duckdb 0.8.1-dev96.0 → 0.8.2-dev1.0

package/src/duckdb/src/storage/data_table.cpp

@@ -13,6 +13,7 @@
 #include "duckdb/planner/table_filter.hpp"
 #include "duckdb/storage/checkpoint/table_data_writer.hpp"
 #include "duckdb/storage/storage_manager.hpp"
+#include "duckdb/storage/table_storage_info.hpp"
 #include "duckdb/storage/table/persistent_table_data.hpp"
 #include "duckdb/storage/table/row_group.hpp"
 #include "duckdb/storage/table/standard_column_data.hpp"
@@ -1201,13 +1202,14 @@ void DataTable::WALAddIndex(ClientContext &context, unique_ptr<Index> index,
 	// intermediate holds scanned chunks of the underlying data to create the index
 	DataChunk intermediate;
 	vector<LogicalType> intermediate_types;
-	auto column_ids = index->column_ids;
-	column_ids.push_back(COLUMN_IDENTIFIER_ROW_ID);
-	for (auto &id : index->column_ids) {
-		auto &col = column_definitions[id];
-		intermediate_types.push_back(col.Type());
+	vector<column_t> column_ids;
+	for (auto &it : column_definitions) {
+		intermediate_types.push_back(it.Type());
+		column_ids.push_back(it.Oid());
 	}
+	column_ids.push_back(COLUMN_IDENTIFIER_ROW_ID);
 	intermediate_types.emplace_back(LogicalType::ROW_TYPE);
+
 	intermediate.Initialize(allocator, intermediate_types);
 
 	// holds the result of executing the index expression on the intermediate chunks
@@ -1299,10 +1301,10 @@ void DataTable::CommitDropTable() {
 }
 
 //===--------------------------------------------------------------------===//
-// GetStorageInfo
+// GetColumnSegmentInfo
 //===--------------------------------------------------------------------===//
-void DataTable::GetStorageInfo(TableStorageInfo &result) {
-	row_groups->GetStorageInfo(result);
+vector<ColumnSegmentInfo> DataTable::GetColumnSegmentInfo() {
+	return row_groups->GetColumnSegmentInfo();
 }
 
 } // namespace duckdb

package/src/duckdb/src/storage/index.cpp

@@ -59,6 +59,19 @@ bool Index::MergeIndexes(Index &other_index) {
 	}
 }
 
+string Index::VerifyAndToString(const bool only_verify) {
+
+	IndexLock state;
+	InitializeLock(state);
+
+	switch (this->type) {
+	case IndexType::ART:
+		return Cast<ART>().VerifyAndToString(state, only_verify);
+	default:
+		throw InternalException("Unimplemented index type for VerifyAndToString");
+	}
+}
+
 void Index::Vacuum() {
 
 	IndexLock state;

package/src/duckdb/src/storage/storage_manager.cpp

@@ -12,6 +12,7 @@
 #include "duckdb/transaction/transaction_manager.hpp"
 #include "duckdb/common/serializer/buffered_file_reader.hpp"
 #include "duckdb/main/attached_database.hpp"
+#include "duckdb/main/database_manager.hpp"
 
 namespace duckdb {
 
@@ -98,6 +99,11 @@ void SingleFileStorageManager::LoadDatabase() {
 	auto &fs = FileSystem::Get(db);
 	auto &config = DBConfig::Get(db);
 	bool truncate_wal = false;
+	if (!config.options.enable_external_access) {
+		if (!db.IsInitialDatabase()) {
+			throw PermissionException("Attaching on-disk databases is disabled through configuration");
+		}
+	}
 
 	StorageManagerOptions options;
 	options.read_only = read_only;

package/src/duckdb/src/storage/table/column_data.cpp

@@ -488,7 +488,8 @@ shared_ptr<ColumnData> ColumnData::Deserialize(BlockManager &block_manager, Data
 	return entry;
 }
 
-void ColumnData::GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, TableStorageInfo &result) {
+void ColumnData::GetColumnSegmentInfo(idx_t row_group_index, vector<idx_t> col_path,
+                                      vector<ColumnSegmentInfo> &result) {
 	D_ASSERT(!col_path.empty());
 
 	// convert the column path to a string
@@ -515,7 +516,10 @@ void ColumnData::GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, T
 		column_info.segment_count = segment->count;
 		column_info.compression_type = CompressionTypeToString(segment->function.get().type);
 		column_info.segment_stats = segment->stats.statistics.ToString();
-		column_info.has_updates = updates ? true : false;
+		{
+			lock_guard<mutex> ulock(update_lock);
+			column_info.has_updates = updates ? true : false;
+		}
 		// persistent
 		// block_id
 		// block_offset
@@ -526,7 +530,7 @@ void ColumnData::GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, T
 		} else {
 			column_info.persistent = false;
 		}
-		result.column_segments.push_back(std::move(column_info));
+		result.emplace_back(column_info);
 
 		segment_idx++;
 		segment = (ColumnSegment *)data.GetNextSegment(segment);

package/src/duckdb/src/storage/table/list_column_data.cpp

@@ -349,12 +349,13 @@ void ListColumnData::DeserializeColumn(Deserializer &source) {
 	child_column->DeserializeColumn(source);
 }
 
-void ListColumnData::GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, TableStorageInfo &result) {
-	ColumnData::GetStorageInfo(row_group_index, col_path, result);
+void ListColumnData::GetColumnSegmentInfo(duckdb::idx_t row_group_index, vector<duckdb::idx_t> col_path,
+                                          vector<duckdb::ColumnSegmentInfo> &result) {
+	ColumnData::GetColumnSegmentInfo(row_group_index, col_path, result);
 	col_path.push_back(0);
-	validity.GetStorageInfo(row_group_index, col_path, result);
+	validity.GetColumnSegmentInfo(row_group_index, col_path, result);
 	col_path.back() = 1;
-	child_column->GetStorageInfo(row_group_index, col_path, result);
+	child_column->GetColumnSegmentInfo(row_group_index, col_path, result);
 }
 
 } // namespace duckdb

package/src/duckdb/src/storage/table/row_group.cpp

@@ -6,6 +6,7 @@
 #include "duckdb/storage/table/column_data.hpp"
 #include "duckdb/storage/table/column_checkpoint_state.hpp"
 #include "duckdb/storage/table/update_segment.hpp"
+#include "duckdb/storage/table_storage_info.hpp"
 #include "duckdb/common/chrono.hpp"
 #include "duckdb/planner/table_filter.hpp"
 #include "duckdb/execution/expression_executor.hpp"
@@ -912,12 +913,12 @@ RowGroupPointer RowGroup::Deserialize(Deserializer &main_source, const vector<Lo
 }
 
 //===--------------------------------------------------------------------===//
-// GetStorageInfo
+// GetColumnSegmentInfo
 //===--------------------------------------------------------------------===//
-void RowGroup::GetStorageInfo(idx_t row_group_index, TableStorageInfo &result) {
+void RowGroup::GetColumnSegmentInfo(idx_t row_group_index, vector<ColumnSegmentInfo> &result) {
 	for (idx_t col_idx = 0; col_idx < GetColumnCount(); col_idx++) {
 		auto &col_data = GetColumn(col_idx);
-		col_data.GetStorageInfo(row_group_index, {col_idx}, result);
+		col_data.GetColumnSegmentInfo(row_group_index, {col_idx}, result);
 	}
 }
 

package/src/duckdb/src/storage/table/row_group_collection.cpp

@@ -9,6 +9,7 @@
 #include "duckdb/storage/meta_block_reader.hpp"
 #include "duckdb/storage/table/append_state.hpp"
 #include "duckdb/storage/table/scan_state.hpp"
+#include "duckdb/storage/table_storage_info.hpp"
 
 namespace duckdb {
 
@@ -622,12 +623,14 @@ void RowGroupCollection::CommitDropTable() {
 }
 
 //===--------------------------------------------------------------------===//
-// GetStorageInfo
+// GetColumnSegmentInfo
 //===--------------------------------------------------------------------===//
-void RowGroupCollection::GetStorageInfo(TableStorageInfo &result) {
+vector<ColumnSegmentInfo> RowGroupCollection::GetColumnSegmentInfo() {
+	vector<ColumnSegmentInfo> result;
 	for (auto &row_group : row_groups->Segments()) {
-		row_group.GetStorageInfo(row_group.index, result);
+		row_group.GetColumnSegmentInfo(row_group.index, result);
 	}
+	return result;
 }
 
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/storage/table/standard_column_data.cpp

@@ -207,10 +207,11 @@ void StandardColumnData::DeserializeColumn(Deserializer &source) {
 	validity.DeserializeColumn(source);
 }
 
-void StandardColumnData::GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, TableStorageInfo &result) {
-	ColumnData::GetStorageInfo(row_group_index, col_path, result);
+void StandardColumnData::GetColumnSegmentInfo(duckdb::idx_t row_group_index, vector<duckdb::idx_t> col_path,
+                                              vector<duckdb::ColumnSegmentInfo> &result) {
+	ColumnData::GetColumnSegmentInfo(row_group_index, col_path, result);
 	col_path.push_back(0);
-	validity.GetStorageInfo(row_group_index, std::move(col_path), result);
+	validity.GetColumnSegmentInfo(row_group_index, std::move(col_path), result);
 }
 
 void StandardColumnData::Verify(RowGroup &parent) {

package/src/duckdb/src/storage/table/struct_column_data.cpp

@@ -273,12 +273,13 @@ void StructColumnData::DeserializeColumn(Deserializer &source) {
 	this->count = validity.count;
 }
 
-void StructColumnData::GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, TableStorageInfo &result) {
+void StructColumnData::GetColumnSegmentInfo(duckdb::idx_t row_group_index, vector<duckdb::idx_t> col_path,
+                                            vector<duckdb::ColumnSegmentInfo> &result) {
 	col_path.push_back(0);
-	validity.GetStorageInfo(row_group_index, col_path, result);
+	validity.GetColumnSegmentInfo(row_group_index, col_path, result);
 	for (idx_t i = 0; i < sub_columns.size(); i++) {
 		col_path.back() = i + 1;
-		sub_columns[i]->GetStorageInfo(row_group_index, col_path, result);
+		sub_columns[i]->GetColumnSegmentInfo(row_group_index, col_path, result);
 	}
 }
 

package/src/duckdb/src/storage/wal_replay.cpp

@@ -195,15 +195,16 @@ void ReplayState::ReplayEntry(WALType entry_type) {
 // Replay Table
 //===--------------------------------------------------------------------===//
 void ReplayState::ReplayCreateTable() {
-
 	auto info = TableCatalogEntry::Deserialize(source, context);
 	if (deserialize_only) {
 		return;
 	}
 
 	// bind the constraints to the table again
+
 	auto binder = Binder::CreateBinder(context);
-	auto bound_info = binder->BindCreateTableInfo(std::move(info));
+	auto &schema = catalog.GetSchema(context, info->schema);
+	auto bound_info = binder->BindCreateTableInfo(std::move(info), schema);
 
 	catalog.CreateTable(context, *bound_info);
 }
@@ -282,9 +283,7 @@ void ReplayState::ReplayDropSchema() {
 //===--------------------------------------------------------------------===//
 void ReplayState::ReplayCreateType() {
 	auto info = TypeCatalogEntry::Deserialize(source);
-	if (Catalog::TypeExists(context, info->catalog, info->schema, info->name)) {
-		return;
-	}
+	info->on_conflict = OnCreateConflict::IGNORE_ON_CONFLICT;
 	catalog.CreateType(context, *info);
 }
 

package/src/duckdb/third_party/libpg_query/include/nodes/nodes.hpp

@@ -426,7 +426,6 @@ typedef enum PGNodeTag {
 	T_PGImportStmt,
 	T_PGAttachStmt,
 	T_PGDetachStmt,
-	T_PGCreateDatabaseStmt,
 	T_PGUseStmt,
 
 	/*

package/src/duckdb/third_party/libpg_query/include/nodes/parsenodes.hpp

@@ -2119,20 +2119,6 @@ typedef struct PGDetachStmt
 	bool missing_ok;
 } PGDetachStmt;
 
-
-
-/* ----------------------
- *		CREATE DATABASE Statement
- * ----------------------
- */
-typedef struct PGCreateDatabaseStmt
-{
-	PGNodeTag	type;
-	PGRangeVar *name;			/* The name of the created database */
-	char *extension;			/* The name of the extension which will create the database */
-	char *path;					/* The file path of the to-be-created database */
-} PGCreateDatabaseStmt;
-
 /* ----------------------
  *		Use Statement
  * ----------------------