duckdb 0.10.1-dev9.0 → 0.10.2-dev0.0

package/src/duckdb/src/function/table/system/duckdb_columns.cpp

@@ -178,7 +178,11 @@ public:
 		return true;
 	}
 	const Value ColumnComment(idx_t col) override {
-		return Value();
+		if (entry.column_comments.empty()) {
+			return Value();
+		}
+		D_ASSERT(entry.column_comments.size() == entry.types.size());
+		return entry.column_comments[col];
 	}
 
 private:
@@ -217,7 +221,7 @@ void ColumnHelper::WriteColumns(idx_t start_index, idx_t start_col, idx_t end_co
 		// column_name, VARCHAR
 		output.SetValue(col++, index, Value(ColumnName(i)));
 		// column_index, INTEGER
-		output.SetValue(col++, index, Value::INTEGER(i + 1));
+		output.SetValue(col++, index, Value::INTEGER(UnsafeNumericCast<int32_t>(i + 1)));
 		// comment, VARCHAR
 		output.SetValue(col++, index, ColumnComment(i));
 		// internal, BOOLEAN

package/src/duckdb/src/function/table/system/duckdb_secrets.cpp

@@ -15,6 +15,7 @@ struct DuckDBSecretsData : public GlobalTableFunctionState {
 	DuckDBSecretsData() : offset(0) {
 	}
 	idx_t offset;
+	duckdb::vector<duckdb::SecretEntry> secrets;
 };
 
 struct DuckDBSecretsBindData : public FunctionData {
@@ -84,8 +85,11 @@ void DuckDBSecretsFunction(ClientContext &context, TableFunctionInput &data_p, D
 	auto &secret_manager = SecretManager::Get(context);
 
 	auto transaction = CatalogTransaction::GetSystemCatalogTransaction(context);
-	auto secrets = secret_manager.AllSecrets(transaction);
 
+	if (data.secrets.empty()) {
+		data.secrets = secret_manager.AllSecrets(transaction);
+	}
+	auto &secrets = data.secrets;
 	if (data.offset >= secrets.size()) {
 		// finished returning values
 		return;

package/src/duckdb/src/function/table/system/duckdb_sequences.cpp

@@ -4,6 +4,7 @@
 #include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/sequence_catalog_entry.hpp"
 #include "duckdb/common/exception.hpp"
+#include "duckdb/common/numeric_utils.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/main/client_data.hpp"
 
@@ -121,7 +122,8 @@ void DuckDBSequencesFunction(ClientContext &context, TableFunctionInput &data_p,
 		// cycle, BOOLEAN
 		output.SetValue(col++, count, Value::BOOLEAN(seq_data.cycle));
 		// last_value, BIGINT
-		output.SetValue(col++, count, seq_data.usage_count == 0 ? Value() : Value::BOOLEAN(seq_data.last_value));
+		output.SetValue(col++, count,
+		                seq_data.usage_count == 0 ? Value() : Value::BOOLEAN(NumericCast<int8_t>(seq_data.last_value)));
 		// sql, LogicalType::VARCHAR
 		output.SetValue(col++, count, Value(seq.ToSQL()));
 

package/src/duckdb/src/function/table/system/duckdb_settings.cpp

@@ -10,6 +10,7 @@ struct DuckDBSettingValue {
 	string value;
 	string description;
 	string input_type;
+	string scope;
 };
 
 struct DuckDBSettingsData : public GlobalTableFunctionState {
@@ -34,6 +35,9 @@ static unique_ptr<FunctionData> DuckDBSettingsBind(ClientContext &context, Table
 	names.emplace_back("input_type");
 	return_types.emplace_back(LogicalType::VARCHAR);
 
+	names.emplace_back("scope");
+	return_types.emplace_back(LogicalType::VARCHAR);
+
 	return nullptr;
 }
 
@@ -46,24 +50,30 @@ unique_ptr<GlobalTableFunctionState> DuckDBSettingsInit(ClientContext &context,
 		auto option = DBConfig::GetOptionByIndex(i);
 		D_ASSERT(option);
 		DuckDBSettingValue value;
+		auto scope = option->set_global ? SettingScope::GLOBAL : SettingScope::LOCAL;
 		value.name = option->name;
 		value.value = option->get_setting(context).ToString();
 		value.description = option->description;
 		value.input_type = EnumUtil::ToString(option->parameter_type);
+		value.scope = EnumUtil::ToString(scope);
 
 		result->settings.push_back(std::move(value));
 	}
 	for (auto &ext_param : config.extension_parameters) {
 		Value setting_val;
 		string setting_str_val;
-		if (context.TryGetCurrentSetting(ext_param.first, setting_val)) {
+		auto scope = SettingScope::GLOBAL;
+		auto lookup_result = context.TryGetCurrentSetting(ext_param.first, setting_val);
+		if (lookup_result) {
 			setting_str_val = setting_val.ToString();
+			scope = lookup_result.GetScope();
 		}
 		DuckDBSettingValue value;
 		value.name = ext_param.first;
 		value.value = std::move(setting_str_val);
 		value.description = ext_param.second.description;
 		value.input_type = ext_param.second.type.ToString();
+		value.scope = EnumUtil::ToString(scope);
 
 		result->settings.push_back(std::move(value));
 	}
@@ -91,6 +101,8 @@ void DuckDBSettingsFunction(ClientContext &context, TableFunctionInput &data_p,
 		output.SetValue(2, count, Value(entry.description));
 		// input_type, LogicalType::VARCHAR
 		output.SetValue(3, count, Value(entry.input_type));
+		// scope, LogicalType::VARCHAR
+		output.SetValue(4, count, Value(entry.scope));
 		count++;
 	}
 	output.SetCardinality(count);

package/src/duckdb/src/function/table/system/test_all_types.cpp

@@ -212,6 +212,70 @@ vector<TestType> TestAllTypesFun::GetTestTypes(bool use_large_enum) {
 	const Value &max = Value::UNION(members, 1, Value::SMALLINT(5));
 	result.emplace_back(union_type, "union", min, max);
 
+	// fixed int array
+	auto fixed_int_array_type = LogicalType::ARRAY(LogicalType::INTEGER, 3);
+	auto fixed_int_min_array_value = Value::ARRAY({Value(LogicalType::INTEGER), 2, 3});
+	auto fixed_int_max_array_value = Value::ARRAY({4, 5, 6});
+	result.emplace_back(fixed_int_array_type, "fixed_int_array", fixed_int_min_array_value, fixed_int_max_array_value);
+
+	// fixed varchar array
+	auto fixed_varchar_array_type = LogicalType::ARRAY(LogicalType::VARCHAR, 3);
+	auto fixed_varchar_min_array_value = Value::ARRAY({Value("a"), Value(LogicalType::VARCHAR), Value("c")});
+	auto fixed_varchar_max_array_value = Value::ARRAY({Value("d"), Value("e"), Value("f")});
+	result.emplace_back(fixed_varchar_array_type, "fixed_varchar_array", fixed_varchar_min_array_value,
+	                    fixed_varchar_max_array_value);
+
+	// fixed nested int array
+	auto fixed_nested_int_array_type = LogicalType::ARRAY(fixed_int_array_type, 3);
+	auto fixed_nested_int_min_array_value =
+	    Value::ARRAY({fixed_int_min_array_value, Value(fixed_int_array_type), fixed_int_min_array_value});
+	auto fixed_nested_int_max_array_value =
+	    Value::ARRAY({fixed_int_max_array_value, fixed_int_min_array_value, fixed_int_max_array_value});
+	result.emplace_back(fixed_nested_int_array_type, "fixed_nested_int_array", fixed_nested_int_min_array_value,
+	                    fixed_nested_int_max_array_value);
+
+	// fixed nested varchar array
+	auto fixed_nested_varchar_array_type = LogicalType::ARRAY(fixed_varchar_array_type, 3);
+	auto fixed_nested_varchar_min_array_value =
+	    Value::ARRAY({fixed_varchar_min_array_value, Value(fixed_varchar_array_type), fixed_varchar_min_array_value});
+	auto fixed_nested_varchar_max_array_value =
+	    Value::ARRAY({fixed_varchar_max_array_value, fixed_varchar_min_array_value, fixed_varchar_max_array_value});
+	result.emplace_back(fixed_nested_varchar_array_type, "fixed_nested_varchar_array",
+	                    fixed_nested_varchar_min_array_value, fixed_nested_varchar_max_array_value);
+
+	// fixed array of structs
+	auto fixed_struct_array_type = LogicalType::ARRAY(struct_type, 3);
+	auto fixed_struct_min_array_value = Value::ARRAY({min_struct_val, max_struct_val, min_struct_val});
+	auto fixed_struct_max_array_value = Value::ARRAY({max_struct_val, min_struct_val, max_struct_val});
+	result.emplace_back(fixed_struct_array_type, "fixed_struct_array", fixed_struct_min_array_value,
+	                    fixed_struct_max_array_value);
+
+	// struct of fixed array
+	auto struct_of_fixed_array_type =
+	    LogicalType::STRUCT({{"a", fixed_int_array_type}, {"b", fixed_varchar_array_type}});
+	auto struct_of_fixed_array_min_value =
+	    Value::STRUCT({{"a", fixed_int_min_array_value}, {"b", fixed_varchar_min_array_value}});
+	auto struct_of_fixed_array_max_value =
+	    Value::STRUCT({{"a", fixed_int_max_array_value}, {"b", fixed_varchar_max_array_value}});
+	result.emplace_back(struct_of_fixed_array_type, "struct_of_fixed_array", struct_of_fixed_array_min_value,
+	                    struct_of_fixed_array_max_value);
+
+	// fixed array of list of int
+	auto fixed_array_of_list_of_int_type = LogicalType::ARRAY(LogicalType::LIST(LogicalType::INTEGER), 3);
+	auto fixed_array_of_list_of_int_min_value = Value::ARRAY({empty_int_list, int_list, empty_int_list});
+	auto fixed_array_of_list_of_int_max_value = Value::ARRAY({int_list, empty_int_list, int_list});
+	result.emplace_back(fixed_array_of_list_of_int_type, "fixed_array_of_int_list",
+	                    fixed_array_of_list_of_int_min_value, fixed_array_of_list_of_int_max_value);
+
+	// list of fixed array of int
+	auto list_of_fixed_array_of_int_type = LogicalType::LIST(fixed_int_array_type);
+	auto list_of_fixed_array_of_int_min_value =
+	    Value::LIST({fixed_int_min_array_value, fixed_int_max_array_value, fixed_int_min_array_value});
+	auto list_of_fixed_array_of_int_max_value =
+	    Value::LIST({fixed_int_max_array_value, fixed_int_min_array_value, fixed_int_max_array_value});
+	result.emplace_back(list_of_fixed_array_of_int_type, "list_of_fixed_int_array",
+	                    list_of_fixed_array_of_int_min_value, list_of_fixed_array_of_int_max_value);
+
 	return result;
 }
 

package/src/duckdb/src/function/table/system/ub_duckdb_table_func_system.cpp

@@ -0,0 +1,23 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/function/table/system/duckdb_columns.cpp>
+#include </Users/carlo/duckdb/src/function/table/system/duckdb_constraints.cpp>
+#include </Users/carlo/duckdb/src/function/table/system/duckdb_databases.cpp>
+#include </Users/carlo/duckdb/src/function/table/system/duckdb_dependencies.cpp>
+#include </Users/carlo/duckdb/src/function/table/system/duckdb_extensions.cpp>
+#include </Users/carlo/duckdb/src/function/table/system/duckdb_functions.cpp>
+#include </Users/carlo/duckdb/src/function/table/system/duckdb_keywords.cpp>
+#include </Users/carlo/duckdb/src/function/table/system/duckdb_indexes.cpp>
+#include </Users/carlo/duckdb/src/function/table/system/duckdb_schemas.cpp>
+#include </Users/carlo/duckdb/src/function/table/system/duckdb_sequences.cpp>
+#include </Users/carlo/duckdb/src/function/table/system/duckdb_settings.cpp>
+#include </Users/carlo/duckdb/src/function/table/system/duckdb_tables.cpp>
+#include </Users/carlo/duckdb/src/function/table/system/duckdb_temporary_files.cpp>
+#include </Users/carlo/duckdb/src/function/table/system/duckdb_types.cpp>
+#include </Users/carlo/duckdb/src/function/table/system/duckdb_views.cpp>
+#include </Users/carlo/duckdb/src/function/table/system/pragma_collations.cpp>
+#include </Users/carlo/duckdb/src/function/table/system/pragma_database_size.cpp>
+#include </Users/carlo/duckdb/src/function/table/system/pragma_metadata_info.cpp>
+#include </Users/carlo/duckdb/src/function/table/system/pragma_storage_info.cpp>
+#include </Users/carlo/duckdb/src/function/table/system/pragma_table_info.cpp>
+#include </Users/carlo/duckdb/src/function/table/system/test_all_types.cpp>
+#include </Users/carlo/duckdb/src/function/table/system/test_vector_types.cpp>

package/src/duckdb/src/function/table/ub_duckdb_func_table.cpp

@@ -0,0 +1,16 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/function/table/arrow.cpp>
+#include </Users/carlo/duckdb/src/function/table/arrow_conversion.cpp>
+#include </Users/carlo/duckdb/src/function/table/checkpoint.cpp>
+#include </Users/carlo/duckdb/src/function/table/glob.cpp>
+#include </Users/carlo/duckdb/src/function/table/range.cpp>
+#include </Users/carlo/duckdb/src/function/table/repeat.cpp>
+#include </Users/carlo/duckdb/src/function/table/repeat_row.cpp>
+#include </Users/carlo/duckdb/src/function/table/copy_csv.cpp>
+#include </Users/carlo/duckdb/src/function/table/read_csv.cpp>
+#include </Users/carlo/duckdb/src/function/table/system_functions.cpp>
+#include </Users/carlo/duckdb/src/function/table/summary.cpp>
+#include </Users/carlo/duckdb/src/function/table/table_scan.cpp>
+#include </Users/carlo/duckdb/src/function/table/pragma_last_profiling_output.cpp>
+#include </Users/carlo/duckdb/src/function/table/pragma_detailed_profiling_output.cpp>
+#include </Users/carlo/duckdb/src/function/table/unnest.cpp>

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,17 @@
+#ifndef DUCKDB_PATCH_VERSION
+#define DUCKDB_PATCH_VERSION "1"
+#endif
+#ifndef DUCKDB_MINOR_VERSION
+#define DUCKDB_MINOR_VERSION 10
+#endif
+#ifndef DUCKDB_MAJOR_VERSION
+#define DUCKDB_MAJOR_VERSION 0
+#endif
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "v0.10.0"
+#define DUCKDB_VERSION "v0.10.1"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "20b1486d11"
+#define DUCKDB_SOURCE_ID "4a89d97db8"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/function/table/version/ub_duckdb_func_table_version.cpp

@@ -0,0 +1,2 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/function/table/version/pragma_version.cpp>

package/src/duckdb/src/function/ub_duckdb_function.cpp

@@ -0,0 +1,14 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/function/built_in_functions.cpp>
+#include </Users/carlo/duckdb/src/function/cast_rules.cpp>
+#include </Users/carlo/duckdb/src/function/compression_config.cpp>
+#include </Users/carlo/duckdb/src/function/function.cpp>
+#include </Users/carlo/duckdb/src/function/function_binder.cpp>
+#include </Users/carlo/duckdb/src/function/function_set.cpp>
+#include </Users/carlo/duckdb/src/function/pragma_function.cpp>
+#include </Users/carlo/duckdb/src/function/macro_function.cpp>
+#include </Users/carlo/duckdb/src/function/scalar_macro_function.cpp>
+#include </Users/carlo/duckdb/src/function/table_macro_function.cpp>
+#include </Users/carlo/duckdb/src/function/scalar_function.cpp>
+#include </Users/carlo/duckdb/src/function/table_function.cpp>
+#include </Users/carlo/duckdb/src/function/udf_function.cpp>

package/src/duckdb/src/include/duckdb/catalog/catalog.hpp

@@ -17,6 +17,7 @@
 #include "duckdb/common/optional_ptr.hpp"
 #include "duckdb/common/enums/on_entry_not_found.hpp"
 #include "duckdb/common/exception/catalog_exception.hpp"
+#include "duckdb/common/enums/catalog_lookup_behavior.hpp"
 #include <functional>
 
 namespace duckdb {
@@ -191,6 +192,10 @@ public:
 	DUCKDB_API optional_ptr<SchemaCatalogEntry> GetSchema(ClientContext &context, const string &name,
 	                                                      OnEntryNotFound if_not_found,
 	                                                      QueryErrorContext error_context = QueryErrorContext());
+	//! Overloadable method for giving warnings on ambiguous naming id.tab due to a database and schema with name id
+	DUCKDB_API virtual bool CheckAmbiguousCatalogOrSchema(ClientContext &context, const string &name) {
+		return !!GetSchema(context, name, OnEntryNotFound::RETURN_NULL);
+	}
 	DUCKDB_API SchemaCatalogEntry &GetSchema(CatalogTransaction transaction, const string &name,
 	                                         QueryErrorContext error_context = QueryErrorContext());
 	DUCKDB_API virtual optional_ptr<SchemaCatalogEntry>
@@ -273,6 +278,11 @@ public:
 	virtual bool InMemory() = 0;
 	virtual string GetDBPath() = 0;
 
+	//! Whether or not this catalog should search a specific type with the standard priority
+	DUCKDB_API virtual CatalogLookupBehavior CatalogTypeLookupRule(CatalogType type) const {
+		return CatalogLookupBehavior::STANDARD;
+	}
+
 public:
 	template <class T>
 	static optional_ptr<T> GetEntry(ClientContext &context, const string &catalog_name, const string &schema_name,
@@ -348,7 +358,7 @@ private:
 public:
 	template <class TARGET>
 	TARGET &Cast() {
-		D_ASSERT(dynamic_cast<TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<TARGET &>(*this);
 	}
 

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/view_catalog_entry.hpp

@@ -38,6 +38,8 @@ public:
 	vector<LogicalType> types;
 	//! The returned names of the view
 	vector<string> names;
+	//! The comments on the columns of the view: can be empty if there are no comments
+	vector<Value> column_comments;
 
 public:
 	unique_ptr<CreateInfo> GetInfo() const override;

package/src/duckdb/src/include/duckdb/catalog/catalog_entry.hpp

@@ -95,7 +95,7 @@ public:
 public:
 	template <class TARGET>
 	TARGET &Cast() {
-		D_ASSERT(dynamic_cast<TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<TARGET &>(*this);
 	}
 	template <class TARGET>

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

@@ -8,8 +8,10 @@
 
 #pragma once
 
-#include "duckdb/common/common.hpp"
+#include "duckdb/common/assert.hpp"
+#include "duckdb/common/helper.hpp"
 #include "duckdb/common/optional_ptr.hpp"
+#include "duckdb/common/shared_ptr.hpp"
 
 namespace duckdb {
 class Allocator;
@@ -29,7 +31,7 @@ struct PrivateAllocatorData {
 
 	template <class TARGET>
 	TARGET &Cast() {
-		D_ASSERT(dynamic_cast<TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<TARGET &>(*this);
 	}
 	template <class TARGET>
@@ -95,16 +97,10 @@ public:
 	AllocatedData Allocate(idx_t size) {
 		return AllocatedData(*this, AllocateData(size), size);
 	}
-	static data_ptr_t DefaultAllocate(PrivateAllocatorData *private_data, idx_t size) {
-		return data_ptr_cast(malloc(size));
-	}
-	static void DefaultFree(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t size) {
-		free(pointer);
-	}
+	static data_ptr_t DefaultAllocate(PrivateAllocatorData *private_data, idx_t size);
+	static void DefaultFree(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t size);
 	static data_ptr_t DefaultReallocate(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t old_size,
-	                                    idx_t size) {
-		return data_ptr_cast(realloc(pointer, size));
-	}
+	                                    idx_t size);
 	static Allocator &Get(ClientContext &context);
 	static Allocator &Get(DatabaseInstance &db);
 	static Allocator &Get(AttachedDatabase &db);
@@ -117,6 +113,7 @@ public:
 	DUCKDB_API static shared_ptr<Allocator> &DefaultAllocatorReference();
 
 	static void ThreadFlush(idx_t threshold);
+	static void FlushAll();
 
 private:
 	allocate_function_ptr_t allocate_function;

package/src/duckdb/src/include/duckdb/common/arrow/appender/enum_data.hpp

@@ -45,13 +45,13 @@ struct ArrowEnumData : public ArrowScalarBaseData<TGT> {
 
 			// append the offset data
 			auto current_offset = last_offset + string_length;
-			offset_data[offset_idx] = current_offset;
+			offset_data[offset_idx] = UnsafeNumericCast<uint32_t>(current_offset);
 
 			// resize the string buffer if required, and write the string data
 			append_data.aux_buffer.resize(current_offset);
 			WriteData(append_data.aux_buffer.data() + last_offset, data[i]);
 
-			last_offset = current_offset;
+			last_offset = UnsafeNumericCast<uint32_t>(current_offset);
 		}
 		append_data.row_count += size;
 	}

package/src/duckdb/src/include/duckdb/common/arrow/appender/fixed_size_list_data.hpp

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "duckdb/common/arrow/appender/append_data.hpp"
+
+namespace duckdb {
+
+struct ArrowFixedSizeListData {
+public:
+	static void Initialize(ArrowAppendData &result, const LogicalType &type, idx_t capacity);
+	static void Append(ArrowAppendData &append_data, Vector &input, idx_t from, idx_t to, idx_t input_size);
+	static void Finalize(ArrowAppendData &append_data, const LogicalType &type, ArrowArray *result);
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/arrow/appender/list.hpp

@@ -1,5 +1,6 @@
 #include "duckdb/common/arrow/appender/bool_data.hpp"
 #include "duckdb/common/arrow/appender/enum_data.hpp"
+#include "duckdb/common/arrow/appender/fixed_size_list_data.hpp"
 #include "duckdb/common/arrow/appender/list_data.hpp"
 #include "duckdb/common/arrow/appender/map_data.hpp"
 #include "duckdb/common/arrow/appender/scalar_data.hpp"

package/src/duckdb/src/include/duckdb/common/arrow/appender/list_data.hpp

@@ -79,7 +79,7 @@ public:
 			offset_data[offset_idx] = last_offset;
 
 			for (idx_t k = 0; k < list_length; k++) {
-				child_sel.push_back(data[source_idx].offset + k);
+				child_sel.push_back(UnsafeNumericCast<sel_t>(data[source_idx].offset + k));
 			}
 		}
 	}

package/src/duckdb/src/include/duckdb/common/arrow/appender/varchar_data.hpp

@@ -85,13 +85,13 @@ struct ArrowVarcharData {
 				    "%u but the offset of %lu exceeds this.",
 				    NumericLimits<int32_t>::Maximum(), current_offset);
 			}
-			offset_data[offset_idx] = current_offset;
+			offset_data[offset_idx] = UnsafeNumericCast<BUFTYPE>(current_offset);
 
 			// resize the string buffer if required, and write the string data
 			append_data.aux_buffer.resize(current_offset);
 			OP::WriteData(append_data.aux_buffer.data() + last_offset, data[source_idx]);
 
-			last_offset = current_offset;
+			last_offset = UnsafeNumericCast<BUFTYPE>(current_offset);
 		}
 		append_data.row_count += size;
 	}

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

@@ -189,10 +189,10 @@ private:
 	// Sign bit extension
 	template <class T, class T_U = typename MakeUnsigned<T>::type>
 	static void SignExtend(data_ptr_t dst, bitpacking_width_t width) {
-		T const mask = T_U(1) << (width - 1);
+		T const mask = UnsafeNumericCast<T>(T_U(1) << (width - 1));
 		for (idx_t i = 0; i < BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE; ++i) {
 			T value = Load<T>(dst + i * sizeof(T));
-			value = value & ((T_U(1) << width) - T_U(1));
+			value = UnsafeNumericCast<T>(value & ((T_U(1) << width) - T_U(1)));
 			T result = (value ^ mask) - mask;
 			Store(result, dst + i * sizeof(T));
 		}

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

@@ -9,6 +9,7 @@
 #pragma once
 
 #include "duckdb/common/common.hpp"
+#include "duckdb/common/numeric_utils.hpp"
 
 namespace duckdb {
 
@@ -33,9 +34,12 @@ static inline T BSwap(const T &x) {
 	} else if (sizeof(T) == 2) {
 		return BSWAP16(x);
 	} else if (sizeof(T) == 4) {
-		return BSWAP32(x);
+		// this check is superfluous as the branch is not taken for small return types but the compiler does not realize
+		// that
+		return UnsafeNumericCast<T>(BSWAP32(x));
 	} else {
-		return BSWAP64(x);
+		// see above
+		return UnsafeNumericCast<T>(BSWAP64(x));
 	}
 }
 

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

@@ -72,6 +72,8 @@ enum class CSVState : uint8_t;
 
 enum class CTEMaterialize : uint8_t;
 
+enum class CatalogLookupBehavior : uint8_t;
+
 enum class CatalogType : uint8_t;
 
 enum class CheckpointAbort : uint8_t;
@@ -154,6 +156,8 @@ enum class JoinType : uint8_t;
 
 enum class KeywordCategory : uint8_t;
 
+enum class LimitNodeType : uint8_t;
+
 enum class LoadType : uint8_t;
 
 enum class LogicalOperatorType : uint8_t;
@@ -212,6 +216,8 @@ enum class PragmaType : uint8_t;
 
 enum class PreparedParamType : uint8_t;
 
+enum class PreparedStatementMode : uint8_t;
+
 enum class ProfilerPrintFormat : uint8_t;
 
 enum class QuantileSerializationType : uint8_t;
@@ -242,6 +248,8 @@ enum class SetScope : uint8_t;
 
 enum class SetType : uint8_t;
 
+enum class SettingScope : uint8_t;
+
 enum class ShowType : uint8_t;
 
 enum class SimplifiedTokenType : uint8_t;
@@ -369,6 +377,9 @@ const char* EnumUtil::ToChars<CSVState>(CSVState value);
 template<>
 const char* EnumUtil::ToChars<CTEMaterialize>(CTEMaterialize value);
 
+template<>
+const char* EnumUtil::ToChars<CatalogLookupBehavior>(CatalogLookupBehavior value);
+
 template<>
 const char* EnumUtil::ToChars<CatalogType>(CatalogType value);
 
@@ -492,6 +503,9 @@ const char* EnumUtil::ToChars<JoinType>(JoinType value);
 template<>
 const char* EnumUtil::ToChars<KeywordCategory>(KeywordCategory value);
 
+template<>
+const char* EnumUtil::ToChars<LimitNodeType>(LimitNodeType value);
+
 template<>
 const char* EnumUtil::ToChars<LoadType>(LoadType value);
 
@@ -579,6 +593,9 @@ const char* EnumUtil::ToChars<PragmaType>(PragmaType value);
 template<>
 const char* EnumUtil::ToChars<PreparedParamType>(PreparedParamType value);
 
+template<>
+const char* EnumUtil::ToChars<PreparedStatementMode>(PreparedStatementMode value);
+
 template<>
 const char* EnumUtil::ToChars<ProfilerPrintFormat>(ProfilerPrintFormat value);
 
@@ -624,6 +641,9 @@ const char* EnumUtil::ToChars<SetScope>(SetScope value);
 template<>
 const char* EnumUtil::ToChars<SetType>(SetType value);
 
+template<>
+const char* EnumUtil::ToChars<SettingScope>(SettingScope value);
+
 template<>
 const char* EnumUtil::ToChars<ShowType>(ShowType value);
 
@@ -784,6 +804,9 @@ CSVState EnumUtil::FromString<CSVState>(const char *value);
 template<>
 CTEMaterialize EnumUtil::FromString<CTEMaterialize>(const char *value);
 
+template<>
+CatalogLookupBehavior EnumUtil::FromString<CatalogLookupBehavior>(const char *value);
+
 template<>
 CatalogType EnumUtil::FromString<CatalogType>(const char *value);
 
@@ -907,6 +930,9 @@ JoinType EnumUtil::FromString<JoinType>(const char *value);
 template<>
 KeywordCategory EnumUtil::FromString<KeywordCategory>(const char *value);
 
+template<>
+LimitNodeType EnumUtil::FromString<LimitNodeType>(const char *value);
+
 template<>
 LoadType EnumUtil::FromString<LoadType>(const char *value);
 
@@ -994,6 +1020,9 @@ PragmaType EnumUtil::FromString<PragmaType>(const char *value);
 template<>
 PreparedParamType EnumUtil::FromString<PreparedParamType>(const char *value);
 
+template<>
+PreparedStatementMode EnumUtil::FromString<PreparedStatementMode>(const char *value);
+
 template<>
 ProfilerPrintFormat EnumUtil::FromString<ProfilerPrintFormat>(const char *value);
 
@@ -1039,6 +1068,9 @@ SetScope EnumUtil::FromString<SetScope>(const char *value);
 template<>
 SetType EnumUtil::FromString<SetType>(const char *value);
 
+template<>
+SettingScope EnumUtil::FromString<SettingScope>(const char *value);
+
 template<>
 ShowType EnumUtil::FromString<ShowType>(const char *value);
 

package/src/duckdb/src/include/duckdb/common/enums/catalog_lookup_behavior.hpp

@@ -0,0 +1,21 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/enums/catalog_lookup_behavior.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/constants.hpp"
+
+namespace duckdb {
+
+//! Enum used for indicating lookup behavior of specific catalog types
+// STANDARD means the catalog lookups are performed in a regular manner (i.e. according to the users' search path)
+// LOWER_PRIORITY means the catalog lookups are de-prioritized and we do lookups in other catalogs first
+// NEVER_LOOKUP means we never do lookups for this specific type in this catalog
+enum class CatalogLookupBehavior : uint8_t { STANDARD = 0, LOWER_PRIORITY = 1, NEVER_LOOKUP = 2 };
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/enums/logical_operator_type.hpp

@@ -28,7 +28,6 @@ enum class LogicalOperatorType : uint8_t {
 	LOGICAL_COPY_TO_FILE = 10,
 	LOGICAL_DISTINCT = 11,
 	LOGICAL_SAMPLE = 12,
-	LOGICAL_LIMIT_PERCENT = 13,
 	LOGICAL_PIVOT = 14,
 	LOGICAL_COPY_DATABASE = 15,
 

package/src/duckdb/src/include/duckdb/common/enums/physical_operator_type.hpp

@@ -31,7 +31,6 @@ enum class PhysicalOperatorType : uint8_t {
 	PROJECTION,
 	COPY_TO_FILE,
 	BATCH_COPY_TO_FILE,
-	FIXED_BATCH_COPY_TO_FILE,
 	RESERVOIR_SAMPLE,
 	STREAMING_SAMPLE,
 	STREAMING_WINDOW,
@@ -113,6 +112,7 @@ enum class PhysicalOperatorType : uint8_t {
 	RESULT_COLLECTOR,
 	RESET,
 	EXTENSION,
+	VERIFY_VECTOR,
 
 	// -----------------------------
 	// Secret