duckdb 0.7.2-dev225.0 → 0.7.2-dev2320.0

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

@@ -58,7 +58,7 @@ static unique_ptr<FunctionData> DuckDBTypesBind(ClientContext &context, TableFun
 }
 
 unique_ptr<GlobalTableFunctionState> DuckDBTypesInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_unique<DuckDBTypesData>();
+	auto result = make_uniq<DuckDBTypesData>();
 	auto schemas = Catalog::GetAllSchemas(context);
 	for (auto &schema : schemas) {
 		schema->Scan(context, CatalogType::TYPE_ENTRY,
@@ -68,7 +68,7 @@ unique_ptr<GlobalTableFunctionState> DuckDBTypesInit(ClientContext &context, Tab
 }
 
 void DuckDBTypesFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = (DuckDBTypesData &)*data_p.global_state;
+	auto &data = data_p.global_state->Cast<DuckDBTypesData>();
 	if (data.offset >= data.entries.size()) {
 		// finished returning values
 		return;

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

@@ -53,7 +53,7 @@ static unique_ptr<FunctionData> DuckDBViewsBind(ClientContext &context, TableFun
 }
 
 unique_ptr<GlobalTableFunctionState> DuckDBViewsInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_unique<DuckDBViewsData>();
+	auto result = make_uniq<DuckDBViewsData>();
 
 	// scan all the schemas for tables and collect them and collect them
 	auto schemas = Catalog::GetAllSchemas(context);
@@ -78,7 +78,7 @@ void DuckDBViewsFunction(ClientContext &context, TableFunctionInput &data_p, Dat
 		if (entry->type != CatalogType::VIEW_ENTRY) {
 			continue;
 		}
-		auto &view = (ViewCatalogEntry &)*entry;
+		auto &view = entry->Cast<ViewCatalogEntry>();
 
 		// return values:
 		idx_t col = 0;

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

@@ -24,7 +24,7 @@ static unique_ptr<FunctionData> PragmaCollateBind(ClientContext &context, TableF
 }
 
 unique_ptr<GlobalTableFunctionState> PragmaCollateInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_unique<PragmaCollateData>();
+	auto result = make_uniq<PragmaCollateData>();
 
 	auto schemas = Catalog::GetAllSchemas(context);
 	for (auto schema : schemas) {
@@ -35,7 +35,7 @@ unique_ptr<GlobalTableFunctionState> PragmaCollateInit(ClientContext &context, T
 }
 
 static void PragmaCollateFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = (PragmaCollateData &)*data_p.global_state;
+	auto &data = data_p.global_state->Cast<PragmaCollateData>();
 	if (data.offset >= data.entries.size()) {
 		// finished returning values
 		return;

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

@@ -15,7 +15,7 @@ struct PragmaDatabaseSizeData : public GlobalTableFunctionState {
 	}
 
 	idx_t index;
-	vector<AttachedDatabase *> databases;
+	vector<optional_ptr<AttachedDatabase>> databases;
 	Value memory_usage;
 	Value memory_limit;
 };
@@ -53,7 +53,7 @@ static unique_ptr<FunctionData> PragmaDatabaseSizeBind(ClientContext &context, T
 }
 
 unique_ptr<GlobalTableFunctionState> PragmaDatabaseSizeInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_unique<PragmaDatabaseSizeData>();
+	auto result = make_uniq<PragmaDatabaseSizeData>();
 	result->databases = DatabaseManager::Get(context).GetDatabases(context);
 	auto &buffer_manager = BufferManager::GetBufferManager(context);
 	result->memory_usage = Value(StringUtil::BytesToHumanReadableString(buffer_manager.GetUsedMemory()));
@@ -65,7 +65,7 @@ unique_ptr<GlobalTableFunctionState> PragmaDatabaseSizeInit(ClientContext &conte
 }
 
 void PragmaDatabaseSizeFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = (PragmaDatabaseSizeData &)*data_p.global_state;
+	auto &data = data_p.global_state->Cast<PragmaDatabaseSizeData>();
 	idx_t row = 0;
 	for (; data.index < data.databases.size() && row < STANDARD_VECTOR_SIZE; data.index++) {
 		auto db = data.databases[data.index];

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

@@ -11,16 +11,17 @@
 #include "duckdb/common/limits.hpp"
 #include "duckdb/storage/data_table.hpp"
 #include "duckdb/storage/table_storage_info.hpp"
+#include "duckdb/planner/binder.hpp"
 
 #include <algorithm>
 
 namespace duckdb {
 
 struct PragmaStorageFunctionData : public TableFunctionData {
-	explicit PragmaStorageFunctionData(TableCatalogEntry *table_entry) : table_entry(table_entry) {
+	explicit PragmaStorageFunctionData(TableCatalogEntry &table_entry) : table_entry(table_entry) {
 	}
 
-	TableCatalogEntry *table_entry;
+	TableCatalogEntry &table_entry;
 	TableStorageInfo storage_info;
 };
 
@@ -78,21 +79,22 @@ static unique_ptr<FunctionData> PragmaStorageInfoBind(ClientContext &context, Ta
 	auto qname = QualifiedName::Parse(input.inputs[0].GetValue<string>());
 
 	// look up the table name in the catalog
+	Binder::BindSchemaOrCatalog(context, qname.catalog, qname.schema);
 	auto table_entry = Catalog::GetEntry<TableCatalogEntry>(context, qname.catalog, qname.schema, qname.name);
-	auto result = make_unique<PragmaStorageFunctionData>(table_entry);
+	auto result = make_uniq<PragmaStorageFunctionData>(*table_entry);
 	result->storage_info = table_entry->GetStorageInfo(context);
 	return std::move(result);
 }
 
 unique_ptr<GlobalTableFunctionState> PragmaStorageInfoInit(ClientContext &context, TableFunctionInitInput &input) {
-	return make_unique<PragmaStorageOperatorData>();
+	return make_uniq<PragmaStorageOperatorData>();
 }
 
 static void PragmaStorageInfoFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &bind_data = (PragmaStorageFunctionData &)*data_p.bind_data;
-	auto &data = (PragmaStorageOperatorData &)*data_p.global_state;
+	auto &bind_data = data_p.bind_data->Cast<PragmaStorageFunctionData>();
+	auto &data = data_p.global_state->Cast<PragmaStorageOperatorData>();
 	idx_t count = 0;
-	auto &columns = bind_data.table_entry->GetColumns();
+	auto &columns = bind_data.table_entry.GetColumns();
 	while (data.offset < bind_data.storage_info.column_segments.size() && count < STANDARD_VECTOR_SIZE) {
 		auto &entry = bind_data.storage_info.column_segments[data.offset++];
 

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

@@ -17,10 +17,10 @@
 namespace duckdb {
 
 struct PragmaTableFunctionData : public TableFunctionData {
-	explicit PragmaTableFunctionData(CatalogEntry *entry_p) : entry(entry_p) {
+	explicit PragmaTableFunctionData(CatalogEntry &entry_p) : entry(entry_p) {
 	}
 
-	CatalogEntry *entry;
+	CatalogEntry &entry;
 };
 
 struct PragmaTableOperatorData : public GlobalTableFunctionState {
@@ -55,31 +55,30 @@ static unique_ptr<FunctionData> PragmaTableInfoBind(ClientContext &context, Tabl
 	// look up the table name in the catalog
 	Binder::BindSchemaOrCatalog(context, qname.catalog, qname.schema);
 	auto entry = Catalog::GetEntry(context, CatalogType::TABLE_ENTRY, qname.catalog, qname.schema, qname.name);
-	return make_unique<PragmaTableFunctionData>(entry);
+	return make_uniq<PragmaTableFunctionData>(*entry);
 }
 
 unique_ptr<GlobalTableFunctionState> PragmaTableInfoInit(ClientContext &context, TableFunctionInitInput &input) {
-	return make_unique<PragmaTableOperatorData>();
+	return make_uniq<PragmaTableOperatorData>();
 }
 
-static void CheckConstraints(TableCatalogEntry *table, const ColumnDefinition &column, bool &out_not_null,
+static void CheckConstraints(TableCatalogEntry &table, const ColumnDefinition &column, bool &out_not_null,
                              bool &out_pk) {
 	out_not_null = false;
 	out_pk = false;
 	// check all constraints
 	// FIXME: this is pretty inefficient, it probably doesn't matter
-	for (auto &constraint : table->GetConstraints()) {
+	for (auto &constraint : table.GetConstraints()) {
 		switch (constraint->type) {
 		case ConstraintType::NOT_NULL: {
-			auto &not_null = (NotNullConstraint &)*constraint;
+			auto &not_null = constraint->Cast<NotNullConstraint>();
 			if (not_null.index == column.Logical()) {
 				out_not_null = true;
 			}
 			break;
 		}
 		case ConstraintType::UNIQUE: {
-			auto &unique = (UniqueConstraint &)*constraint;
-
+			auto &unique = constraint->Cast<UniqueConstraint>();
 			if (unique.is_primary_key) {
 				if (unique.index == column.Logical()) {
 					out_pk = true;
@@ -96,20 +95,20 @@ static void CheckConstraints(TableCatalogEntry *table, const ColumnDefinition &c
 	}
 }
 
-static void PragmaTableInfoTable(PragmaTableOperatorData &data, TableCatalogEntry *table, DataChunk &output) {
-	if (data.offset >= table->GetColumns().LogicalColumnCount()) {
+static void PragmaTableInfoTable(PragmaTableOperatorData &data, TableCatalogEntry &table, DataChunk &output) {
+	if (data.offset >= table.GetColumns().LogicalColumnCount()) {
 		// finished returning values
 		return;
 	}
 	// start returning values
 	// either fill up the chunk or return all the remaining columns
-	idx_t next = MinValue<idx_t>(data.offset + STANDARD_VECTOR_SIZE, table->GetColumns().LogicalColumnCount());
+	idx_t next = MinValue<idx_t>(data.offset + STANDARD_VECTOR_SIZE, table.GetColumns().LogicalColumnCount());
 	output.SetCardinality(next - data.offset);
 
 	for (idx_t i = data.offset; i < next; i++) {
 		bool not_null, pk;
 		auto index = i - data.offset;
-		auto &column = table->GetColumn(LogicalIndex(i));
+		auto &column = table.GetColumn(LogicalIndex(i));
 		D_ASSERT(column.Oid() < (idx_t)NumericLimits<int32_t>::Maximum());
 		CheckConstraints(table, column, not_null, pk);
 
@@ -131,20 +130,20 @@ static void PragmaTableInfoTable(PragmaTableOperatorData &data, TableCatalogEntr
 	data.offset = next;
 }
 
-static void PragmaTableInfoView(PragmaTableOperatorData &data, ViewCatalogEntry *view, DataChunk &output) {
-	if (data.offset >= view->types.size()) {
+static void PragmaTableInfoView(PragmaTableOperatorData &data, ViewCatalogEntry &view, DataChunk &output) {
+	if (data.offset >= view.types.size()) {
 		// finished returning values
 		return;
 	}
 	// start returning values
 	// either fill up the chunk or return all the remaining columns
-	idx_t next = MinValue<idx_t>(data.offset + STANDARD_VECTOR_SIZE, view->types.size());
+	idx_t next = MinValue<idx_t>(data.offset + STANDARD_VECTOR_SIZE, view.types.size());
 	output.SetCardinality(next - data.offset);
 
 	for (idx_t i = data.offset; i < next; i++) {
 		auto index = i - data.offset;
-		auto type = view->types[i];
-		auto &name = view->aliases[i];
+		auto type = view.types[i];
+		auto &name = view.aliases[i];
 		// return values:
 		// "cid", PhysicalType::INT32
 
@@ -164,14 +163,14 @@ static void PragmaTableInfoView(PragmaTableOperatorData &data, ViewCatalogEntry
 }
 
 static void PragmaTableInfoFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &bind_data = (PragmaTableFunctionData &)*data_p.bind_data;
-	auto &state = (PragmaTableOperatorData &)*data_p.global_state;
-	switch (bind_data.entry->type) {
+	auto &bind_data = data_p.bind_data->Cast<PragmaTableFunctionData>();
+	auto &state = data_p.global_state->Cast<PragmaTableOperatorData>();
+	switch (bind_data.entry.type) {
 	case CatalogType::TABLE_ENTRY:
-		PragmaTableInfoTable(state, (TableCatalogEntry *)bind_data.entry, output);
+		PragmaTableInfoTable(state, bind_data.entry.Cast<TableCatalogEntry>(), output);
 		break;
 	case CatalogType::VIEW_ENTRY:
-		PragmaTableInfoView(state, (ViewCatalogEntry *)bind_data.entry, output);
+		PragmaTableInfoView(state, bind_data.entry.Cast<ViewCatalogEntry>(), output);
 		break;
 	default:
 		throw NotImplementedException("Unimplemented catalog type for pragma_table_info");

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

@@ -138,7 +138,7 @@ vector<TestType> TestAllTypesFun::GetTestTypes() {
 	child_list_t<LogicalType> struct_type_list;
 	struct_type_list.push_back(make_pair("a", LogicalType::INTEGER));
 	struct_type_list.push_back(make_pair("b", LogicalType::VARCHAR));
-	auto struct_type = LogicalType::STRUCT(std::move(struct_type_list));
+	auto struct_type = LogicalType::STRUCT(struct_type_list);
 
 	child_list_t<Value> min_struct_list;
 	min_struct_list.push_back(make_pair("a", Value(LogicalType::INTEGER)));
@@ -156,7 +156,7 @@ vector<TestType> TestAllTypesFun::GetTestTypes() {
 	child_list_t<LogicalType> struct_list_type_list;
 	struct_list_type_list.push_back(make_pair("a", int_list_type));
 	struct_list_type_list.push_back(make_pair("b", varchar_list_type));
-	auto struct_list_type = LogicalType::STRUCT(std::move(struct_list_type_list));
+	auto struct_list_type = LogicalType::STRUCT(struct_list_type_list);
 
 	child_list_t<Value> min_struct_vl_list;
 	min_struct_vl_list.push_back(make_pair("a", Value(int_list_type)));
@@ -180,7 +180,7 @@ vector<TestType> TestAllTypesFun::GetTestTypes() {
 
 	// map
 	auto map_type = LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR);
-	auto min_map_value = Value::MAP(ListType::GetChildType(map_type), std::vector<Value>());
+	auto min_map_value = Value::MAP(ListType::GetChildType(map_type), vector<Value>());
 
 	child_list_t<Value> map_struct1;
 	map_struct1.push_back(make_pair("key", Value("key1")));
@@ -189,7 +189,7 @@ vector<TestType> TestAllTypesFun::GetTestTypes() {
 	map_struct2.push_back(make_pair("key", Value("key2")));
 	map_struct2.push_back(make_pair("key", Value("goose")));
 
-	std::vector<Value> map_values;
+	vector<Value> map_values;
 	map_values.push_back(Value::STRUCT(map_struct1));
 	map_values.push_back(Value::STRUCT(map_struct2));
 
@@ -210,7 +210,7 @@ static unique_ptr<FunctionData> TestAllTypesBind(ClientContext &context, TableFu
 }
 
 unique_ptr<GlobalTableFunctionState> TestAllTypesInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto result = make_unique<TestAllTypesData>();
+	auto result = make_uniq<TestAllTypesData>();
 	auto test_types = TestAllTypesFun::GetTestTypes();
 	// 3 rows: min, max and NULL
 	result->entries.resize(3);
@@ -224,7 +224,7 @@ unique_ptr<GlobalTableFunctionState> TestAllTypesInit(ClientContext &context, Ta
 }
 
 void TestAllTypesFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = (TestAllTypesData &)*data_p.global_state;
+	auto &data = data_p.global_state->Cast<TestAllTypesData>();
 	if (data.offset >= data.entries.size()) {
 		// finished returning values
 		return;

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

@@ -78,7 +78,7 @@ struct TestVectorFlat {
 	static void Generate(TestVectorInfo &info) {
 		vector<Value> result_values = GenerateValues(info, info.type);
 		for (idx_t cur_row = 0; cur_row < result_values.size(); cur_row += STANDARD_VECTOR_SIZE) {
-			auto result = make_unique<DataChunk>();
+			auto result = make_uniq<DataChunk>();
 			result->Initialize(Allocator::DefaultAllocator(), {info.type});
 			auto cardinality = MinValue<idx_t>(STANDARD_VECTOR_SIZE, result_values.size() - cur_row);
 			for (idx_t i = 0; i < cardinality; i++) {
@@ -94,7 +94,7 @@ struct TestVectorConstant {
 	static void Generate(TestVectorInfo &info) {
 		auto values = TestVectorFlat::GenerateValues(info, info.type);
 		for (idx_t cur_row = 0; cur_row < TestVectorFlat::TEST_VECTOR_CARDINALITY; cur_row += STANDARD_VECTOR_SIZE) {
-			auto result = make_unique<DataChunk>();
+			auto result = make_uniq<DataChunk>();
 			result->Initialize(Allocator::DefaultAllocator(), {info.type});
 			auto cardinality = MinValue<idx_t>(STANDARD_VECTOR_SIZE, TestVectorFlat::TEST_VECTOR_CARDINALITY - cur_row);
 			result->data[0].SetValue(0, values[0]);
@@ -159,7 +159,7 @@ struct TestVectorSequence {
 
 	static void Generate(TestVectorInfo &info) {
 #if STANDARD_VECTOR_SIZE > 2
-		auto result = make_unique<DataChunk>();
+		auto result = make_uniq<DataChunk>();
 		result->Initialize(Allocator::DefaultAllocator(), {info.type});
 
 		GenerateVector(info, info.type, result->data[0]);
@@ -194,7 +194,7 @@ struct TestVectorDictionary {
 
 static unique_ptr<FunctionData> TestVectorTypesBind(ClientContext &context, TableFunctionBindInput &input,
                                                     vector<LogicalType> &return_types, vector<string> &names) {
-	auto result = make_unique<TestVectorBindData>();
+	auto result = make_uniq<TestVectorBindData>();
 	result->type = input.inputs[0].type();
 	result->all_flat = BooleanValue::Get(input.inputs[1]);
 
@@ -204,9 +204,9 @@ static unique_ptr<FunctionData> TestVectorTypesBind(ClientContext &context, Tabl
 }
 
 unique_ptr<GlobalTableFunctionState> TestVectorTypesInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto &bind_data = (TestVectorBindData &)*input.bind_data;
+	auto &bind_data = input.bind_data->Cast<TestVectorBindData>();
 
-	auto result = make_unique<TestVectorTypesData>();
+	auto result = make_uniq<TestVectorTypesData>();
 
 	auto test_types = TestAllTypesFun::GetTestTypes();