duckdb 1.3.3-dev4.0 → 1.3.3

package/src/duckdb/src/catalog/catalog.cpp

@@ -39,7 +39,6 @@
 #include "duckdb/function/built_in_functions.hpp"
 #include "duckdb/catalog/similar_catalog_entry.hpp"
 #include "duckdb/storage/database_size.hpp"
-#include "duckdb/main/settings.hpp"
 #include <algorithm>
 
 namespace duckdb {
@@ -535,20 +534,19 @@ bool Catalog::TryAutoLoad(ClientContext &context, const string &original_name) n
 	return false;
 }
 
-String Catalog::AutoloadExtensionByConfigName(ClientContext &context, const String &configuration_name) {
+void Catalog::AutoloadExtensionByConfigName(ClientContext &context, const string &configuration_name) {
 #ifndef DUCKDB_DISABLE_EXTENSION_LOAD
 	auto &dbconfig = DBConfig::GetConfig(context);
 	if (dbconfig.options.autoload_known_extensions) {
-		auto extension_name =
-		    ExtensionHelper::FindExtensionInEntries(configuration_name.ToStdString(), EXTENSION_SETTINGS);
+		auto extension_name = ExtensionHelper::FindExtensionInEntries(configuration_name, EXTENSION_SETTINGS);
 		if (ExtensionHelper::CanAutoloadExtension(extension_name)) {
 			ExtensionHelper::AutoLoadExtension(context, extension_name);
-			return extension_name;
+			return;
 		}
 	}
 #endif
 
-	throw Catalog::UnrecognizedConfigurationError(context, configuration_name.ToStdString());
+	throw Catalog::UnrecognizedConfigurationError(context, configuration_name);
 }
 
 static bool IsAutoloadableFunction(CatalogType type) {
@@ -651,17 +649,19 @@ CatalogException Catalog::CreateMissingEntryException(CatalogEntryRetriever &ret
                                                       const reference_set_t<SchemaCatalogEntry> &schemas) {
 	auto &context = retriever.GetContext();
 	auto entries = SimilarEntriesInSchemas(context, lookup_info, schemas);
-	auto max_schema_count = DBConfig::GetSetting<CatalogErrorMaxSchemasSetting>(context);
+
+	auto &config = DBConfig::GetConfig(context);
+	auto max_schema_count = config.GetSetting<CatalogErrorMaxSchemasSetting>(context);
 
 	reference_set_t<SchemaCatalogEntry> unseen_schemas;
 	auto &db_manager = DatabaseManager::Get(context);
 	auto databases = db_manager.GetDatabases(context, max_schema_count);
 
-	for (const auto &database : databases) {
+	for (auto database : databases) {
 		if (unseen_schemas.size() >= max_schema_count) {
 			break;
 		}
-		auto &catalog = database->GetCatalog();
+		auto &catalog = database.get().GetCatalog();
 		auto current_schemas = catalog.GetSchemas(context);
 		for (auto &current_schema : current_schemas) {
 			if (unseen_schemas.size() >= max_schema_count) {
@@ -838,37 +838,17 @@ CatalogEntryLookup Catalog::LookupEntry(CatalogEntryRetriever &retriever, const
 	return res;
 }
 
-static void ThrowDefaultTableAmbiguityException(CatalogEntryLookup &base_lookup, CatalogEntryLookup &default_table,
-                                                const string &name) {
-	auto entry_type = CatalogTypeToString(base_lookup.entry->type);
-	string fully_qualified_name_hint;
-	if (base_lookup.schema) {
-		fully_qualified_name_hint = StringUtil::Format(": '%s.%s.%s'", base_lookup.schema->catalog.GetName(),
-		                                               base_lookup.schema->name, base_lookup.entry->name);
-	}
-	string fully_qualified_catalog_name_hint = StringUtil::Format(
-	    ": '%s.%s.%s'", default_table.schema->catalog.GetName(), default_table.schema->name, default_table.entry->name);
-	throw CatalogException(
-	    "Ambiguity detected for '%s': this could either refer to the '%s' '%s', or the "
-	    "attached catalog '%s' which has a default table. To avoid this error, either detach the catalog and "
-	    "reattach under a different name, or use a fully qualified name for the '%s'%s or for the Catalog "
-	    "Default Table%s.",
-	    name, entry_type, name, name, entry_type, fully_qualified_name_hint, fully_qualified_catalog_name_hint);
-}
-
 CatalogEntryLookup Catalog::TryLookupEntry(CatalogEntryRetriever &retriever, const vector<CatalogLookup> &lookups,
-                                           const EntryLookupInfo &lookup_info, OnEntryNotFound if_not_found,
-                                           bool allow_default_table_lookup) {
+                                           const EntryLookupInfo &lookup_info, OnEntryNotFound if_not_found) {
 	auto &context = retriever.GetContext();
 	reference_set_t<SchemaCatalogEntry> schemas;
 	bool all_errors = true;
 	ErrorData error_data;
-	CatalogEntryLookup result;
 	for (auto &lookup : lookups) {
 		auto transaction = lookup.catalog.GetCatalogTransaction(context);
-		result = lookup.catalog.TryLookupEntryInternal(transaction, lookup.schema, lookup.lookup_info);
+		auto result = lookup.catalog.TryLookupEntryInternal(transaction, lookup.schema, lookup.lookup_info);
 		if (result.Found()) {
-			break;
+			return result;
 		}
 		if (result.schema) {
 			schemas.insert(*result.schema);
@@ -879,29 +859,6 @@ CatalogEntryLookup Catalog::TryLookupEntry(CatalogEntryRetriever &retriever, con
 			error_data = std::move(result.error);
 		}
 	}
-
-	// Special case for tables: we do a second lookup searching for catalogs with default tables that also match this
-	// lookup
-	if (lookup_info.GetCatalogType() == CatalogType::TABLE_ENTRY && allow_default_table_lookup) {
-		if (!result.Found()) {
-			result = TryLookupDefaultTable(retriever, lookup_info, false);
-			if (result.error.HasError()) {
-				error_data = std::move(result.error);
-			}
-		} else {
-			// allow_ignore_at_clause set to true to ensure `FROM <table_name> AT <version>` is considered
-			// ambiguous with a default table lookup in a catalog that does not support time travel
-			auto ambiguity_lookup = TryLookupDefaultTable(retriever, lookup_info, true);
-			if (ambiguity_lookup.Found()) {
-				ThrowDefaultTableAmbiguityException(result, ambiguity_lookup, lookup_info.GetEntryName());
-			}
-		}
-	}
-
-	if (result.Found()) {
-		return result;
-	}
-
 	if (all_errors && error_data.HasError()) {
 		error_data.Throw();
 	}
@@ -921,29 +878,41 @@ CatalogEntryLookup Catalog::TryLookupEntry(CatalogEntryRetriever &retriever, con
 	}
 }
 
-CatalogEntryLookup Catalog::TryLookupDefaultTable(CatalogEntryRetriever &retriever, const EntryLookupInfo &lookup_info,
-                                                  bool allow_ignore_at_clause) {
-	auto catalog_by_name = GetCatalogEntry(retriever, lookup_info.GetEntryName());
+CatalogEntryLookup Catalog::TryLookupDefaultTable(CatalogEntryRetriever &retriever, const string &catalog,
+                                                  const string &schema, const EntryLookupInfo &lookup_info,
+                                                  OnEntryNotFound if_not_found) {
+	// Default tables of catalogs can only be accessed by the catalog name directly
+	if (!schema.empty() || !catalog.empty()) {
+		return {nullptr, nullptr, ErrorData()};
+	}
 
+	vector<CatalogLookup> catalog_by_name_lookups;
+	auto catalog_by_name = GetCatalogEntry(retriever, lookup_info.GetEntryName());
 	if (catalog_by_name && catalog_by_name->HasDefaultTable()) {
-		auto transaction = catalog_by_name->GetCatalogTransaction(retriever.GetContext());
-		QueryErrorContext context;
-
-		string table_schema = catalog_by_name->GetDefaultTableSchema();
-		string table_name = catalog_by_name->GetDefaultTable();
+		catalog_by_name_lookups.emplace_back(*catalog_by_name, CatalogType::TABLE_ENTRY,
+		                                     catalog_by_name->GetDefaultTableSchema(),
+		                                     catalog_by_name->GetDefaultTable());
+	}
 
-		optional_ptr<BoundAtClause> at_clause;
-		if (!catalog_by_name->SupportsTimeTravel() && allow_ignore_at_clause) {
-			at_clause = nullptr;
-		} else {
-			at_clause = lookup_info.GetAtClause();
-		}
+	return TryLookupEntry(retriever, catalog_by_name_lookups, lookup_info, if_not_found);
+}
 
-		EntryLookupInfo info = EntryLookupInfo(CatalogType::TABLE_ENTRY, table_name, at_clause, context);
-		return catalog_by_name->TryLookupEntryInternal(transaction, table_schema, info);
+static void ThrowDefaultTableAmbiguityException(CatalogEntryLookup &base_lookup, CatalogEntryLookup &default_table,
+                                                const string &name) {
+	auto entry_type = CatalogTypeToString(base_lookup.entry->type);
+	string fully_qualified_name_hint;
+	if (base_lookup.schema) {
+		fully_qualified_name_hint = StringUtil::Format(": '%s.%s.%s'", base_lookup.schema->catalog.GetName(),
+		                                               base_lookup.schema->name, base_lookup.entry->name);
 	}
-
-	return {nullptr, nullptr, ErrorData()};
+	string fully_qualified_catalog_name_hint = StringUtil::Format(
+	    ": '%s.%s.%s'", default_table.schema->catalog.GetName(), default_table.schema->name, default_table.entry->name);
+	throw CatalogException(
+	    "Ambiguity detected for '%s': this could either refer to the '%s' '%s', or the "
+	    "attached catalog '%s' which has a default table. To avoid this error, either detach the catalog and "
+	    "reattach under a different name, or use a fully qualified name for the '%s'%s or for the Catalog "
+	    "Default Table%s.",
+	    name, entry_type, name, name, entry_type, fully_qualified_name_hint, fully_qualified_catalog_name_hint);
 }
 
 CatalogEntryLookup Catalog::TryLookupEntry(CatalogEntryRetriever &retriever, const string &catalog,
@@ -976,9 +945,25 @@ CatalogEntryLookup Catalog::TryLookupEntry(CatalogEntryRetriever &retriever, con
 		lookups.emplace_back(std::move(lookup));
 	}
 
-	bool allow_default_table_lookup = catalog.empty() && schema.empty();
+	// Do the main lookup
+	auto lookup_result = TryLookupEntry(retriever, lookups, lookup_info, if_not_found);
+
+	// Special case for tables: we do a second lookup searching for catalogs with default tables that also match this
+	// lookup
+	if (lookup_info.GetCatalogType() == CatalogType::TABLE_ENTRY) {
+		auto lookup_result_default_table =
+		    TryLookupDefaultTable(retriever, catalog, schema, lookup_info, OnEntryNotFound::RETURN_NULL);
+
+		if (lookup_result_default_table.Found() && lookup_result.Found()) {
+			ThrowDefaultTableAmbiguityException(lookup_result, lookup_result_default_table, lookup_info.GetEntryName());
+		}
+
+		if (lookup_result_default_table.Found()) {
+			return lookup_result_default_table;
+		}
+	}
 
-	return TryLookupEntry(retriever, lookups, lookup_info, if_not_found, allow_default_table_lookup);
+	return lookup_result;
 }
 
 CatalogEntry &Catalog::GetEntry(ClientContext &context, CatalogType catalog_type, const string &catalog_name,
@@ -1134,8 +1119,8 @@ vector<reference<SchemaCatalogEntry>> Catalog::GetAllSchemas(ClientContext &cont
 
 	auto &db_manager = DatabaseManager::Get(context);
 	auto databases = db_manager.GetDatabases(context);
-	for (auto &database : databases) {
-		auto &catalog = database->GetCatalog();
+	for (auto database : databases) {
+		auto &catalog = database.get().GetCatalog();
 		auto new_schemas = catalog.GetSchemas(context);
 		result.insert(result.end(), new_schemas.begin(), new_schemas.end());
 	}
@@ -1155,16 +1140,6 @@ vector<reference<SchemaCatalogEntry>> Catalog::GetAllSchemas(ClientContext &cont
 	return result;
 }
 
-vector<reference<CatalogEntry>> Catalog::GetAllEntries(ClientContext &context, CatalogType catalog_type) {
-	vector<reference<CatalogEntry>> result;
-	auto schemas = GetAllSchemas(context);
-	for (const auto &schema_ref : schemas) {
-		auto &schema = schema_ref.get();
-		schema.Scan(context, catalog_type, [&](CatalogEntry &entry) { result.push_back(entry); });
-	}
-	return result;
-}
-
 void Catalog::Alter(CatalogTransaction transaction, AlterInfo &info) {
 	if (transaction.HasContext()) {
 		CatalogEntryRetriever retriever(transaction.GetContext());
@@ -1235,9 +1210,4 @@ void Catalog::FinalizeLoad(optional_ptr<ClientContext> context) {
 void Catalog::OnDetach(ClientContext &context) {
 }
 
-bool Catalog::HasConflictingAttachOptions(const string &path, const AttachOptions &options) {
-	auto const db_type = options.db_type.empty() ? "duckdb" : options.db_type;
-	return GetDBPath() != path || GetCatalogType() != db_type;
-}
-
 } // namespace duckdb

package/src/duckdb/src/catalog/catalog_entry/duck_table_entry.cpp

@@ -23,7 +23,6 @@
 #include "duckdb/parser/expression/function_expression.hpp"
 #include "duckdb/storage/storage_manager.hpp"
 #include "duckdb/storage/table_storage_info.hpp"
-#include "duckdb/common/type_visitor.hpp"
 
 namespace duckdb {
 
@@ -55,9 +54,6 @@ DuckTableEntry::DuckTableEntry(Catalog &catalog, SchemaCatalogEntry &schema, Bou
 	// create the physical storage
 	vector<ColumnDefinition> column_defs;
 	for (auto &col_def : columns.Physical()) {
-		if (TypeVisitor::Contains(col_def.Type(), LogicalTypeId::VARIANT)) {
-			throw NotImplementedException("A table cannot be created from a VARIANT column yet");
-		}
 		column_defs.push_back(col_def.Copy());
 	}
 	storage = make_shared_ptr<DataTable>(catalog.GetAttached(), StorageManager::Get(catalog).GetTableIOManager(&info),
@@ -263,12 +259,15 @@ void DuckTableEntry::UndoAlter(ClientContext &context, AlterInfo &info) {
 	}
 }
 
-static void RenameExpression(ParsedExpression &root_expr, RenameColumnInfo &info) {
-	ParsedExpressionIterator::VisitExpressionMutable<ColumnRefExpression>(root_expr, [&](ColumnRefExpression &colref) {
+static void RenameExpression(ParsedExpression &expr, RenameColumnInfo &info) {
+	if (expr.GetExpressionType() == ExpressionType::COLUMN_REF) {
+		auto &colref = expr.Cast<ColumnRefExpression>();
 		if (colref.column_names.back() == info.old_name) {
 			colref.column_names.back() = info.new_name;
 		}
-	});
+	}
+	ParsedExpressionIterator::EnumerateChildren(
+	    expr, [&](const ParsedExpression &child) { RenameExpression((ParsedExpression &)child, info); });
 }
 
 unique_ptr<CatalogEntry> DuckTableEntry::RenameColumn(ClientContext &context, RenameColumnInfo &info) {
@@ -859,12 +858,12 @@ unique_ptr<CatalogEntry> DuckTableEntry::RenameField(ClientContext &context, Ren
 	if (!ColumnExists(info.column_path[0])) {
 		throw CatalogException("Cannot rename field from column \"%s\" - it does not exist", info.column_path[0]);
 	}
-
 	// follow the path
 	auto &col = GetColumn(info.column_path[0]);
 	auto res = RenameFieldFromStruct(col.Type(), info.column_path, info.new_name, 1);
 	if (res.error.HasError()) {
 		res.error.Throw();
+		return nullptr;
 	}
 
 	// construct the struct remapping expression
@@ -875,6 +874,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::RenameField(ClientContext &context, Ren
 	children.push_back(make_uniq<ConstantExpression>(Value()));
 
 	auto function = make_uniq<FunctionExpression>("remap_struct", std::move(children));
+
 	ChangeColumnTypeInfo change_column_type(info.GetAlterEntryData(), info.column_path[0], std::move(res.new_type),
 	                                        std::move(function));
 	return ChangeColumnType(context, change_column_type);

package/src/duckdb/src/catalog/catalog_entry/table_catalog_entry.cpp

@@ -38,13 +38,7 @@ LogicalIndex TableCatalogEntry::GetColumnIndex(string &column_name, bool if_exis
 		if (if_exists) {
 			return entry;
 		}
-		vector<string> column_names;
-		for (auto &col : columns.Logical()) {
-			column_names.push_back(col.Name());
-		}
-		auto candidates = StringUtil::CandidatesErrorMessage(column_names, column_name, "Did you mean");
-		throw BinderException("Table \"%s\" does not have a column with name \"%s\"\n%s", name, column_name,
-		                      candidates);
+		throw BinderException("Table \"%s\" does not have a column with name \"%s\"", name, column_name);
 	}
 	return entry;
 }
@@ -247,21 +241,21 @@ void LogicalUpdate::BindExtraColumns(TableCatalogEntry &table, LogicalGet &get,
 		}
 	}
 	if (found_column_count > 0 && found_column_count != bound_columns.size()) {
-		// columns that were required are not all part of the UPDATE
+		// columns in this CHECK constraint were referenced, but not all were part of the UPDATE
 		// add them to the scan and update set
-		for (auto &physical_id : bound_columns) {
-			if (found_columns.find(physical_id) != found_columns.end()) {
+		for (auto &check_column_id : bound_columns) {
+			if (found_columns.find(check_column_id) != found_columns.end()) {
 				// column is already projected
 				continue;
 			}
 			// column is not projected yet: project it by adding the clause "i=i" to the set of updated columns
-			auto &column = table.GetColumns().GetColumn(physical_id);
+			auto &column = table.GetColumns().GetColumn(check_column_id);
 			update.expressions.push_back(make_uniq<BoundColumnRefExpression>(
 			    column.Type(), ColumnBinding(proj.table_index, proj.expressions.size())));
 			proj.expressions.push_back(make_uniq<BoundColumnRefExpression>(
 			    column.Type(), ColumnBinding(get.table_index, get.GetColumnIds().size())));
-			get.AddColumnId(column.Logical().index);
-			update.columns.push_back(physical_id);
+			get.AddColumnId(check_column_id.index);
+			update.columns.push_back(check_column_id);
 		}
 	}
 }
@@ -305,7 +299,7 @@ void TableCatalogEntry::BindUpdateConstraints(Binder &binder, LogicalGet &get, L
 				break;
 			}
 		}
-	}
+	};
 
 	// we also convert any updates on LIST columns into delete + insert
 	for (auto &col_index : update.columns) {

package/src/duckdb/src/catalog/catalog_set.cpp

@@ -7,7 +7,6 @@
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/serializer/memory_stream.hpp"
 #include "duckdb/common/serializer/binary_serializer.hpp"
-#include "duckdb/catalog/catalog_entry/dependency/dependency_entry.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/parser/expression/constant_expression.hpp"
 #include "duckdb/parser/parsed_data/alter_table_info.hpp"

package/src/duckdb/src/catalog/default/default_functions.cpp

@@ -3,6 +3,7 @@
 #include "duckdb/parser/parsed_data/create_macro_info.hpp"
 #include "duckdb/parser/expression/columnref_expression.hpp"
 #include "duckdb/catalog/catalog_entry/scalar_macro_catalog_entry.hpp"
+#include "duckdb/function/table_macro_function.hpp"
 
 #include "duckdb/function/scalar_macro_function.hpp"
 
@@ -195,13 +196,12 @@ unique_ptr<CreateMacroInfo> DefaultFunctionGenerator::CreateInternalMacroInfo(ar
 			    make_uniq<ColumnRefExpression>(default_macro.parameters[param_idx]));
 		}
 		for (idx_t named_idx = 0; default_macro.named_parameters[named_idx].name != nullptr; named_idx++) {
-			const auto &named_param = default_macro.named_parameters[named_idx];
-			auto expr_list = Parser::ParseExpressionList(named_param.default_value);
+			auto expr_list = Parser::ParseExpressionList(default_macro.named_parameters[named_idx].default_value);
 			if (expr_list.size() != 1) {
 				throw InternalException("Expected a single expression");
 			}
-			function->parameters.push_back(make_uniq<ColumnRefExpression>(named_param.name));
-			function->default_parameters.insert(make_pair(named_param.name, std::move(expr_list[0])));
+			function->default_parameters.insert(
+				make_pair(default_macro.named_parameters[named_idx].name, std::move(expr_list[0])));
 		}
 		D_ASSERT(function->type == MacroType::SCALAR_MACRO);
 		bind_info->macros.push_back(std::move(function));

package/src/duckdb/src/catalog/default/default_table_functions.cpp

@@ -68,7 +68,7 @@ FROM histogram_values(source, col_name, bin_count := bin_count, technique := tec
 )"},
 	{DEFAULT_SCHEMA, "duckdb_logs_parsed", {"log_type"}, {}, R"(
 SELECT * EXCLUDE (message), UNNEST(parse_duckdb_log_message(log_type, message))
-FROM duckdb_logs(denormalized_table=1)
+FROM duckdb_logs
 WHERE type = log_type
 )"},
 	{nullptr, nullptr, {nullptr}, {{nullptr, nullptr}}, nullptr}
@@ -86,13 +86,12 @@ DefaultTableFunctionGenerator::CreateInternalTableMacroInfo(const DefaultTableMa
 		function->parameters.push_back(make_uniq<ColumnRefExpression>(default_macro.parameters[param_idx]));
 	}
 	for (idx_t named_idx = 0; default_macro.named_parameters[named_idx].name != nullptr; named_idx++) {
-		const auto &named_param = default_macro.named_parameters[named_idx];
-		auto expr_list = Parser::ParseExpressionList(named_param.default_value);
+		auto expr_list = Parser::ParseExpressionList(default_macro.named_parameters[named_idx].default_value);
 		if (expr_list.size() != 1) {
 			throw InternalException("Expected a single expression");
 		}
-		function->parameters.push_back(make_uniq<ColumnRefExpression>(named_param.name));
-		function->default_parameters.insert(make_pair(named_param.name, std::move(expr_list[0])));
+		function->default_parameters.insert(
+		    make_pair(default_macro.named_parameters[named_idx].name, std::move(expr_list[0])));
 	}
 
 	auto type = CatalogType::TABLE_MACRO_ENTRY;

package/src/duckdb/src/catalog/default/default_views.cpp

@@ -26,7 +26,7 @@ static const DefaultView internal_views[] = {
     {DEFAULT_SCHEMA, "duckdb_tables", "SELECT * FROM duckdb_tables() WHERE NOT internal"},
     {DEFAULT_SCHEMA, "duckdb_types", "SELECT * FROM duckdb_types()"},
     {DEFAULT_SCHEMA, "duckdb_views", "SELECT * FROM duckdb_views() WHERE NOT internal"},
-	{DEFAULT_SCHEMA, "duckdb_logs", "SELECT * FROM duckdb_logs(denormalized_table=true)"},
+	{DEFAULT_SCHEMA, "duckdb_logs", "SELECT * exclude (l.context_id, c.context_id) FROM duckdb_logs() as l JOIN duckdb_log_contexts() as c ON l.context_id=c.context_id order by timestamp;"},
     {"pg_catalog", "pg_am", "SELECT 0 oid, 'art' amname, NULL amhandler, 'i' amtype"},
     {"pg_catalog", "pg_prepared_statements", "SELECT name, statement, NULL prepare_time, parameter_types, result_types, NULL from_sql, NULL generic_plans, NULL custom_plans from duckdb_prepared_statements()"},
     {"pg_catalog", "pg_attribute", "SELECT table_oid attrelid, column_name attname, data_type_id atttypid, 0 attstattarget, NULL attlen, column_index attnum, 0 attndims, -1 attcacheoff, case when data_type ilike '%decimal%' then numeric_precision*1000+numeric_scale else -1 end atttypmod, false attbyval, NULL attstorage, NULL attalign, NOT is_nullable attnotnull, column_default IS NOT NULL atthasdef, false atthasmissing, '' attidentity, '' attgenerated, false attisdropped, true attislocal, 0 attinhcount, 0 attcollation, NULL attcompression, NULL attacl, NULL attoptions, NULL attfdwoptions, NULL attmissingval FROM duckdb_columns()"},

package/src/duckdb/src/catalog/duck_catalog.cpp

@@ -9,7 +9,6 @@
 #include "duckdb/main/attached_database.hpp"
 #include "duckdb/transaction/duck_transaction_manager.hpp"
 #include "duckdb/function/function_list.hpp"
-#include "duckdb/common/encryption_state.hpp"
 
 namespace duckdb {
 
@@ -160,14 +159,6 @@ string DuckCatalog::GetDBPath() {
 	return db.GetStorageManager().GetDBPath();
 }
 
-bool DuckCatalog::IsEncrypted() const {
-	return IsSystemCatalog() ? false : db.GetStorageManager().IsEncrypted();
-}
-
-string DuckCatalog::GetEncryptionCipher() const {
-	return IsSystemCatalog() ? string() : EncryptionTypes::CipherToString(db.GetStorageManager().GetCipher());
-}
-
 void DuckCatalog::Verify() {
 #ifdef DEBUG
 	Catalog::Verify();
@@ -182,23 +173,4 @@ optional_idx DuckCatalog::GetCatalogVersion(ClientContext &context) {
 	return transaction_manager.GetCatalogVersion(*transaction.transaction);
 }
 
-//===--------------------------------------------------------------------===//
-// Encryption
-//===--------------------------------------------------------------------===//
-void DuckCatalog::SetEncryptionKeyId(const string &key_id) {
-	encryption_key_id = key_id;
-}
-
-string &DuckCatalog::GetEncryptionKeyId() {
-	return encryption_key_id;
-}
-
-void DuckCatalog::SetIsEncrypted() {
-	is_encrypted = true;
-}
-
-bool DuckCatalog::GetIsEncrypted() {
-	return is_encrypted;
-}
-
 } // namespace duckdb