duckdb 0.6.2-dev971.0 → 0.7.1-dev2.0

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

@@ -1,7 +1,7 @@
 #include "duckdb/function/table/table_scan.hpp"
 
 #include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
 #include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/mutex.hpp"
 #include "duckdb/main/client_config.hpp"
@@ -11,9 +11,10 @@
 #include "duckdb/planner/operator/logical_get.hpp"
 #include "duckdb/storage/data_table.hpp"
 #include "duckdb/transaction/local_storage.hpp"
-#include "duckdb/transaction/transaction.hpp"
+#include "duckdb/transaction/duck_transaction.hpp"
 #include "duckdb/main/attached_database.hpp"
 #include "duckdb/catalog/dependency_list.hpp"
+#include "duckdb/function/function_set.hpp"
 
 namespace duckdb {
 
@@ -34,7 +35,7 @@ static storage_t GetStorageIndex(TableCatalogEntry &table, column_t column_id) {
 	if (column_id == DConstants::INVALID_INDEX) {
 		return column_id;
 	}
-	auto &col = table.columns.GetColumn(LogicalIndex(column_id));
+	auto &col = table.GetColumn(LogicalIndex(column_id));
 	return col.StorageOid();
 }
 
@@ -42,7 +43,7 @@ struct TableScanGlobalState : public GlobalTableFunctionState {
 	TableScanGlobalState(ClientContext &context, const FunctionData *bind_data_p) : row_count(0) {
 		D_ASSERT(bind_data_p);
 		auto &bind_data = (const TableScanBindData &)*bind_data_p;
-		max_threads = bind_data.table->storage->MaxThreads(context);
+		max_threads = bind_data.table->GetStorage().MaxThreads(context);
 	}
 
 	ParallelTableScanState state;
@@ -72,13 +73,13 @@ static unique_ptr<LocalTableFunctionState> TableScanInitLocal(ExecutionContext &
 		auto storage_idx = GetStorageIndex(*bind_data.table, col);
 		col = storage_idx;
 	}
-	result->scan_state.Initialize(move(column_ids), input.filters);
+	result->scan_state.Initialize(std::move(column_ids), input.filters);
 	TableScanParallelStateNext(context.client, input.bind_data, result.get(), gstate);
 	if (input.CanRemoveFilterColumns()) {
 		auto &tsgs = (TableScanGlobalState &)*gstate;
 		result->all_columns.Initialize(context.client, tsgs.scanned_types);
 	}
-	return move(result);
+	return std::move(result);
 }
 
 unique_ptr<GlobalTableFunctionState> TableScanInitGlobal(ClientContext &context, TableFunctionInitInput &input) {
@@ -86,10 +87,10 @@ unique_ptr<GlobalTableFunctionState> TableScanInitGlobal(ClientContext &context,
 	D_ASSERT(input.bind_data);
 	auto &bind_data = (const TableScanBindData &)*input.bind_data;
 	auto result = make_unique<TableScanGlobalState>(context, input.bind_data);
-	bind_data.table->storage->InitializeParallelScan(context, result->state);
+	bind_data.table->GetStorage().InitializeParallelScan(context, result->state);
 	if (input.CanRemoveFilterColumns()) {
 		result->projection_ids = input.projection_ids;
-		const auto &columns = bind_data.table->columns;
+		const auto &columns = bind_data.table->GetColumns();
 		for (const auto &col_idx : input.column_ids) {
 			if (col_idx == COLUMN_IDENTIFIER_ROW_ID) {
 				result->scanned_types.emplace_back(LogicalType::ROW_TYPE);
@@ -98,14 +99,14 @@ unique_ptr<GlobalTableFunctionState> TableScanInitGlobal(ClientContext &context,
 			}
 		}
 	}
-	return move(result);
+	return std::move(result);
 }
 
 static unique_ptr<BaseStatistics> TableScanStatistics(ClientContext &context, const FunctionData *bind_data_p,
                                                       column_t column_id) {
 	auto &bind_data = (const TableScanBindData &)*bind_data_p;
 	auto &local_storage = LocalStorage::Get(context, *bind_data.table->catalog);
-	if (local_storage.Find(bind_data.table->storage.get())) {
+	if (local_storage.Find(bind_data.table->GetStoragePtr())) {
 		// we don't emit any statistics for tables that have outstanding transaction-local data
 		return nullptr;
 	}
@@ -116,17 +117,18 @@ static void TableScanFunc(ClientContext &context, TableFunctionInput &data_p, Da
 	auto &bind_data = (TableScanBindData &)*data_p.bind_data;
 	auto &gstate = (TableScanGlobalState &)*data_p.global_state;
 	auto &state = (TableScanLocalState &)*data_p.local_state;
-	auto &transaction = Transaction::Get(context, *bind_data.table->catalog);
+	auto &transaction = DuckTransaction::Get(context, *bind_data.table->catalog);
+	auto &storage = bind_data.table->GetStorage();
 	do {
 		if (bind_data.is_create_index) {
-			bind_data.table->storage->CreateIndexScan(
-			    state.scan_state, output, TableScanType::TABLE_SCAN_COMMITTED_ROWS_OMIT_PERMANENTLY_DELETED);
+			storage.CreateIndexScan(state.scan_state, output,
+			                        TableScanType::TABLE_SCAN_COMMITTED_ROWS_OMIT_PERMANENTLY_DELETED);
 		} else if (gstate.CanRemoveFilterColumns()) {
 			state.all_columns.Reset();
-			bind_data.table->storage->Scan(transaction, state.all_columns, state.scan_state);
+			storage.Scan(transaction, state.all_columns, state.scan_state);
 			output.ReferenceColumns(state.all_columns, gstate.projection_ids);
 		} else {
-			bind_data.table->storage->Scan(transaction, output, state.scan_state);
+			storage.Scan(transaction, output, state.scan_state);
 		}
 		if (output.size() > 0) {
 			gstate.row_count += output.size();
@@ -143,16 +145,18 @@ bool TableScanParallelStateNext(ClientContext &context, const FunctionData *bind
 	auto &bind_data = (const TableScanBindData &)*bind_data_p;
 	auto &parallel_state = (TableScanGlobalState &)*global_state;
 	auto &state = (TableScanLocalState &)*local_state;
+	auto &storage = bind_data.table->GetStorage();
 
 	lock_guard<mutex> parallel_lock(parallel_state.lock);
-	return bind_data.table->storage->NextParallelScan(context, parallel_state.state, state.scan_state);
+	return storage.NextParallelScan(context, parallel_state.state, state.scan_state);
 }
 
 double TableScanProgress(ClientContext &context, const FunctionData *bind_data_p,
                          const GlobalTableFunctionState *gstate_p) {
 	auto &bind_data = (TableScanBindData &)*bind_data_p;
 	auto &gstate = (TableScanGlobalState &)*gstate_p;
-	idx_t total_rows = bind_data.table->storage->GetTotalRows();
+	auto &storage = bind_data.table->GetStorage();
+	idx_t total_rows = storage.GetTotalRows();
 	if (total_rows == 0) {
 		//! Table is either empty or smaller than a vector size, so it is finished
 		return 100;
@@ -190,9 +194,9 @@ void TableScanDependency(DependencyList &entries, const FunctionData *bind_data_
 unique_ptr<NodeStatistics> TableScanCardinality(ClientContext &context, const FunctionData *bind_data_p) {
 	auto &bind_data = (const TableScanBindData &)*bind_data_p;
 	auto &local_storage = LocalStorage::Get(context, *bind_data.table->catalog);
-	idx_t estimated_cardinality =
-	    bind_data.table->storage->info->cardinality + local_storage.AddedRows(bind_data.table->storage.get());
-	return make_unique<NodeStatistics>(bind_data.table->storage->info->cardinality, estimated_cardinality);
+	auto &storage = bind_data.table->GetStorage();
+	idx_t estimated_cardinality = storage.info->cardinality + local_storage.AddedRows(bind_data.table->GetStoragePtr());
+	return make_unique<NodeStatistics>(storage.info->cardinality, estimated_cardinality);
 }
 
 //===--------------------------------------------------------------------===//
@@ -219,22 +223,22 @@ static unique_ptr<GlobalTableFunctionState> IndexScanInitGlobal(ClientContext &c
 	auto &local_storage = LocalStorage::Get(context, *bind_data.table->catalog);
 	result->column_ids = input.column_ids;
 	result->local_storage_state.Initialize(input.column_ids, input.filters);
-	local_storage.InitializeScan(bind_data.table->storage.get(), result->local_storage_state.local_state,
+	local_storage.InitializeScan(bind_data.table->GetStoragePtr(), result->local_storage_state.local_state,
 	                             input.filters);
 
 	result->finished = false;
-	return move(result);
+	return std::move(result);
 }
 
 static void IndexScanFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
 	auto &bind_data = (const TableScanBindData &)*data_p.bind_data;
 	auto &state = (IndexScanGlobalState &)*data_p.global_state;
-	auto &transaction = Transaction::Get(context, *bind_data.table->catalog);
+	auto &transaction = DuckTransaction::Get(context, *bind_data.table->catalog);
 	auto &local_storage = LocalStorage::Get(transaction);
 
 	if (!state.finished) {
-		bind_data.table->storage->Fetch(transaction, output, state.column_ids, state.row_ids,
-		                                bind_data.result_ids.size(), state.fetch_state);
+		bind_data.table->GetStorage().Fetch(transaction, output, state.column_ids, state.row_ids,
+		                                    bind_data.result_ids.size(), state.fetch_state);
 		state.finished = true;
 	}
 	if (output.size() == 0) {
@@ -266,7 +270,7 @@ void TableScanPushdownComplexFilter(ClientContext &context, LogicalGet &get, Fun
                                     vector<unique_ptr<Expression>> &filters) {
 	auto &bind_data = (TableScanBindData &)*bind_data_p;
 	auto table = bind_data.table;
-	auto &storage = *table->storage;
+	auto &storage = table->GetStorage();
 
 	auto &config = ClientConfig::GetConfig(context);
 	if (!config.enable_optimizer) {
@@ -426,11 +430,11 @@ static unique_ptr<FunctionData> TableScanDeserialize(ClientContext &context, Fie
 		throw SerializationException("Cant find table for %s.%s", schema_name, table_name);
 	}
 
-	auto result = make_unique<TableScanBindData>((TableCatalogEntry *)catalog_entry);
+	auto result = make_unique<TableScanBindData>((DuckTableEntry *)catalog_entry);
 	result->is_index_scan = is_index_scan;
 	result->is_create_index = is_create_index;
-	result->result_ids = move(result_ids);
-	return move(result);
+	result->result_ids = std::move(result_ids);
+	return std::move(result);
 }
 
 TableFunction TableScanFunction::GetIndexScanFunction() {
@@ -482,7 +486,7 @@ TableCatalogEntry *TableScanFunction::GetTableEntry(const TableFunction &functio
 void TableScanFunction::RegisterFunction(BuiltinFunctions &set) {
 	TableFunctionSet table_scan_set("seq_scan");
 	table_scan_set.AddFunction(GetFunction());
-	set.AddFunction(move(table_scan_set));
+	set.AddFunction(std::move(table_scan_set));
 
 	set.AddFunction(GetIndexScanFunction());
 }

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

@@ -7,7 +7,7 @@
 namespace duckdb {
 
 struct UnnestBindData : public FunctionData {
-	explicit UnnestBindData(LogicalType input_type_p) : input_type(move(input_type_p)) {
+	explicit UnnestBindData(LogicalType input_type_p) : input_type(std::move(input_type_p)) {
 	}
 
 	LogicalType input_type;
@@ -57,7 +57,7 @@ static unique_ptr<LocalTableFunctionState> UnnestLocalInit(ExecutionContext &con
 
 	auto result = make_unique<UnnestLocalState>();
 	result->operator_state = PhysicalUnnest::GetState(context, gstate.select_list);
-	return move(result);
+	return std::move(result);
 }
 
 static unique_ptr<GlobalTableFunctionState> UnnestInit(ClientContext &context, TableFunctionInitInput &input) {
@@ -65,9 +65,9 @@ static unique_ptr<GlobalTableFunctionState> UnnestInit(ClientContext &context, T
 	auto result = make_unique<UnnestGlobalState>();
 	auto ref = make_unique<BoundReferenceExpression>(bind_data.input_type, 0);
 	auto bound_unnest = make_unique<BoundUnnestExpression>(ListType::GetChildType(bind_data.input_type));
-	bound_unnest->child = move(ref);
-	result->select_list.push_back(move(bound_unnest));
-	return move(result);
+	bound_unnest->child = std::move(ref);
+	result->select_list.push_back(std::move(bound_unnest));
+	return std::move(result);
 }
 
 static OperatorResultType UnnestFunction(ExecutionContext &context, TableFunctionInput &data_p, DataChunk &input,

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

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.6.2-dev971"
+#define DUCKDB_VERSION "0.7.1-dev2"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "0ab23dde05"
+#define DUCKDB_SOURCE_ID "0f5e1ec507"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

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

@@ -14,7 +14,7 @@ TableFunctionInfo::~TableFunctionInfo() {
 TableFunction::TableFunction(string name, vector<LogicalType> arguments, table_function_t function,
                              table_function_bind_t bind, table_function_init_global_t init_global,
                              table_function_init_local_t init_local)
-    : SimpleNamedParameterFunction(move(name), move(arguments)), bind(bind), init_global(init_global),
+    : SimpleNamedParameterFunction(std::move(name), std::move(arguments)), bind(bind), 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_batch_info(nullptr),

package/src/duckdb/src/function/table_macro_function.cpp

@@ -14,7 +14,7 @@
 namespace duckdb {
 
 TableMacroFunction::TableMacroFunction(unique_ptr<QueryNode> query_node)
-    : MacroFunction(MacroType::TABLE_MACRO), query_node(move(query_node)) {
+    : MacroFunction(MacroType::TABLE_MACRO), query_node(std::move(query_node)) {
 }
 
 TableMacroFunction::TableMacroFunction(void) : MacroFunction(MacroType::TABLE_MACRO) {
@@ -24,7 +24,7 @@ unique_ptr<MacroFunction> TableMacroFunction::Copy() {
 	auto result = make_unique<TableMacroFunction>();
 	result->query_node = query_node->Copy();
 	this->CopyProperties(*result);
-	return move(result);
+	return std::move(result);
 }
 
 string TableMacroFunction::ToSQL(const string &schema, const string &name) {

package/src/duckdb/src/function/udf_function.cpp

@@ -10,8 +10,8 @@ namespace duckdb {
 void UDFWrapper::RegisterFunction(string name, vector<LogicalType> args, LogicalType ret_type,
                                   scalar_function_t udf_function, ClientContext &context, LogicalType varargs) {
 
-	ScalarFunction scalar_function(move(name), move(args), move(ret_type), move(udf_function));
-	scalar_function.varargs = move(varargs);
+	ScalarFunction scalar_function(std::move(name), std::move(args), std::move(ret_type), std::move(udf_function));
+	scalar_function.varargs = std::move(varargs);
 	scalar_function.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	CreateScalarFunctionInfo info(scalar_function);
 	info.schema = DEFAULT_SCHEMA;
@@ -19,8 +19,8 @@ void UDFWrapper::RegisterFunction(string name, vector<LogicalType> args, Logical
 }
 
 void UDFWrapper::RegisterAggrFunction(AggregateFunction aggr_function, ClientContext &context, LogicalType varargs) {
-	aggr_function.varargs = move(varargs);
-	CreateAggregateFunctionInfo info(move(aggr_function));
+	aggr_function.varargs = std::move(varargs);
+	CreateAggregateFunctionInfo info(std::move(aggr_function));
 	context.RegisterFunction(&info);
 }
 

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

@@ -31,6 +31,7 @@ struct CreateSequenceInfo;
 struct CreateCollationInfo;
 struct CreateTypeInfo;
 struct CreateTableInfo;
+struct DatabaseSize;
 
 class AttachedDatabase;
 class ClientContext;
@@ -53,18 +54,21 @@ struct CatalogLookup;
 struct CatalogEntryLookup;
 struct SimilarCatalogEntry;
 
+class Binder;
+class LogicalOperator;
+class PhysicalOperator;
+class LogicalCreateIndex;
+class LogicalCreateTable;
+class LogicalInsert;
+class LogicalDelete;
+class LogicalUpdate;
+class CreateStatement;
+
 //! The Catalog object represents the catalog of the database.
 class Catalog {
 public:
 	explicit Catalog(AttachedDatabase &db);
-	~Catalog();
-
-	//! The catalog set holding the schemas
-	unique_ptr<CatalogSet> schemas;
-	//! The DependencyManager manages dependencies between different catalog objects
-	unique_ptr<DependencyManager> dependency_manager;
-	//! Write lock for the catalog
-	mutex write_lock;
+	virtual ~Catalog();
 
 public:
 	//! Get the SystemCatalog from the ClientContext
@@ -78,13 +82,13 @@ public:
 	//! Get the specific Catalog from the AttachedDatabase
 	DUCKDB_API static Catalog &GetCatalog(AttachedDatabase &db);
 
-	DUCKDB_API DependencyManager &GetDependencyManager() {
-		return *dependency_manager;
-	}
 	DUCKDB_API AttachedDatabase &GetAttached();
 	DUCKDB_API DatabaseInstance &GetDatabase();
 
-	void Initialize(bool load_builtin);
+	virtual bool IsDuckCatalog() {
+		return false;
+	}
+	virtual void Initialize(bool load_builtin) = 0;
 
 	bool IsSystemCatalog() const;
 	bool IsTemporaryCatalog() const;
@@ -97,11 +101,12 @@ public:
 	//! Returns the catalog name - based on how the catalog was attached
 	DUCKDB_API const string &GetName();
 	DUCKDB_API idx_t GetOid();
+	DUCKDB_API virtual string GetCatalogType() = 0;
 
 	DUCKDB_API CatalogTransaction GetCatalogTransaction(ClientContext &context);
 
 	//! Creates a schema in the catalog.
-	DUCKDB_API CatalogEntry *CreateSchema(CatalogTransaction transaction, CreateSchemaInfo *info);
+	DUCKDB_API virtual CatalogEntry *CreateSchema(CatalogTransaction transaction, CreateSchemaInfo *info) = 0;
 	DUCKDB_API CatalogEntry *CreateSchema(ClientContext &context, CreateSchemaInfo *info);
 	//! Creates a table in the catalog.
 	DUCKDB_API CatalogEntry *CreateTable(CatalogTransaction transaction, BoundCreateTableInfo *info);
@@ -168,14 +173,14 @@ public:
 	DUCKDB_API SchemaCatalogEntry *GetSchema(ClientContext &context, const string &name = DEFAULT_SCHEMA,
 	                                         bool if_exists = false,
 	                                         QueryErrorContext error_context = QueryErrorContext());
-	DUCKDB_API SchemaCatalogEntry *GetSchema(CatalogTransaction transaction, const string &schema_name,
-	                                         bool if_exists = false,
-	                                         QueryErrorContext error_context = QueryErrorContext());
+	DUCKDB_API virtual SchemaCatalogEntry *GetSchema(CatalogTransaction transaction, const string &schema_name,
+	                                                 bool if_exists = false,
+	                                                 QueryErrorContext error_context = QueryErrorContext()) = 0;
 	DUCKDB_API static SchemaCatalogEntry *GetSchema(ClientContext &context, const string &catalog_name,
 	                                                const string &schema_name, bool if_exists = false,
 	                                                QueryErrorContext error_context = QueryErrorContext());
 	//! Scans all the schemas in the system one-by-one, invoking the callback for each entry
-	DUCKDB_API void ScanSchemas(ClientContext &context, std::function<void(CatalogEntry *)> callback);
+	DUCKDB_API virtual void ScanSchemas(ClientContext &context, std::function<void(CatalogEntry *)> callback) = 0;
 	//! Gets the "schema.name" entry of the specified type, if if_exists=true returns nullptr if entry does not
 	//! exist, otherwise an exception is thrown
 	DUCKDB_API CatalogEntry *GetEntry(ClientContext &context, CatalogType type, const string &schema,
@@ -191,6 +196,8 @@ public:
 	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, bool if_exists);
+
 	DUCKDB_API static LogicalType GetType(ClientContext &context, const string &catalog_name, const string &schema,
 	                                      const string &name);
 
@@ -210,6 +217,22 @@ public:
 	//! Alter an existing entry in the catalog.
 	DUCKDB_API void Alter(ClientContext &context, AlterInfo *info);
 
+	virtual unique_ptr<PhysicalOperator> PlanCreateTableAs(ClientContext &context, LogicalCreateTable &op,
+	                                                       unique_ptr<PhysicalOperator> plan) = 0;
+	virtual unique_ptr<PhysicalOperator> PlanInsert(ClientContext &context, LogicalInsert &op,
+	                                                unique_ptr<PhysicalOperator> plan) = 0;
+	virtual unique_ptr<PhysicalOperator> PlanDelete(ClientContext &context, LogicalDelete &op,
+	                                                unique_ptr<PhysicalOperator> plan) = 0;
+	virtual unique_ptr<PhysicalOperator> PlanUpdate(ClientContext &context, LogicalUpdate &op,
+	                                                unique_ptr<PhysicalOperator> plan) = 0;
+	virtual unique_ptr<LogicalOperator> BindCreateIndex(Binder &binder, CreateStatement &stmt, TableCatalogEntry &table,
+	                                                    unique_ptr<LogicalOperator> plan) = 0;
+
+	virtual DatabaseSize GetDatabaseSize(ClientContext &context) = 0;
+
+	virtual bool InMemory() = 0;
+	virtual string GetDBPath() = 0;
+
 public:
 	template <class T>
 	static T *GetEntry(ClientContext &context, const string &catalog_name, const string &schema_name,
@@ -222,12 +245,13 @@ public:
 		return (T *)entry;
 	}
 
+	DUCKDB_API vector<SchemaCatalogEntry *> GetSchemas(ClientContext &context);
 	DUCKDB_API static vector<SchemaCatalogEntry *> GetSchemas(ClientContext &context, const string &catalog_name);
 	DUCKDB_API static vector<SchemaCatalogEntry *> GetAllSchemas(ClientContext &context);
 
-	DUCKDB_API void Verify();
+	virtual void Verify();
 
-private:
+protected:
 	//! Reference to the database
 	AttachedDatabase &db;
 
@@ -250,7 +274,7 @@ private:
 	static SimilarCatalogEntry SimilarEntryInSchemas(ClientContext &context, const string &entry_name, CatalogType type,
 	                                                 const unordered_set<SchemaCatalogEntry *> &schemas);
 
-	void DropSchema(ClientContext &context, DropInfo *info);
+	virtual void DropSchema(ClientContext &context, DropInfo *info) = 0;
 };
 
 } // namespace duckdb

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

@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/catalog/catalog_entry/dindex_catalog_entry.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/catalog/catalog_entry/index_catalog_entry.hpp"
+
+namespace duckdb {
+
+//! An index catalog entry
+class DuckIndexEntry : public IndexCatalogEntry {
+public:
+	//! Create an IndexCatalogEntry and initialize storage for it
+	DuckIndexEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateIndexInfo *info);
+	~DuckIndexEntry();
+
+	shared_ptr<DataTableInfo> info;
+
+public:
+	string GetSchemaName() override;
+	string GetTableName() override;
+};
+
+} // namespace duckdb

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

@@ -0,0 +1,69 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/catalog/catalog_entry/dschema_catalog_entry.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
+
+namespace duckdb {
+
+//! A schema in the catalog
+class DuckSchemaEntry : public SchemaCatalogEntry {
+public:
+	DuckSchemaEntry(Catalog *catalog, string name, bool is_internal);
+
+private:
+	//! The catalog set holding the tables
+	CatalogSet tables;
+	//! The catalog set holding the indexes
+	CatalogSet indexes;
+	//! The catalog set holding the table functions
+	CatalogSet table_functions;
+	//! The catalog set holding the copy functions
+	CatalogSet copy_functions;
+	//! The catalog set holding the pragma functions
+	CatalogSet pragma_functions;
+	//! The catalog set holding the scalar and aggregate functions
+	CatalogSet functions;
+	//! The catalog set holding the sequences
+	CatalogSet sequences;
+	//! The catalog set holding the collations
+	CatalogSet collations;
+	//! The catalog set holding the types
+	CatalogSet types;
+
+public:
+	CatalogEntry *AddEntry(CatalogTransaction transaction, unique_ptr<StandardEntry> entry,
+	                       OnCreateConflict on_conflict);
+	CatalogEntry *AddEntryInternal(CatalogTransaction transaction, unique_ptr<StandardEntry> entry,
+	                               OnCreateConflict on_conflict, DependencyList dependencies);
+
+	CatalogEntry *CreateTable(CatalogTransaction transaction, BoundCreateTableInfo *info) override;
+	CatalogEntry *CreateFunction(CatalogTransaction transaction, CreateFunctionInfo *info) override;
+	CatalogEntry *CreateIndex(ClientContext &context, CreateIndexInfo *info, TableCatalogEntry *table) override;
+	CatalogEntry *CreateView(CatalogTransaction transaction, CreateViewInfo *info) override;
+	CatalogEntry *CreateSequence(CatalogTransaction transaction, CreateSequenceInfo *info) override;
+	CatalogEntry *CreateTableFunction(CatalogTransaction transaction, CreateTableFunctionInfo *info) override;
+	CatalogEntry *CreateCopyFunction(CatalogTransaction transaction, CreateCopyFunctionInfo *info) override;
+	CatalogEntry *CreatePragmaFunction(CatalogTransaction transaction, CreatePragmaFunctionInfo *info) override;
+	CatalogEntry *CreateCollation(CatalogTransaction transaction, CreateCollationInfo *info) override;
+	CatalogEntry *CreateType(CatalogTransaction transaction, CreateTypeInfo *info) override;
+	void Alter(ClientContext &context, 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;
+	CatalogEntry *GetEntry(CatalogTransaction transaction, CatalogType type, const string &name) override;
+	SimilarCatalogEntry GetSimilarEntry(CatalogTransaction transaction, CatalogType type, const string &name) override;
+
+	void Verify(Catalog &catalog) override;
+
+private:
+	//! Get the catalog set for the specified type
+	CatalogSet &GetCatalogSet(CatalogType type);
+};
+} // namespace duckdb

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

@@ -0,0 +1,71 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/catalog/catalog_entry/dtable_catalog_entry.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
+
+namespace duckdb {
+
+//! A table catalog entry
+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);
+
+public:
+	unique_ptr<CatalogEntry> AlterEntry(ClientContext &context, AlterInfo *info) override;
+	void UndoAlter(ClientContext &context, AlterInfo *info) override;
+	//! Returns the underlying storage of the table
+	DataTable &GetStorage() override;
+	DataTable *GetStoragePtr() 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;
+
+	unique_ptr<CatalogEntry> Copy(ClientContext &context) override;
+
+	void SetAsRoot() override;
+
+	void CommitAlter(AlterInfo &info);
+	void CommitDrop();
+
+	TableFunction GetScanFunction(ClientContext &context, unique_ptr<FunctionData> &bind_data) override;
+
+	TableStorageInfo GetStorageInfo(ClientContext &context) override;
+
+	bool IsDuckTable() override {
+		return true;
+	}
+
+private:
+	unique_ptr<CatalogEntry> RenameColumn(ClientContext &context, RenameColumnInfo &info);
+	unique_ptr<CatalogEntry> AddColumn(ClientContext &context, AddColumnInfo &info);
+	unique_ptr<CatalogEntry> RemoveColumn(ClientContext &context, RemoveColumnInfo &info);
+	unique_ptr<CatalogEntry> SetDefault(ClientContext &context, SetDefaultInfo &info);
+	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> DropForeignKeyConstraint(ClientContext &context, AlterForeignKeyInfo &info);
+
+	void UpdateConstraintsOnColumnDrop(const LogicalIndex &removed_index, const vector<LogicalIndex> &adjusted_indices,
+	                                   const RemoveColumnInfo &info, CreateTableInfo &create_info, 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;
+	//! Manages dependencies of the individual columns of the table
+	ColumnDependencyManager column_dependency_manager;
+};
+} // namespace duckdb

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

@@ -26,10 +26,8 @@ public:
 public:
 	//! Create an IndexCatalogEntry and initialize storage for it
 	IndexCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateIndexInfo *info);
-	~IndexCatalogEntry() override;
 
 	Index *index;
-	shared_ptr<DataTableInfo> info;
 	string sql;
 	vector<unique_ptr<ParsedExpression>> expressions;
 	vector<unique_ptr<ParsedExpression>> parsed_expressions;
@@ -38,6 +36,9 @@ public:
 	string ToSQL() override;
 	void Serialize(duckdb::MetaBlockWriter &serializer);
 	static unique_ptr<CreateIndexInfo> Deserialize(Deserializer &source, ClientContext &context);
+
+	virtual string GetSchemaName() = 0;
+	virtual string GetTableName() = 0;
 };
 
 } // namespace duckdb