duckdb 0.10.3-dev0.0 → 0.10.3-dev6.0

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

@@ -30,6 +30,7 @@ void BuiltinFunctions::RegisterSQLiteFunctions() {
 	DuckDBMemoryFun::RegisterFunction(*this);
 	DuckDBOptimizersFun::RegisterFunction(*this);
 	DuckDBSecretsFun::RegisterFunction(*this);
+	DuckDBWhichSecretFun::RegisterFunction(*this);
 	DuckDBSequencesFun::RegisterFunction(*this);
 	DuckDBSettingsFun::RegisterFunction(*this);
 	DuckDBTablesFun::RegisterFunction(*this);

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

@@ -202,8 +202,9 @@ unique_ptr<NodeStatistics> TableScanCardinality(ClientContext &context, const Fu
 	auto &bind_data = bind_data_p->Cast<TableScanBindData>();
 	auto &local_storage = LocalStorage::Get(context, bind_data.table.catalog);
 	auto &storage = bind_data.table.GetStorage();
-	idx_t estimated_cardinality = storage.info->cardinality + local_storage.AddedRows(bind_data.table.GetStorage());
-	return make_uniq<NodeStatistics>(storage.info->cardinality, estimated_cardinality);
+	idx_t table_rows = storage.GetTotalRows();
+	idx_t estimated_cardinality = table_rows + local_storage.AddedRows(bind_data.table.GetStorage());
+	return make_uniq<NodeStatistics>(table_rows, estimated_cardinality);
 }
 
 //===--------------------------------------------------------------------===//
@@ -263,7 +264,8 @@ static void RewriteIndexExpression(Index &index, LogicalGet &get, Expression &ex
 		auto &bound_colref = expr.Cast<BoundColumnRefExpression>();
 		// bound column ref: rewrite to fit in the current set of bound column ids
 		bound_colref.binding.table_index = get.table_index;
-		column_t referenced_column = index.column_ids[bound_colref.binding.column_index];
+		auto &column_ids = index.GetColumnIds();
+		column_t referenced_column = column_ids[bound_colref.binding.column_index];
 		// search for the referenced column in the set of column_ids
 		for (idx_t i = 0; i < get.column_ids.size(); i++) {
 			if (get.column_ids[i] == referenced_column) {
@@ -306,22 +308,13 @@ void TableScanPushdownComplexFilter(ClientContext &context, LogicalGet &get, Fun
 		return;
 	}
 
-	// behold
-	storage.info->indexes.Scan([&](Index &index) {
-		// first rewrite the index expression so the ColumnBindings align with the column bindings of the current table
-
-		if (index.IsUnknown()) {
-			// unknown index: skip
-			return false;
-		}
-
-		if (index.index_type != ART::TYPE_NAME) {
-			// only ART indexes are supported for now
-			return false;
-		}
-
-		auto &art_index = index.Cast<ART>();
+	auto checkpoint_lock = storage.GetSharedCheckpointLock();
+	auto &info = storage.GetDataTableInfo();
+	auto &transaction = Transaction::Get(context, bind_data.table.catalog);
 
+	// bind and scan any ART indexes
+	info->GetIndexes().BindAndScan<ART>(context, *info, [&](ART &art_index) {
+		// first rewrite the index expression so the ColumnBindings align with the column bindings of the current table
 		if (art_index.unbound_expressions.size() > 1) {
 			// NOTE: index scans are not (yet) supported for compound index keys
 			return false;
@@ -336,8 +329,6 @@ void TableScanPushdownComplexFilter(ClientContext &context, LogicalGet &get, Fun
 		}
 
 		// try to find a matching index for any of the filter expressions
-		auto &transaction = Transaction::Get(context, bind_data.table.catalog);
-
 		for (auto &filter : filters) {
 			auto index_state = art_index.TryInitializeScan(transaction, *index_expression, *filter);
 			if (index_state != nullptr) {

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

@@ -63,7 +63,7 @@ static unique_ptr<LocalTableFunctionState> UnnestLocalInit(ExecutionContext &con
 static unique_ptr<GlobalTableFunctionState> UnnestInit(ClientContext &context, TableFunctionInitInput &input) {
 	auto &bind_data = input.bind_data->Cast<UnnestBindData>();
 	auto result = make_uniq<UnnestGlobalState>();
-	auto ref = make_uniq<BoundReferenceExpression>(bind_data.input_type, 0);
+	auto ref = make_uniq<BoundReferenceExpression>(bind_data.input_type, 0U);
 	auto bound_unnest = make_uniq<BoundUnnestExpression>(ListType::GetChildType(bind_data.input_type));
 	bound_unnest->child = std::move(ref);
 	result->select_list.push_back(std::move(bound_unnest));

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

@@ -1,5 +1,5 @@
 #ifndef DUCKDB_PATCH_VERSION
-#define DUCKDB_PATCH_VERSION "2"
+#define DUCKDB_PATCH_VERSION "3"
 #endif
 #ifndef DUCKDB_MINOR_VERSION
 #define DUCKDB_MINOR_VERSION 10
@@ -8,10 +8,10 @@
 #define DUCKDB_MAJOR_VERSION 0
 #endif
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "v0.10.2"
+#define DUCKDB_VERSION "v0.10.3"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "1601d94f94"
+#define DUCKDB_SOURCE_ID "70fd6a8a24"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/function/table_function.cpp

@@ -18,8 +18,8 @@ TableFunction::TableFunction(string name, vector<LogicalType> arguments, table_f
       init_global(init_global), init_local(init_local), function(function), in_out_function(nullptr),
       in_out_function_final(nullptr), statistics(nullptr), dependency(nullptr), cardinality(nullptr),
       pushdown_complex_filter(nullptr), to_string(nullptr), table_scan_progress(nullptr), get_batch_index(nullptr),
-      get_bind_info(nullptr), serialize(nullptr), deserialize(nullptr), projection_pushdown(false),
-      filter_pushdown(false), filter_prune(false) {
+      get_bind_info(nullptr), type_pushdown(nullptr), get_multi_file_reader(nullptr), serialize(nullptr),
+      deserialize(nullptr), projection_pushdown(false), filter_pushdown(false), filter_prune(false) {
 }
 
 TableFunction::TableFunction(const vector<LogicalType> &arguments, table_function_t function,
@@ -31,8 +31,9 @@ TableFunction::TableFunction()
     : SimpleNamedParameterFunction("", {}), bind(nullptr), bind_replace(nullptr), init_global(nullptr),
       init_local(nullptr), function(nullptr), in_out_function(nullptr), statistics(nullptr), dependency(nullptr),
       cardinality(nullptr), pushdown_complex_filter(nullptr), to_string(nullptr), table_scan_progress(nullptr),
-      get_batch_index(nullptr), get_bind_info(nullptr), serialize(nullptr), deserialize(nullptr),
-      projection_pushdown(false), filter_pushdown(false), filter_prune(false) {
+      get_batch_index(nullptr), get_bind_info(nullptr), type_pushdown(nullptr), get_multi_file_reader(nullptr),
+      serialize(nullptr), deserialize(nullptr), projection_pushdown(false), filter_pushdown(false),
+      filter_prune(false) {
 }
 
 bool TableFunction::Equal(const TableFunction &rhs) const {

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

@@ -229,16 +229,6 @@ public:
 	                                         const string &schema, const string &name,
 	                                         QueryErrorContext error_context = QueryErrorContext());
 
-	//! Gets the "schema.name" entry without a specified type, if entry does not exist an exception is thrown
-	DUCKDB_API CatalogEntry &GetEntry(ClientContext &context, const string &schema, const string &name);
-
-	//! Fetches a logical type from the catalog
-	DUCKDB_API LogicalType GetType(ClientContext &context, const string &schema, const string &names,
-	                               OnEntryNotFound if_not_found);
-
-	DUCKDB_API static LogicalType GetType(ClientContext &context, const string &catalog_name, const string &schema,
-	                                      const string &name);
-
 	template <class T>
 	optional_ptr<T> GetEntry(ClientContext &context, const string &schema_name, const string &name,
 	                         OnEntryNotFound if_not_found, QueryErrorContext error_context = QueryErrorContext()) {
@@ -262,6 +252,7 @@ public:
 	DUCKDB_API optional_ptr<CatalogEntry> AddFunction(ClientContext &context, CreateFunctionInfo &info);
 
 	//! Alter an existing entry in the catalog.
+	DUCKDB_API void Alter(CatalogTransaction transaction, AlterInfo &info);
 	DUCKDB_API void Alter(ClientContext &context, AlterInfo &info);
 
 	virtual unique_ptr<PhysicalOperator> PlanCreateTableAs(ClientContext &context, LogicalCreateTable &op,

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

@@ -14,7 +14,7 @@ namespace duckdb {
 
 //! Wrapper class to allow copying a DuckIndexEntry (for altering the DuckIndexEntry metadata such as comments)
 struct IndexDataTableInfo {
-	IndexDataTableInfo(shared_ptr<DataTableInfo> &info_p, const string &index_name_p);
+	IndexDataTableInfo(shared_ptr<DataTableInfo> info_p, const string &index_name_p);
 	~IndexDataTableInfo();
 
 	//! Pointer to the DataTableInfo

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

@@ -45,7 +45,7 @@ public:
 
 	optional_ptr<CatalogEntry> CreateTable(CatalogTransaction transaction, BoundCreateTableInfo &info) override;
 	optional_ptr<CatalogEntry> CreateFunction(CatalogTransaction transaction, CreateFunctionInfo &info) override;
-	optional_ptr<CatalogEntry> CreateIndex(ClientContext &context, CreateIndexInfo &info,
+	optional_ptr<CatalogEntry> CreateIndex(CatalogTransaction transaction, CreateIndexInfo &info,
 	                                       TableCatalogEntry &table) override;
 	optional_ptr<CatalogEntry> CreateView(CatalogTransaction transaction, CreateViewInfo &info) override;
 	optional_ptr<CatalogEntry> CreateSequence(CatalogTransaction transaction, CreateSequenceInfo &info) override;
@@ -57,7 +57,7 @@ public:
 	                                                CreatePragmaFunctionInfo &info) override;
 	optional_ptr<CatalogEntry> CreateCollation(CatalogTransaction transaction, CreateCollationInfo &info) override;
 	optional_ptr<CatalogEntry> CreateType(CatalogTransaction transaction, CreateTypeInfo &info) override;
-	void Alter(ClientContext &context, AlterInfo &info) override;
+	void Alter(CatalogTransaction transaction, AlterInfo &info) override;
 	void Scan(ClientContext &context, CatalogType type, const std::function<void(CatalogEntry &)> &callback) override;
 	void Scan(CatalogType type, const std::function<void(CatalogEntry &)> &callback) override;
 	void DropEntry(ClientContext &context, DropInfo &info) override;

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

@@ -17,15 +17,14 @@ class DuckTableEntry : public TableCatalogEntry {
 public:
 	//! Create a TableCatalogEntry and initialize storage for it
 	DuckTableEntry(Catalog &catalog, SchemaCatalogEntry &schema, BoundCreateTableInfo &info,
-	               std::shared_ptr<DataTable> inherited_storage = nullptr);
+	               shared_ptr<DataTable> inherited_storage = nullptr);
 
 public:
 	unique_ptr<CatalogEntry> AlterEntry(ClientContext &context, AlterInfo &info) override;
+	unique_ptr<CatalogEntry> AlterEntry(CatalogTransaction, AlterInfo &info) override;
 	void UndoAlter(ClientContext &context, AlterInfo &info) override;
 	//! Returns the underlying storage of the table
 	DataTable &GetStorage() override;
-	//! Returns a list of the bound constraints of the table
-	const vector<unique_ptr<BoundConstraint>> &GetBoundConstraints() override;
 
 	//! Get statistics of a column (physical or virtual) within the table
 	unique_ptr<BaseStatistics> GetStatistics(ClientContext &context, column_t column_id) override;
@@ -55,18 +54,17 @@ private:
 	unique_ptr<CatalogEntry> ChangeColumnType(ClientContext &context, ChangeColumnTypeInfo &info);
 	unique_ptr<CatalogEntry> SetNotNull(ClientContext &context, SetNotNullInfo &info);
 	unique_ptr<CatalogEntry> DropNotNull(ClientContext &context, DropNotNullInfo &info);
-	unique_ptr<CatalogEntry> AddForeignKeyConstraint(ClientContext &context, AlterForeignKeyInfo &info);
+	unique_ptr<CatalogEntry> AddForeignKeyConstraint(optional_ptr<ClientContext> context, AlterForeignKeyInfo &info);
 	unique_ptr<CatalogEntry> DropForeignKeyConstraint(ClientContext &context, AlterForeignKeyInfo &info);
 	unique_ptr<CatalogEntry> SetColumnComment(ClientContext &context, SetColumnCommentInfo &info);
 
 	void UpdateConstraintsOnColumnDrop(const LogicalIndex &removed_index, const vector<LogicalIndex> &adjusted_indices,
-	                                   const RemoveColumnInfo &info, CreateTableInfo &create_info, bool is_generated);
+	                                   const RemoveColumnInfo &info, CreateTableInfo &create_info,
+	                                   const vector<unique_ptr<BoundConstraint>> &bound_constraints, bool is_generated);
 
 private:
 	//! A reference to the underlying storage unit used for this table
-	std::shared_ptr<DataTable> storage;
-	//! A list of constraints that are part of this table
-	vector<unique_ptr<BoundConstraint>> bound_constraints;
+	shared_ptr<DataTable> storage;
 	//! Manages dependencies of the individual columns of the table
 	ColumnDependencyManager column_dependency_manager;
 };

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

@@ -21,6 +21,7 @@ public:
 		description = std::move(info.description);
 		parameter_names = std::move(info.parameter_names);
 		example = std::move(info.example);
+		this->dependencies = info.dependencies;
 	}
 
 	//! The description (if any)

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

@@ -58,8 +58,9 @@ public:
 	string ToSQL() const override;
 
 	//! Creates an index with the given name in the schema
-	virtual optional_ptr<CatalogEntry> CreateIndex(ClientContext &context, CreateIndexInfo &info,
+	virtual optional_ptr<CatalogEntry> CreateIndex(CatalogTransaction transaction, CreateIndexInfo &info,
 	                                               TableCatalogEntry &table) = 0;
+	optional_ptr<CatalogEntry> CreateIndex(ClientContext &context, CreateIndexInfo &info, TableCatalogEntry &table);
 	//! Create a scalar or aggregate function within the given schema
 	virtual optional_ptr<CatalogEntry> CreateFunction(CatalogTransaction transaction, CreateFunctionInfo &info) = 0;
 	//! Creates a table with the given name in the schema
@@ -91,7 +92,7 @@ public:
 	virtual void DropEntry(ClientContext &context, DropInfo &info) = 0;
 
 	//! Alters a catalog entry
-	virtual void Alter(ClientContext &context, AlterInfo &info) = 0;
+	virtual void Alter(CatalogTransaction transaction, AlterInfo &info) = 0;
 
 	CatalogTransaction GetCatalogTransaction(ClientContext &context);
 };

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

@@ -15,13 +15,10 @@
 
 namespace duckdb {
 class DuckTransaction;
+class SequenceCatalogEntry;
 
 struct SequenceValue {
-	SequenceValue() : usage_count(0), counter(-1) {
-	}
-	SequenceValue(uint64_t usage_count, int64_t counter) : usage_count(usage_count), counter(counter) {
-	}
-
+	SequenceCatalogEntry *entry;
 	uint64_t usage_count;
 	int64_t counter;
 };

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

@@ -37,6 +37,7 @@ struct SetColumnCommentInfo;
 class TableFunction;
 struct FunctionData;
 
+class Binder;
 class TableColumnInfo;
 struct ColumnSegmentInfo;
 class TableStorageInfo;
@@ -74,11 +75,9 @@ public:
 	DUCKDB_API const ColumnList &GetColumns() const;
 	//! Returns the underlying storage of the table
 	virtual DataTable &GetStorage();
-	//! Returns a list of the bound constraints of the table
-	virtual const vector<unique_ptr<BoundConstraint>> &GetBoundConstraints();
 
 	//! Returns a list of the constraints of the table
-	DUCKDB_API const vector<unique_ptr<Constraint>> &GetConstraints();
+	DUCKDB_API const vector<unique_ptr<Constraint>> &GetConstraints() const;
 	DUCKDB_API string ToSQL() const override;
 
 	//! Get statistics of a column (physical or virtual) within the table
@@ -105,7 +104,7 @@ public:
 	//! Returns the storage info of this table
 	virtual TableStorageInfo GetStorageInfo(ClientContext &context) = 0;
 
-	virtual void BindUpdateConstraints(LogicalGet &get, LogicalProjection &proj, LogicalUpdate &update,
+	virtual void BindUpdateConstraints(Binder &binder, LogicalGet &get, LogicalProjection &proj, LogicalUpdate &update,
 	                                   ClientContext &context);
 
 protected:

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

@@ -26,6 +26,8 @@ public:
 
 	LogicalType user_type;
 
+	bind_type_modifiers_function_t bind_modifiers;
+
 public:
 	unique_ptr<CreateInfo> GetInfo() const override;
 	unique_ptr<CatalogEntry> Copy(ClientContext &context) const override;

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

@@ -27,6 +27,7 @@ class Serializer;
 class Deserializer;
 class Value;
 
+struct CatalogTransaction;
 struct CreateInfo;
 
 //! Abstract base class of an entry in the catalog
@@ -54,6 +55,8 @@ public:
 	atomic<transaction_t> timestamp;
 	//! (optional) comment on this entry
 	Value comment;
+	//! (optional) extra data associated with this entry
+	unordered_map<string, string> tags;
 
 private:
 	//! Child entry
@@ -63,6 +66,7 @@ private:
 
 public:
 	virtual unique_ptr<CatalogEntry> AlterEntry(ClientContext &context, AlterInfo &info);
+	virtual unique_ptr<CatalogEntry> AlterEntry(CatalogTransaction transaction, AlterInfo &info);
 	virtual void UndoAlter(ClientContext &context, AlterInfo &info);
 
 	virtual unique_ptr<CatalogEntry> Copy(ClientContext &context) const;

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

@@ -0,0 +1,72 @@
+#pragma once
+
+#include <functional>
+#include "duckdb/common/enums/catalog_type.hpp"
+#include "duckdb/common/enums/on_entry_not_found.hpp"
+#include "duckdb/common/string.hpp"
+#include "duckdb/parser/query_error_context.hpp"
+#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
+
+namespace duckdb {
+
+class ClientContext;
+class Catalog;
+class CatalogEntry;
+
+using catalog_entry_callback_t = std::function<void(CatalogEntry &)>;
+
+// Wraps the Catalog::GetEntry method
+class CatalogEntryRetriever {
+public:
+	explicit CatalogEntryRetriever(ClientContext &context) : context(context) {
+	}
+	CatalogEntryRetriever(const CatalogEntryRetriever &other) : callback(other.callback), context(other.context) {
+	}
+
+public:
+	optional_ptr<CatalogEntry> GetEntry(CatalogType type, const string &catalog, const string &schema,
+	                                    const string &name,
+	                                    OnEntryNotFound on_entry_not_found = OnEntryNotFound::THROW_EXCEPTION,
+	                                    QueryErrorContext error_context = QueryErrorContext());
+
+	optional_ptr<CatalogEntry> GetEntry(CatalogType type, Catalog &catalog, const string &schema, const string &name,
+	                                    OnEntryNotFound on_entry_not_found = OnEntryNotFound::THROW_EXCEPTION,
+	                                    QueryErrorContext error_context = QueryErrorContext());
+
+	LogicalType GetType(const string &catalog, const string &schema, const string &name,
+	                    OnEntryNotFound on_entry_not_found = OnEntryNotFound::RETURN_NULL);
+	LogicalType GetType(Catalog &catalog, const string &schema, const string &name,
+	                    OnEntryNotFound on_entry_not_found = OnEntryNotFound::RETURN_NULL);
+
+	optional_ptr<SchemaCatalogEntry> GetSchema(const string &catalog, const string &name,
+	                                           OnEntryNotFound on_entry_not_found = OnEntryNotFound::THROW_EXCEPTION,
+	                                           QueryErrorContext error_context = QueryErrorContext());
+
+	void SetCallback(catalog_entry_callback_t callback) {
+		this->callback = std::move(callback);
+	}
+	catalog_entry_callback_t GetCallback() {
+		return callback;
+	}
+
+private:
+	using catalog_entry_retrieve_func_t = std::function<optional_ptr<CatalogEntry>()>;
+	optional_ptr<CatalogEntry> GetEntryInternal(const catalog_entry_retrieve_func_t &retriever) {
+		auto result = retriever();
+		if (!result) {
+			return result;
+		}
+		if (callback) {
+			// Call the callback if it's set
+			callback(*result);
+		}
+		return result;
+	}
+
+private:
+	//! (optional) callback, called on every succesful entry retrieval
+	catalog_entry_callback_t callback = nullptr;
+	ClientContext &context;
+};
+
+} // namespace duckdb

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

@@ -27,6 +27,9 @@ struct CatalogTransaction {
 	transaction_t transaction_id;
 	transaction_t start_time;
 
+	bool HasContext() const {
+		return context;
+	}
 	ClientContext &GetContext();
 
 	static CatalogTransaction GetSystemCatalogTransaction(ClientContext &context);

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

@@ -153,6 +153,10 @@ public:
 		}
 		return true;
 	}
+
+public:
+	void Serialize(Serializer &serializer) const;
+	static CatalogEntryInfo Deserialize(Deserializer &deserializer);
 };
 
 struct Dependency {

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

@@ -32,6 +32,10 @@ public:
 	explicit LogicalDependency(CatalogEntry &entry);
 	LogicalDependency();
 	bool operator==(const LogicalDependency &other) const;
+
+public:
+	void Serialize(Serializer &serializer) const;
+	static LogicalDependency Deserialize(Deserializer &deserializer);
 };
 
 struct LogicalDependencyHashFunction {
@@ -42,7 +46,7 @@ struct LogicalDependencyEquality {
 	bool operator()(const LogicalDependency &a, const LogicalDependency &b) const;
 };
 
-//! The DependencyList containing LogicalDependency objects, not looked up in the catalog yet
+//! The LogicalDependencyList containing LogicalDependency objects, not looked up in the catalog yet
 class LogicalDependencyList {
 	using create_info_set_t =
 	    unordered_set<LogicalDependency, LogicalDependencyHashFunction, LogicalDependencyEquality>;
@@ -54,6 +58,8 @@ public:
 
 public:
 	DUCKDB_API void VerifyDependencies(Catalog &catalog, const string &name);
+	void Serialize(Serializer &serializer) const;
+	static LogicalDependencyList Deserialize(Deserializer &deserializer);
 	bool operator==(const LogicalDependencyList &other) const;
 	const create_info_set_t &Set() const;
 

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

@@ -100,7 +100,7 @@ private:
 	bool IsSystemEntry(CatalogEntry &entry) const;
 	optional_ptr<CatalogEntry> LookupEntry(CatalogTransaction transaction, const LogicalDependency &dependency);
 	optional_ptr<CatalogEntry> LookupEntry(CatalogTransaction transaction, CatalogEntry &dependency);
-
+	string CollectDependents(CatalogTransaction transaction, catalog_entry_set_t &entries, CatalogEntryInfo &info);
 	void CleanupDependencies(CatalogTransaction transaction, CatalogEntry &entry);
 
 public:
@@ -112,7 +112,7 @@ public:
 private:
 	void AddObject(CatalogTransaction transaction, CatalogEntry &object, const LogicalDependencyList &dependencies);
 	void DropObject(CatalogTransaction transaction, CatalogEntry &object, bool cascade);
-	void AlterObject(CatalogTransaction transaction, CatalogEntry &old_obj, CatalogEntry &new_obj);
+	void AlterObject(CatalogTransaction transaction, CatalogEntry &old_obj, CatalogEntry &new_obj, AlterInfo &info);
 
 private:
 	void RemoveDependency(CatalogTransaction transaction, const DependencyInfo &info);

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

@@ -25,6 +25,8 @@ public:
 
 	//! The schema the entry belongs to
 	SchemaCatalogEntry &schema;
+	//! The dependencies of the entry, can be empty
+	LogicalDependencyList dependencies;
 
 public:
 	SchemaCatalogEntry &ParentSchema() override {

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

@@ -59,6 +59,7 @@ struct ArrowAppendData {
 //===--------------------------------------------------------------------===//
 // Append Helper Functions
 //===--------------------------------------------------------------------===//
+
 static void GetBitPosition(idx_t row_idx, idx_t &current_byte, uint8_t &current_bit) {
 	current_byte = row_idx / 8;
 	current_bit = row_idx % 8;

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

@@ -44,14 +44,14 @@ struct ArrowEnumData : public ArrowScalarBaseData<TGT> {
 			auto string_length = GetLength(data[i]);
 
 			// append the offset data
-			auto current_offset = last_offset + string_length;
-			offset_data[offset_idx] = UnsafeNumericCast<uint32_t>(current_offset);
+			auto current_offset = UnsafeNumericCast<idx_t>(last_offset) + string_length;
+			offset_data[offset_idx] = UnsafeNumericCast<int32_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 = UnsafeNumericCast<uint32_t>(current_offset);
+			last_offset = UnsafeNumericCast<int32_t>(current_offset);
 		}
 		append_data.row_count += size;
 	}

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

@@ -75,7 +75,7 @@ public:
 		struct_result->children = struct_data.child_pointers.data();
 		struct_result->n_buffers = 1;
 		struct_result->n_children = struct_child_count;
-		struct_result->length = struct_data.child_data[0]->row_count;
+		struct_result->length = NumericCast<int64_t>(struct_data.child_data[0]->row_count);
 
 		append_data.child_arrays[0] = *struct_result;
 

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

@@ -42,6 +42,21 @@ struct ArrowIntervalConverter {
 	}
 };
 
+struct ArrowTimeTzConverter {
+	template <class TGT, class SRC>
+	static TGT Operation(SRC input) {
+		return input.time().micros;
+	}
+
+	static bool SkipNulls() {
+		return true;
+	}
+
+	template <class TGT>
+	static void SetNull(TGT &value) {
+	}
+};
+
 template <class TGT, class SRC = TGT, class OP = ArrowScalarConverter>
 struct ArrowScalarBaseData {
 	static void Append(ArrowAppendData &append_data, Vector &input, idx_t from, idx_t to, idx_t input_size) {

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

@@ -77,8 +77,9 @@ struct ArrowVarcharData {
 			auto string_length = OP::GetLength(data[source_idx]);
 
 			// append the offset data
-			auto current_offset = last_offset + string_length;
-			if (!LARGE_STRING && (int64_t)last_offset + string_length > NumericLimits<int32_t>::Maximum()) {
+			auto current_offset = UnsafeNumericCast<idx_t>(last_offset) + string_length;
+			if (!LARGE_STRING &&
+			    UnsafeNumericCast<idx_t>(last_offset) + string_length > NumericLimits<int32_t>::Maximum()) {
 				D_ASSERT(append_data.options.arrow_offset_size == ArrowOffsetSize::REGULAR);
 				throw InvalidInputException(
 				    "Arrow Appender: The maximum total string size for regular string buffers is "