duckdb 0.7.2-dev314.0 → 0.7.2-dev3154.0

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

@@ -23,16 +23,16 @@ static unique_ptr<FunctionData> RepeatBind(ClientContext &context, TableFunction
 	auto &inputs = input.inputs;
 	return_types.push_back(inputs[0].type());
 	names.push_back(inputs[0].ToString());
-	return make_unique<RepeatFunctionData>(inputs[0], inputs[1].GetValue<int64_t>());
+	return make_uniq<RepeatFunctionData>(inputs[0], inputs[1].GetValue<int64_t>());
 }
 
 static unique_ptr<GlobalTableFunctionState> RepeatInit(ClientContext &context, TableFunctionInitInput &input) {
-	return make_unique<RepeatOperatorData>();
+	return make_uniq<RepeatOperatorData>();
 }
 
 static void RepeatFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
 	auto &bind_data = (const RepeatFunctionData &)*data_p.bind_data;
-	auto &state = (RepeatOperatorData &)*data_p.global_state;
+	auto &state = data_p.global_state->Cast<RepeatOperatorData>();
 
 	idx_t remaining = MinValue<idx_t>(bind_data.target_count - state.current_count, STANDARD_VECTOR_SIZE);
 	output.data[0].Reference(bind_data.value);
@@ -42,7 +42,7 @@ static void RepeatFunction(ClientContext &context, TableFunctionInput &data_p, D
 
 static unique_ptr<NodeStatistics> RepeatCardinality(ClientContext &context, const FunctionData *bind_data_p) {
 	auto &bind_data = (const RepeatFunctionData &)*bind_data_p;
-	return make_unique<NodeStatistics>(bind_data.target_count, bind_data.target_count);
+	return make_uniq<NodeStatistics>(bind_data.target_count, bind_data.target_count);
 }
 
 void RepeatTableFunction::RegisterFunction(BuiltinFunctions &set) {

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

@@ -0,0 +1,60 @@
+#include "duckdb/function/table/range.hpp"
+#include "duckdb/common/algorithm.hpp"
+
+namespace duckdb {
+
+struct RepeatRowFunctionData : public TableFunctionData {
+	RepeatRowFunctionData(vector<Value> values, idx_t target_count)
+	    : values(std::move(values)), target_count(target_count) {
+	}
+
+	const vector<Value> values;
+	idx_t target_count;
+};
+
+struct RepeatRowOperatorData : public GlobalTableFunctionState {
+	RepeatRowOperatorData() : current_count(0) {
+	}
+	idx_t current_count;
+};
+
+static unique_ptr<FunctionData> RepeatRowBind(ClientContext &context, TableFunctionBindInput &input,
+                                              vector<LogicalType> &return_types, vector<string> &names) {
+	auto &inputs = input.inputs;
+	for (idx_t input_idx = 0; input_idx < inputs.size(); input_idx++) {
+		return_types.push_back(inputs[input_idx].type());
+		names.push_back("column" + std::to_string(input_idx));
+	}
+	return make_uniq<RepeatRowFunctionData>(inputs, input.named_parameters["num_rows"].GetValue<int64_t>());
+}
+
+static unique_ptr<GlobalTableFunctionState> RepeatRowInit(ClientContext &context, TableFunctionInitInput &input) {
+	return make_uniq<RepeatRowOperatorData>();
+}
+
+static void RepeatRowFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+	auto &bind_data = (const RepeatRowFunctionData &)*data_p.bind_data;
+	auto &state = data_p.global_state->Cast<RepeatRowOperatorData>();
+
+	idx_t remaining = MinValue<idx_t>(bind_data.target_count - state.current_count, STANDARD_VECTOR_SIZE);
+	for (idx_t val_idx = 0; val_idx < bind_data.values.size(); val_idx++) {
+		output.data[val_idx].Reference(bind_data.values[val_idx]);
+	}
+	output.SetCardinality(remaining);
+	state.current_count += remaining;
+}
+
+static unique_ptr<NodeStatistics> RepeatRowCardinality(ClientContext &context, const FunctionData *bind_data_p) {
+	auto &bind_data = (const RepeatRowFunctionData &)*bind_data_p;
+	return make_uniq<NodeStatistics>(bind_data.target_count, bind_data.target_count);
+}
+
+void RepeatRowTableFunction::RegisterFunction(BuiltinFunctions &set) {
+	TableFunction repeat_row("repeat_row", {}, RepeatRowFunction, RepeatRowBind, RepeatRowInit);
+	repeat_row.varargs = LogicalType::ANY;
+	repeat_row.named_parameters["num_rows"] = LogicalType::BIGINT;
+	repeat_row.cardinality = RepeatRowCardinality;
+	set.AddFunction(repeat_row);
+}
+
+} // namespace duckdb

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

@@ -18,7 +18,7 @@ static unique_ptr<FunctionData> SummaryFunctionBind(ClientContext &context, Tabl
 		names.emplace_back(input.input_table_names[i]);
 	}
 
-	return make_unique<TableFunctionData>();
+	return make_uniq<TableFunctionData>();
 }
 
 static OperatorResultType SummaryFunction(ExecutionContext &context, TableFunctionInput &data_p, DataChunk &input,

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

@@ -16,7 +16,7 @@ struct DuckDBColumnsData : public GlobalTableFunctionState {
 	DuckDBColumnsData() : offset(0), column_offset(0) {
 	}
 
-	vector<CatalogEntry *> entries;
+	vector<reference<CatalogEntry>> entries;
 	idx_t offset;
 	idx_t column_offset;
 };
@@ -78,24 +78,25 @@ static unique_ptr<FunctionData> DuckDBColumnsBind(ClientContext &context, TableF
 }
 
 unique_ptr<GlobalTableFunctionState> DuckDBColumnsInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_unique<DuckDBColumnsData>();
+	auto result = make_uniq<DuckDBColumnsData>();
 
 	// scan all the schemas for tables and views and collect them
 	auto schemas = Catalog::GetAllSchemas(context);
 	for (auto &schema : schemas) {
-		schema->Scan(context, CatalogType::TABLE_ENTRY, [&](CatalogEntry *entry) { result->entries.push_back(entry); });
+		schema.get().Scan(context, CatalogType::TABLE_ENTRY,
+		                  [&](CatalogEntry &entry) { result->entries.push_back(entry); });
 	}
 	return std::move(result);
 }
 
 class ColumnHelper {
 public:
-	static unique_ptr<ColumnHelper> Create(CatalogEntry *entry);
+	static unique_ptr<ColumnHelper> Create(CatalogEntry &entry);
 
 	virtual ~ColumnHelper() {
 	}
 
-	virtual StandardEntry *Entry() = 0;
+	virtual StandardEntry &Entry() = 0;
 	virtual idx_t NumColumns() = 0;
 	virtual const string &ColumnName(idx_t col) = 0;
 	virtual const LogicalType &ColumnType(idx_t col) = 0;
@@ -107,8 +108,8 @@ public:
 
 class TableColumnHelper : public ColumnHelper {
 public:
-	explicit TableColumnHelper(TableCatalogEntry *entry) : entry(entry) {
-		for (auto &constraint : entry->GetConstraints()) {
+	explicit TableColumnHelper(TableCatalogEntry &entry) : entry(entry) {
+		for (auto &constraint : entry.GetConstraints()) {
 			if (constraint->type == ConstraintType::NOT_NULL) {
 				auto &not_null = *reinterpret_cast<NotNullConstraint *>(constraint.get());
 				not_null_cols.insert(not_null.index.index);
@@ -116,20 +117,20 @@ public:
 		}
 	}
 
-	StandardEntry *Entry() override {
+	StandardEntry &Entry() override {
 		return entry;
 	}
 	idx_t NumColumns() override {
-		return entry->GetColumns().LogicalColumnCount();
+		return entry.GetColumns().LogicalColumnCount();
 	}
 	const string &ColumnName(idx_t col) override {
-		return entry->GetColumn(LogicalIndex(col)).Name();
+		return entry.GetColumn(LogicalIndex(col)).Name();
 	}
 	const LogicalType &ColumnType(idx_t col) override {
-		return entry->GetColumn(LogicalIndex(col)).Type();
+		return entry.GetColumn(LogicalIndex(col)).Type();
 	}
 	const Value ColumnDefault(idx_t col) override {
-		auto &column = entry->GetColumn(LogicalIndex(col));
+		auto &column = entry.GetColumn(LogicalIndex(col));
 		if (column.DefaultValue()) {
 			return Value(column.DefaultValue()->ToString());
 		}
@@ -140,26 +141,26 @@ public:
 	}
 
 private:
-	TableCatalogEntry *entry;
+	TableCatalogEntry &entry;
 	std::set<idx_t> not_null_cols;
 };
 
 class ViewColumnHelper : public ColumnHelper {
 public:
-	explicit ViewColumnHelper(ViewCatalogEntry *entry) : entry(entry) {
+	explicit ViewColumnHelper(ViewCatalogEntry &entry) : entry(entry) {
 	}
 
-	StandardEntry *Entry() override {
+	StandardEntry &Entry() override {
 		return entry;
 	}
 	idx_t NumColumns() override {
-		return entry->types.size();
+		return entry.types.size();
 	}
 	const string &ColumnName(idx_t col) override {
-		return entry->aliases[col];
+		return entry.aliases[col];
 	}
 	const LogicalType &ColumnType(idx_t col) override {
-		return entry->types[col];
+		return entry.types[col];
 	}
 	const Value ColumnDefault(idx_t col) override {
 		return Value();
@@ -169,15 +170,15 @@ public:
 	}
 
 private:
-	ViewCatalogEntry *entry;
+	ViewCatalogEntry &entry;
 };
 
-unique_ptr<ColumnHelper> ColumnHelper::Create(CatalogEntry *entry) {
-	switch (entry->type) {
+unique_ptr<ColumnHelper> ColumnHelper::Create(CatalogEntry &entry) {
+	switch (entry.type) {
 	case CatalogType::TABLE_ENTRY:
-		return make_unique<TableColumnHelper>((TableCatalogEntry *)entry);
+		return make_uniq<TableColumnHelper>(entry.Cast<TableCatalogEntry>());
 	case CatalogType::VIEW_ENTRY:
-		return make_unique<ViewColumnHelper>((ViewCatalogEntry *)entry);
+		return make_uniq<ViewColumnHelper>(entry.Cast<ViewCatalogEntry>());
 	default:
 		throw NotImplementedException("Unsupported catalog type for duckdb_columns");
 	}
@@ -186,17 +187,17 @@ unique_ptr<ColumnHelper> ColumnHelper::Create(CatalogEntry *entry) {
 void ColumnHelper::WriteColumns(idx_t start_index, idx_t start_col, idx_t end_col, DataChunk &output) {
 	for (idx_t i = start_col; i < end_col; i++) {
 		auto index = start_index + (i - start_col);
-		auto &entry = *Entry();
+		auto &entry = Entry();
 
 		idx_t col = 0;
 		// database_name, VARCHAR
-		output.SetValue(col++, index, entry.catalog->GetName());
+		output.SetValue(col++, index, entry.catalog.GetName());
 		// database_oid, BIGINT
-		output.SetValue(col++, index, Value::BIGINT(entry.catalog->GetOid()));
+		output.SetValue(col++, index, Value::BIGINT(entry.catalog.GetOid()));
 		// schema_name, VARCHAR
-		output.SetValue(col++, index, entry.schema->name);
+		output.SetValue(col++, index, entry.schema.name);
 		// schema_oid, BIGINT
-		output.SetValue(col++, index, Value::BIGINT(entry.schema->oid));
+		output.SetValue(col++, index, Value::BIGINT(entry.schema.oid));
 		// table_name, VARCHAR
 		output.SetValue(col++, index, entry.name);
 		// table_oid, BIGINT
@@ -284,7 +285,7 @@ void ColumnHelper::WriteColumns(idx_t start_index, idx_t start_col, idx_t end_co
 }
 
 void DuckDBColumnsFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = (DuckDBColumnsData &)*data_p.global_state;
+	auto &data = data_p.global_state->Cast<DuckDBColumnsData>();
 	if (data.offset >= data.entries.size()) {
 		// finished returning values
 		return;
@@ -298,7 +299,7 @@ void DuckDBColumnsFunction(ClientContext &context, TableFunctionInput &data_p, D
 	idx_t column_offset = data.column_offset;
 	idx_t index = 0;
 	while (next < data.entries.size() && index < STANDARD_VECTOR_SIZE) {
-		auto column_helper = ColumnHelper::Create(data.entries[next]);
+		auto column_helper = ColumnHelper::Create(data.entries[next].get());
 		idx_t columns = column_helper->NumColumns();
 
 		// Check to see if we are going to exceed the maximum index for a DataChunk

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

@@ -19,7 +19,8 @@
 namespace duckdb {
 
 struct UniqueKeyInfo {
-	string schema, table;
+	string schema;
+	string table;
 	vector<LogicalIndex> columns;
 
 	bool operator==(const UniqueKeyInfo &other) const {
@@ -52,7 +53,7 @@ struct DuckDBConstraintsData : public GlobalTableFunctionState {
 	DuckDBConstraintsData() : offset(0), constraint_offset(0), unique_constraint_offset(0) {
 	}
 
-	vector<CatalogEntry *> entries;
+	vector<reference<CatalogEntry>> entries;
 	idx_t offset;
 	idx_t constraint_offset;
 	idx_t unique_constraint_offset;
@@ -102,21 +103,21 @@ static unique_ptr<FunctionData> DuckDBConstraintsBind(ClientContext &context, Ta
 }
 
 unique_ptr<GlobalTableFunctionState> DuckDBConstraintsInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_unique<DuckDBConstraintsData>();
+	auto result = make_uniq<DuckDBConstraintsData>();
 
 	// scan all the schemas for tables and collect them
 	auto schemas = Catalog::GetAllSchemas(context);
 
 	for (auto &schema : schemas) {
-		vector<CatalogEntry *> entries;
+		vector<reference<CatalogEntry>> entries;
 
-		schema->Scan(context, CatalogType::TABLE_ENTRY, [&](CatalogEntry *entry) {
-			if (entry->type == CatalogType::TABLE_ENTRY) {
+		schema.get().Scan(context, CatalogType::TABLE_ENTRY, [&](CatalogEntry &entry) {
+			if (entry.type == CatalogType::TABLE_ENTRY) {
 				entries.push_back(entry);
 			}
 		});
 
-		sort(entries.begin(), entries.end(), [&](CatalogEntry *x, CatalogEntry *y) { return (x->name < y->name); });
+		sort(entries.begin(), entries.end(), [&](CatalogEntry &x, CatalogEntry &y) { return (x.name < y.name); });
 
 		result->entries.insert(result->entries.end(), entries.begin(), entries.end());
 	};
@@ -125,7 +126,7 @@ unique_ptr<GlobalTableFunctionState> DuckDBConstraintsInit(ClientContext &contex
 }
 
 void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = (DuckDBConstraintsData &)*data_p.global_state;
+	auto &data = data_p.global_state->Cast<DuckDBConstraintsData>();
 	if (data.offset >= data.entries.size()) {
 		// finished returning values
 		return;
@@ -134,10 +135,10 @@ void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_
 	// either fill up the chunk or return all the remaining columns
 	idx_t count = 0;
 	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &entry = data.entries[data.offset];
-		D_ASSERT(entry->type == CatalogType::TABLE_ENTRY);
+		auto &entry = data.entries[data.offset].get();
+		D_ASSERT(entry.type == CatalogType::TABLE_ENTRY);
 
-		auto &table = (TableCatalogEntry &)*entry;
+		auto &table = entry.Cast<TableCatalogEntry>();
 		auto &constraints = table.GetConstraints();
 		bool is_duck_table = table.IsDuckTable();
 		for (; data.constraint_offset < constraints.size() && count < STANDARD_VECTOR_SIZE; data.constraint_offset++) {
@@ -151,7 +152,7 @@ void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_
 				constraint_type = "CHECK";
 				break;
 			case ConstraintType::UNIQUE: {
-				auto &unique = (UniqueConstraint &)*constraint;
+				auto &unique = constraint->Cast<UniqueConstraint>();
 				constraint_type = unique.is_primary_key ? "PRIMARY KEY" : "UNIQUE";
 				break;
 			}
@@ -163,7 +164,7 @@ void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_
 					continue;
 				}
 				auto &bound_constraints = table.GetBoundConstraints();
-				auto &bound_foreign_key = (const BoundForeignKeyConstraint &)*bound_constraints[data.constraint_offset];
+				auto &bound_foreign_key = bound_constraints[data.constraint_offset]->Cast<BoundForeignKeyConstraint>();
 				if (bound_foreign_key.info.type == ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE) {
 					// Those are already covered by PRIMARY KEY and UNIQUE entries
 					continue;
@@ -177,13 +178,13 @@ void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_
 
 			idx_t col = 0;
 			// database_name, LogicalType::VARCHAR
-			output.SetValue(col++, count, Value(table.schema->catalog->GetName()));
+			output.SetValue(col++, count, Value(table.schema.catalog.GetName()));
 			// database_oid, LogicalType::BIGINT
-			output.SetValue(col++, count, Value::BIGINT(table.schema->catalog->GetOid()));
+			output.SetValue(col++, count, Value::BIGINT(table.schema.catalog.GetOid()));
 			// schema_name, LogicalType::VARCHAR
-			output.SetValue(col++, count, Value(table.schema->name));
+			output.SetValue(col++, count, Value(table.schema.name));
 			// schema_oid, LogicalType::BIGINT
-			output.SetValue(col++, count, Value::BIGINT(table.schema->oid));
+			output.SetValue(col++, count, Value::BIGINT(table.schema.oid));
 			// table_name, LogicalType::VARCHAR
 			output.SetValue(col++, count, Value(table.name));
 			// table_oid, LogicalType::BIGINT
@@ -193,19 +194,19 @@ void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_
 			UniqueKeyInfo uk_info;
 
 			if (is_duck_table) {
-				auto &bound_constraint = (BoundConstraint &)*table.GetBoundConstraints()[data.constraint_offset];
+				auto &bound_constraint = *table.GetBoundConstraints()[data.constraint_offset];
 				switch (bound_constraint.type) {
 				case ConstraintType::UNIQUE: {
-					auto &bound_unique = (BoundUniqueConstraint &)bound_constraint;
-					uk_info = {table.schema->name, table.name, bound_unique.keys};
+					auto &bound_unique = bound_constraint.Cast<BoundUniqueConstraint>();
+					uk_info = {table.schema.name, table.name, bound_unique.keys};
 					break;
 				}
 				case ConstraintType::FOREIGN_KEY: {
-					const auto &bound_foreign_key = (const BoundForeignKeyConstraint &)bound_constraint;
+					const auto &bound_foreign_key = bound_constraint.Cast<BoundForeignKeyConstraint>();
 					const auto &info = bound_foreign_key.info;
 					// find the other table
-					auto table_entry =
-					    Catalog::GetEntry<TableCatalogEntry>(context, INVALID_CATALOG, info.schema, info.table, true);
+					auto table_entry = Catalog::GetEntry<TableCatalogEntry>(
+					    context, table.catalog.GetName(), info.schema, info.table, OnEntryNotFound::RETURN_NULL);
 					if (!table_entry) {
 						throw InternalException("dukdb_constraints: entry %s.%s referenced in foreign key not found",
 						                        info.schema, info.table);
@@ -214,7 +215,7 @@ void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_
 					for (auto &key : info.pk_keys) {
 						index.push_back(table_entry->GetColumns().PhysicalToLogical(key));
 					}
-					uk_info = {table_entry->schema->name, table_entry->name, index};
+					uk_info = {table_entry->schema.name, table_entry->name, index};
 					break;
 				}
 				default:
@@ -242,36 +243,36 @@ void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_
 			// expression, VARCHAR
 			Value expression_text;
 			if (constraint->type == ConstraintType::CHECK) {
-				auto &check = (CheckConstraint &)*constraint;
+				auto &check = constraint->Cast<CheckConstraint>();
 				expression_text = Value(check.expression->ToString());
 			}
 			output.SetValue(col++, count, expression_text);
 
 			vector<LogicalIndex> column_index_list;
 			if (is_duck_table) {
-				auto &bound_constraint = (BoundConstraint &)*table.GetBoundConstraints()[data.constraint_offset];
+				auto &bound_constraint = *table.GetBoundConstraints()[data.constraint_offset];
 				switch (bound_constraint.type) {
 				case ConstraintType::CHECK: {
-					auto &bound_check = (BoundCheckConstraint &)bound_constraint;
+					auto &bound_check = bound_constraint.Cast<BoundCheckConstraint>();
 					for (auto &col_idx : bound_check.bound_columns) {
 						column_index_list.push_back(table.GetColumns().PhysicalToLogical(col_idx));
 					}
 					break;
 				}
 				case ConstraintType::UNIQUE: {
-					auto &bound_unique = (BoundUniqueConstraint &)bound_constraint;
+					auto &bound_unique = bound_constraint.Cast<BoundUniqueConstraint>();
 					for (auto &col_idx : bound_unique.keys) {
 						column_index_list.push_back(col_idx);
 					}
 					break;
 				}
 				case ConstraintType::NOT_NULL: {
-					auto &bound_not_null = (BoundNotNullConstraint &)bound_constraint;
+					auto &bound_not_null = bound_constraint.Cast<BoundNotNullConstraint>();
 					column_index_list.push_back(table.GetColumns().PhysicalToLogical(bound_not_null.index));
 					break;
 				}
 				case ConstraintType::FOREIGN_KEY: {
-					auto &bound_foreign_key = (const BoundForeignKeyConstraint &)bound_constraint;
+					auto &bound_foreign_key = bound_constraint.Cast<BoundForeignKeyConstraint>();
 					for (auto &col_idx : bound_foreign_key.info.fk_keys) {
 						column_index_list.push_back(table.GetColumns().PhysicalToLogical(col_idx));
 					}

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

@@ -8,7 +8,7 @@ struct DuckDBDatabasesData : public GlobalTableFunctionState {
 	DuckDBDatabasesData() : offset(0) {
 	}
 
-	vector<AttachedDatabase *> entries;
+	vector<reference<AttachedDatabase>> entries;
 	idx_t offset;
 };
 
@@ -33,7 +33,7 @@ static unique_ptr<FunctionData> DuckDBDatabasesBind(ClientContext &context, Tabl
 }
 
 unique_ptr<GlobalTableFunctionState> DuckDBDatabasesInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_unique<DuckDBDatabasesData>();
+	auto result = make_uniq<DuckDBDatabasesData>();
 
 	// scan all the schemas for tables and collect them and collect them
 	auto &db_manager = DatabaseManager::Get(context);
@@ -42,7 +42,7 @@ unique_ptr<GlobalTableFunctionState> DuckDBDatabasesInit(ClientContext &context,
 }
 
 void DuckDBDatabasesFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = (DuckDBDatabasesData &)*data_p.global_state;
+	auto &data = data_p.global_state->Cast<DuckDBDatabasesData>();
 	if (data.offset >= data.entries.size()) {
 		// finished returning values
 		return;
@@ -53,7 +53,7 @@ void DuckDBDatabasesFunction(ClientContext &context, TableFunctionInput &data_p,
 	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
 		auto &entry = data.entries[data.offset++];
 
-		auto &attached = (AttachedDatabase &)*entry;
+		auto &attached = entry.get().Cast<AttachedDatabase>();
 		// return values:
 
 		idx_t col = 0;

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

@@ -9,8 +9,12 @@
 namespace duckdb {
 
 struct DependencyInformation {
-	CatalogEntry *object;
-	CatalogEntry *dependent;
+	DependencyInformation(CatalogEntry &object, CatalogEntry &dependent, DependencyType type)
+	    : object(object), dependent(dependent), type(type) {
+	}
+
+	CatalogEntry &object;
+	CatalogEntry &dependent;
 	DependencyType type;
 };
 
@@ -49,19 +53,15 @@ static unique_ptr<FunctionData> DuckDBDependenciesBind(ClientContext &context, T
 }
 
 unique_ptr<GlobalTableFunctionState> DuckDBDependenciesInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_unique<DuckDBDependenciesData>();
+	auto result = make_uniq<DuckDBDependenciesData>();
 
 	// scan all the schemas and collect them
 	auto &catalog = Catalog::GetCatalog(context, INVALID_CATALOG);
 	if (catalog.IsDuckCatalog()) {
-		auto &duck_catalog = (DuckCatalog &)catalog;
+		auto &duck_catalog = catalog.Cast<DuckCatalog>();
 		auto &dependency_manager = duck_catalog.GetDependencyManager();
-		dependency_manager.Scan([&](CatalogEntry *obj, CatalogEntry *dependent, DependencyType type) {
-			DependencyInformation info;
-			info.object = obj;
-			info.dependent = dependent;
-			info.type = type;
-			result->entries.push_back(info);
+		dependency_manager.Scan([&](CatalogEntry &obj, CatalogEntry &dependent, DependencyType type) {
+			result->entries.emplace_back(obj, dependent, type);
 		});
 	}
 
@@ -69,7 +69,7 @@ unique_ptr<GlobalTableFunctionState> DuckDBDependenciesInit(ClientContext &conte
 }
 
 void DuckDBDependenciesFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = (DuckDBDependenciesData &)*data_p.global_state;
+	auto &data = data_p.global_state->Cast<DuckDBDependenciesData>();
 	if (data.offset >= data.entries.size()) {
 		// finished returning values
 		return;
@@ -84,13 +84,13 @@ void DuckDBDependenciesFunction(ClientContext &context, TableFunctionInput &data
 		// classid, LogicalType::BIGINT
 		output.SetValue(0, count, Value::BIGINT(0));
 		// objid, LogicalType::BIGINT
-		output.SetValue(1, count, Value::BIGINT(entry.object->oid));
+		output.SetValue(1, count, Value::BIGINT(entry.object.oid));
 		// objsubid, LogicalType::INTEGER
 		output.SetValue(2, count, Value::INTEGER(0));
 		// refclassid, LogicalType::BIGINT
 		output.SetValue(3, count, Value::BIGINT(0));
 		// refobjid, LogicalType::BIGINT
-		output.SetValue(4, count, Value::BIGINT(entry.dependent->oid));
+		output.SetValue(4, count, Value::BIGINT(entry.dependent.oid));
 		// refobjsubid, LogicalType::INTEGER
 		output.SetValue(5, count, Value::INTEGER(0));
 		// deptype, LogicalType::VARCHAR

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

@@ -51,7 +51,7 @@ static unique_ptr<FunctionData> DuckDBExtensionsBind(ClientContext &context, Tab
 }
 
 unique_ptr<GlobalTableFunctionState> DuckDBExtensionsInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_unique<DuckDBExtensionsData>();
+	auto result = make_uniq<DuckDBExtensionsData>();
 
 	auto &fs = FileSystem::GetFileSystem(context);
 	auto &db = DatabaseInstance::GetDatabase(context);
@@ -75,7 +75,7 @@ unique_ptr<GlobalTableFunctionState> DuckDBExtensionsInit(ClientContext &context
 		}
 		installed_extensions[info.name] = std::move(info);
 	}
-
+#ifndef WASM_LOADABLE_EXTENSIONS
 	// scan the install directory for installed extensions
 	auto ext_directory = ExtensionHelper::ExtensionDirectory(context);
 	fs.ListFiles(ext_directory, [&](const string &path, bool is_directory) {
@@ -96,7 +96,7 @@ unique_ptr<GlobalTableFunctionState> DuckDBExtensionsInit(ClientContext &context
 			entry->second.installed = true;
 		}
 	});
-
+#endif
 	// now check the list of currently loaded extensions
 	auto &loaded_extensions = db.LoadedExtensions();
 	for (auto &ext_name : loaded_extensions) {
@@ -119,7 +119,7 @@ unique_ptr<GlobalTableFunctionState> DuckDBExtensionsInit(ClientContext &context
 }
 
 void DuckDBExtensionsFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = (DuckDBExtensionsData &)*data_p.global_state;
+	auto &data = data_p.global_state->Cast<DuckDBExtensionsData>();
 	if (data.offset >= data.entries.size()) {
 		// finished returning values
 		return;