duckdb 0.8.1-dev287.0 → 0.8.1-dev327.0

package/src/duckdb/src/execution/operator/schema/physical_create_index.cpp

@@ -7,6 +7,8 @@
 #include "duckdb/storage/storage_manager.hpp"
 #include "duckdb/main/database_manager.hpp"
 #include "duckdb/execution/index/art/art_key.hpp"
+#include "duckdb/execution/index/art/node.hpp"
+#include "duckdb/execution/index/art/leaf.hpp"
 
 namespace duckdb {
 
@@ -106,6 +108,28 @@ SinkResultType PhysicalCreateIndex::Sink(ExecutionContext &context, DataChunk &c
 	if (!lstate.local_index->MergeIndexes(*art)) {
 		throw ConstraintException("Data contains duplicates on indexed column(s)");
 	}
+
+#ifdef DEBUG
+	// ensure that all row IDs of this chunk exist in the ART
+	auto row_ids = FlatVector::GetData<row_t>(row_identifiers);
+	for (idx_t i = 0; i < lstate.key_chunk.size(); i++) {
+		auto leaf_node =
+		    lstate.local_index->Cast<ART>().Lookup(*lstate.local_index->Cast<ART>().tree, lstate.keys[i], 0);
+		D_ASSERT(leaf_node.IsSet());
+		auto &leaf = Leaf::Get(lstate.local_index->Cast<ART>(), leaf_node);
+
+		if (leaf.IsInlined()) {
+			D_ASSERT(row_ids[i] == leaf.row_ids.inlined);
+			continue;
+		}
+
+		D_ASSERT(leaf.row_ids.ptr.IsSet());
+		Node leaf_segment = leaf.row_ids.ptr;
+		auto position = leaf.FindRowId(lstate.local_index->Cast<ART>(), leaf_segment, row_ids[i]);
+		D_ASSERT(position != (uint32_t)DConstants::INVALID_INDEX);
+	}
+#endif
+
 	return SinkResultType::NEED_MORE_INPUT;
 }
 
@@ -119,6 +143,9 @@ void PhysicalCreateIndex::Combine(ExecutionContext &context, GlobalSinkState &gs
 	if (!gstate.global_index->MergeIndexes(*lstate.local_index)) {
 		throw ConstraintException("Data contains duplicates on indexed column(s)");
 	}
+
+	// vacuum excess memory
+	gstate.global_index->Vacuum();
 }
 
 SinkFinalizeType PhysicalCreateIndex::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
@@ -127,6 +154,8 @@ SinkFinalizeType PhysicalCreateIndex::Finalize(Pipeline &pipeline, Event &event,
 	// here, we just set the resulting global index as the newly created index of the table
 
 	auto &state = gstate_p.Cast<CreateIndexGlobalSinkState>();
+	D_ASSERT(!state.global_index->VerifyAndToString(true).empty());
+
 	auto &storage = table.GetStorage();
 	if (!storage.IsRoot()) {
 		throw TransactionException("Transaction conflict: cannot add an index to a table that has been altered!");
@@ -147,9 +176,6 @@ SinkFinalizeType PhysicalCreateIndex::Finalize(Pipeline &pipeline, Event &event,
 		index.parsed_expressions.push_back(parsed_expr->Copy());
 	}
 
-	// vacuum excess memory
-	state.global_index->Vacuum();
-
 	// add index to storage
 	storage.info->indexes.AddIndex(std::move(state.global_index));
 	return SinkFinalizeType::READY;

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

@@ -1112,6 +1112,7 @@ void BufferedCSVReaderOptions::Deserialize(FieldReader &reader) {
 
 static void CSVReaderSerialize(FieldWriter &writer, const FunctionData *bind_data_p, const TableFunction &function) {
 	auto &bind_data = bind_data_p->Cast<ReadCSVData>();
+	writer.WriteString(function.extra_info);
 	writer.WriteList<string>(bind_data.files);
 	writer.WriteRegularSerializableList<LogicalType>(bind_data.csv_types);
 	writer.WriteList<string>(bind_data.csv_names);
@@ -1130,6 +1131,7 @@ static void CSVReaderSerialize(FieldWriter &writer, const FunctionData *bind_dat
 
 static unique_ptr<FunctionData> CSVReaderDeserialize(ClientContext &context, FieldReader &reader,
                                                      TableFunction &function) {
+	function.extra_info = reader.ReadRequired<string>();
 	auto result_data = make_uniq<ReadCSVData>();
 	result_data->files = reader.ReadRequiredList<string>();
 	result_data->csv_types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();

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

@@ -23,6 +23,9 @@ 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());
+	if (inputs[1].IsNull()) {
+		throw BinderException("Repeat second parameter cannot be NULL");
+	}
 	return make_uniq<RepeatFunctionData>(inputs[0], inputs[1].GetValue<int64_t>());
 }
 

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

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.8.1-dev287"
+#define DUCKDB_VERSION "0.8.1-dev327"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "8c32403411"
+#define DUCKDB_SOURCE_ID "57912b60a6"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/include/duckdb/common/types/timestamp.hpp

@@ -59,22 +59,12 @@ struct timestamp_t { // NOLINT
 	};
 
 	// arithmetic operators
-	inline timestamp_t operator+(const double &value) const {
-		return timestamp_t(this->value + int64_t(value));
-	};
-	inline int64_t operator-(const timestamp_t &other) const {
-		return this->value - other.value;
-	};
+	timestamp_t operator+(const double &value) const;
+	int64_t operator-(const timestamp_t &other) const;
 
 	// in-place operators
-	inline timestamp_t &operator+=(const int64_t &value) {
-		this->value += value;
-		return *this;
-	};
-	inline timestamp_t &operator-=(const int64_t &value) {
-		this->value -= value;
-		return *this;
-	};
+	timestamp_t &operator+=(const int64_t &delta);
+	timestamp_t &operator-=(const int64_t &delta);
 
 	// special values
 	static timestamp_t infinity() { // NOLINT

package/src/duckdb/src/include/duckdb/execution/index/art/art.hpp

@@ -97,8 +97,11 @@ public:
 	//! Performs constraint checking for a chunk of input data
 	void CheckConstraintsForChunk(DataChunk &input, ConflictManager &conflict_manager) override;
 
-	//! Returns the string representation of the ART
-	string ToString() override;
+	//! Returns the string representation of the ART, or only traverses and verifies the index
+	string VerifyAndToString(IndexLock &state, const bool only_verify) override;
+
+	//! Find the node with a matching key, or return nullptr if not found
+	Node Lookup(Node node, const ARTKey &key, idx_t depth);
 
 private:
 	//! Insert a row ID into a leaf
@@ -107,8 +110,7 @@ private:
 	bool Insert(Node &node, const ARTKey &key, idx_t depth, const row_t &row_id);
 	//! Erase a key from the tree (if a leaf has more than one value) or erase the leaf itself
 	void Erase(Node &node, const ARTKey &key, idx_t depth, const row_t &row_id);
-	//! Find the node with a matching key, or return nullptr if not found
-	Node Lookup(Node node, const ARTKey &key, idx_t depth);
+
 	//! Returns all row IDs belonging to a key greater (or equal) than the search key
 	bool SearchGreater(ARTIndexScanState &state, ARTKey &key, bool inclusive, idx_t max_count,
 	                   vector<row_t> &result_ids);
@@ -129,6 +131,10 @@ private:
 	//! Finalizes a vacuum operation by calling the finalize operation of all qualifying
 	//! fixed size allocators
 	void FinalizeVacuum(const ARTFlags &flags);
+
+	//! Internal function to return the string representation of the ART,
+	//! or only traverses and verifies the index
+	string VerifyAndToStringInternal(const bool only_verify);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/index/art/fixed_size_allocator.hpp

@@ -100,6 +100,9 @@ public:
 	//! Vacuums a pointer
 	SwizzleablePointer VacuumPointer(const SwizzleablePointer ptr);
 
+	//! Verify that the allocation counts match the existing positions on the buffers
+	void Verify() const;
+
 private:
 	//! Returns the data_ptr_t of a pointer
 	inline data_ptr_t Get(const SwizzleablePointer ptr) const {

package/src/duckdb/src/include/duckdb/execution/index/art/leaf.hpp

@@ -73,7 +73,7 @@ public:
 	uint32_t FindRowId(const ART &art, Node &ptr, const row_t row_id) const;
 
 	//! Returns the string representation of a leaf
-	string ToString(const ART &art) const;
+	string VerifyAndToString(const ART &art, const bool only_verify) const;
 
 	//! Serialize this leaf
 	BlockPointer Serialize(const ART &art, MetaBlockWriter &writer) const;

package/src/duckdb/src/include/duckdb/execution/index/art/leaf_segment.hpp

@@ -26,6 +26,8 @@ public:
 	static inline LeafSegment &Get(const ART &art, const Node ptr) {
 		return *Node::GetAllocator(art, NType::LEAF_SEGMENT).Get<LeafSegment>(ptr);
 	}
+	//! Free the leaf segment and any subsequent ones
+	static void Free(ART &art, Node &node);
 
 	//! Append a row ID to the current segment, or create a new segment containing that row ID
 	LeafSegment &Append(ART &art, uint32_t &count, const row_t row_id);

package/src/duckdb/src/include/duckdb/execution/index/art/node.hpp

@@ -65,13 +65,23 @@ public:
 	//! Free the node (and its subtree)
 	static void Free(ART &art, Node &node);
 
+	inline bool operator==(const Node &node) const {
+		return swizzle_flag == node.swizzle_flag && type == node.type && offset == node.offset &&
+		       buffer_id == node.buffer_id;
+	}
+
 	//! Retrieve the node type from the leftmost byte
 	inline NType DecodeARTNodeType() const {
+		D_ASSERT(!IsSwizzled());
+		D_ASSERT(type >= (uint8_t)NType::PREFIX_SEGMENT);
+		D_ASSERT(type <= (uint8_t)NType::NODE_256);
 		return NType(type);
 	}
 
 	//! Set the pointer
 	inline void SetPtr(const SwizzleablePointer ptr) {
+		swizzle_flag = ptr.swizzle_flag;
+		type = ptr.type;
 		offset = ptr.offset;
 		buffer_id = ptr.buffer_id;
 	}
@@ -86,15 +96,15 @@ public:
 	//! Get the child for the respective byte in the node
 	optional_ptr<Node> GetChild(ART &art, const uint8_t byte) const;
 	//! Get the first child that is greater or equal to the specific byte
-	optional_ptr<Node> GetNextChild(ART &art, uint8_t &byte) const;
+	optional_ptr<Node> GetNextChild(ART &art, uint8_t &byte, const bool deserialize = true) const;
 
 	//! Serialize the node
 	BlockPointer Serialize(ART &art, MetaBlockWriter &writer);
 	//! Deserialize the node
 	void Deserialize(ART &art);
 
-	//! Returns the string representation of the node
-	string ToString(ART &art) const;
+	//! Returns the string representation of the node, or only traverses and verifies the node and its subtree
+	string VerifyAndToString(ART &art, const bool only_verify);
 	//! Returns the capacity of the node
 	idx_t GetCapacity() const;
 	//! Returns a pointer to the prefix of the node

package/src/duckdb/src/include/duckdb/execution/index/art/node48.hpp

@@ -59,6 +59,7 @@ public:
 	//! Get the child for the respective byte in the node
 	inline optional_ptr<Node> GetChild(const uint8_t byte) {
 		if (child_index[byte] != Node::EMPTY_MARKER) {
+			D_ASSERT(children[child_index[byte]].IsSet());
 			return &children[child_index[byte]];
 		}
 		return nullptr;

package/src/duckdb/src/include/duckdb/parser/transformer.hpp

@@ -127,8 +127,6 @@ private:
 	unique_ptr<CreateStatement> TransformCreateFunction(duckdb_libpgquery::PGCreateFunctionStmt &stmt);
 	//! Transform a Postgres duckdb_libpgquery::T_PGCreateTypeStmt node into CreateStatement
 	unique_ptr<CreateStatement> TransformCreateType(duckdb_libpgquery::PGCreateTypeStmt &stmt);
-	//! Transform a Postgres duckdb_libpgquery::T_PGCreateDatabaseStmt node into a CreateStatement
-	unique_ptr<CreateStatement> TransformCreateDatabase(duckdb_libpgquery::PGCreateDatabaseStmt &stmt);
 	//! Transform a Postgres duckdb_libpgquery::T_PGAlterSeqStmt node into CreateStatement
 	unique_ptr<AlterStatement> TransformAlterSequence(duckdb_libpgquery::PGAlterSeqStmt &stmt);
 	//! Transform a Postgres duckdb_libpgquery::T_PGDropStmt node into a Drop[Table,Schema]Statement

package/src/duckdb/src/include/duckdb/storage/compression/chimp/algorithm/byte_reader.hpp

@@ -45,6 +45,7 @@ public:
 	inline T ReadValue(uint8_t bytes, uint8_t trailing_zero) {
 		T result = 0;
 		switch (bytes) {
+			// LCOV_EXCL_START
 		case 1:
 			result = Load<uint8_t>(buffer + index);
 			index++;
@@ -73,6 +74,7 @@ public:
 			memcpy(&result, (void *)(buffer + index), 7);
 			index += 7;
 			return result;
+			// LCOV_EXCL_STOP
 		default:
 			if (trailing_zero < 8) {
 				result = Load<T>(buffer + index);
@@ -93,6 +95,7 @@ inline uint32_t ByteReader::ReadValue(uint8_t bytes, uint8_t trailing_zero) {
 	uint32_t result = 0;
 	switch (bytes) {
 	case 0:
+		// LCOV_EXCL_START
 		if (trailing_zero < 8) {
 			result = Load<uint32_t>(buffer + index);
 			index += sizeof(uint32_t);
@@ -115,6 +118,7 @@ inline uint32_t ByteReader::ReadValue(uint8_t bytes, uint8_t trailing_zero) {
 		result = Load<uint32_t>(buffer + index);
 		index += 4;
 		return result;
+		// LCOV_EXCL_STOP
 	default:
 		throw InternalException("Write of %llu bytes attempted into address pointing to 4 byte value", bytes);
 	}

package/src/duckdb/src/include/duckdb/storage/in_memory_block_manager.hpp

@@ -21,43 +21,43 @@ public:
 
 	// LCOV_EXCL_START
 	unique_ptr<Block> ConvertBlock(block_id_t block_id, FileBuffer &source_buffer) override {
-		throw InternalException("Cannot perform IO in in-memory database!");
+		throw InternalException("Cannot perform IO in in-memory database - ConvertBlock!");
 	}
 	unique_ptr<Block> CreateBlock(block_id_t block_id, FileBuffer *source_buffer) override {
-		throw InternalException("Cannot perform IO in in-memory database!");
+		throw InternalException("Cannot perform IO in in-memory database - CreateBlock!");
 	}
 	block_id_t GetFreeBlockId() override {
-		throw InternalException("Cannot perform IO in in-memory database!");
+		throw InternalException("Cannot perform IO in in-memory database - GetFreeBlockId!");
 	}
 	bool IsRootBlock(block_id_t root) override {
-		throw InternalException("Cannot perform IO in in-memory database!");
+		throw InternalException("Cannot perform IO in in-memory database - IsRootBlock!");
 	}
 	void MarkBlockAsFree(block_id_t block_id) override {
-		throw InternalException("Cannot perform IO in in-memory database!");
+		throw InternalException("Cannot perform IO in in-memory database - MarkBlockAsFree!");
 	}
 	void MarkBlockAsModified(block_id_t block_id) override {
-		throw InternalException("Cannot perform IO in in-memory database!");
+		throw InternalException("Cannot perform IO in in-memory database - MarkBlockAsModified!");
 	}
 	void IncreaseBlockReferenceCount(block_id_t block_id) override {
-		throw InternalException("Cannot perform IO in in-memory database!");
+		throw InternalException("Cannot perform IO in in-memory database - IncreaseBlockReferenceCount!");
 	}
 	block_id_t GetMetaBlock() override {
-		throw InternalException("Cannot perform IO in in-memory database!");
+		throw InternalException("Cannot perform IO in in-memory database - GetMetaBlock!");
 	}
 	void Read(Block &block) override {
-		throw InternalException("Cannot perform IO in in-memory database!");
+		throw InternalException("Cannot perform IO in in-memory database - Read!");
 	}
 	void Write(FileBuffer &block, block_id_t block_id) override {
-		throw InternalException("Cannot perform IO in in-memory database!");
+		throw InternalException("Cannot perform IO in in-memory database - Write!");
 	}
 	void WriteHeader(DatabaseHeader header) override {
-		throw InternalException("Cannot perform IO in in-memory database!");
+		throw InternalException("Cannot perform IO in in-memory database - WriteHeader!");
 	}
 	idx_t TotalBlocks() override {
-		throw InternalException("Cannot perform IO in in-memory database!");
+		throw InternalException("Cannot perform IO in in-memory database - TotalBlocks!");
 	}
 	idx_t FreeBlocks() override {
-		throw InternalException("Cannot perform IO in in-memory database!");
+		throw InternalException("Cannot perform IO in in-memory database - FreeBlocks!");
 	}
 	// LCOV_EXCL_STOP
 };

package/src/duckdb/src/include/duckdb/storage/index.hpp

@@ -104,8 +104,10 @@ public:
 	//! Obtains a lock and calls Vacuum while holding that lock
 	void Vacuum();
 
-	//! Returns the string representation of an index
-	virtual string ToString() = 0;
+	//! Returns the string representation of an index, or only traverses and verifies the index
+	virtual string VerifyAndToString(IndexLock &state, const bool only_verify) = 0;
+	//! Obtains a lock and calls VerifyAndToString while holding that lock
+	string VerifyAndToString(const bool only_verify);
 
 	//! Returns true if the index is affected by updates on the specified column IDs, and false otherwise
 	bool IndexIsUpdated(const vector<PhysicalIndex> &column_ids) const;

package/src/duckdb/src/include/duckdb/storage/storage_extension.hpp

@@ -28,17 +28,11 @@ typedef unique_ptr<Catalog> (*attach_function_t)(StorageExtensionInfo *storage_i
                                                  const string &name, AttachInfo &info, AccessMode access_mode);
 typedef unique_ptr<TransactionManager> (*create_transaction_manager_t)(StorageExtensionInfo *storage_info,
                                                                        AttachedDatabase &db, Catalog &catalog);
-typedef unique_ptr<TableFunctionRef> (*create_database_t)(StorageExtensionInfo *info, ClientContext &context,
-                                                          const string &database_name, const string &source_path);
-typedef unique_ptr<TableFunctionRef> (*drop_database_t)(StorageExtensionInfo *storage_info, ClientContext &context,
-                                                        const string &database_name);
 
 class StorageExtension {
 public:
 	attach_function_t attach;
 	create_transaction_manager_t create_transaction_manager;
-	create_database_t create_database;
-	drop_database_t drop_database;
 
 	//! Additional info passed to the various storage functions
 	shared_ptr<StorageExtensionInfo> storage_info;

package/src/duckdb/src/parser/parsed_data/create_info.cpp

@@ -5,7 +5,6 @@
 #include "duckdb/parser/parsed_data/create_table_info.hpp"
 #include "duckdb/parser/parsed_data/create_view_info.hpp"
 #include "duckdb/parser/parsed_data/create_sequence_info.hpp"
-#include "duckdb/parser/parsed_data/create_database_info.hpp"
 #include "duckdb/parser/parsed_data/create_type_info.hpp"
 #include "duckdb/parser/parsed_data/alter_info.hpp"
 #include "duckdb/parser/parsed_data/create_macro_info.hpp"
@@ -43,8 +42,6 @@ unique_ptr<CreateInfo> CreateInfo::Deserialize(Deserializer &deserializer) {
 		return CreateSchemaInfo::Deserialize(deserializer);
 	case CatalogType::VIEW_ENTRY:
 		return CreateViewInfo::Deserialize(deserializer);
-	case CatalogType::DATABASE_ENTRY:
-		return CreateDatabaseInfo::Deserialize(deserializer);
 	case CatalogType::TYPE_ENTRY:
 		return CreateTypeInfo::Deserialize(deserializer);
 	case CatalogType::MACRO_ENTRY:

package/src/duckdb/src/parser/transform/helpers/nodetype_to_string.cpp

@@ -816,8 +816,6 @@ std::string Transformer::NodetypeToString(duckdb_libpgquery::PGNodeTag type) { /
 		return "T_PGAttachStmt";
 	case duckdb_libpgquery::T_PGUseStmt:
 		return "T_PGUseStmt";
-	case duckdb_libpgquery::T_PGCreateDatabaseStmt:
-		return "T_PGCreateDatabaseStmt";
 	default:
 		return "(UNKNOWN)";
 	}

package/src/duckdb/src/parser/transform/statement/transform_drop.cpp

@@ -34,9 +34,6 @@ unique_ptr<SQLStatement> Transformer::TransformDrop(duckdb_libpgquery::PGDropStm
 	case duckdb_libpgquery::PG_OBJECT_TYPE:
 		info.type = CatalogType::TYPE_ENTRY;
 		break;
-	case duckdb_libpgquery::PG_OBJECT_DATABASE:
-		info.type = CatalogType::DATABASE_ENTRY;
-		break;
 	default:
 		throw NotImplementedException("Cannot drop this type yet");
 	}

package/src/duckdb/src/parser/transformer.cpp

@@ -204,8 +204,6 @@ unique_ptr<SQLStatement> Transformer::TransformStatementInternal(duckdb_libpgque
 		return TransformDetach(PGCast<duckdb_libpgquery::PGDetachStmt>(stmt));
 	case duckdb_libpgquery::T_PGUseStmt:
 		return TransformUse(PGCast<duckdb_libpgquery::PGUseStmt>(stmt));
-	case duckdb_libpgquery::T_PGCreateDatabaseStmt:
-		return TransformCreateDatabase(PGCast<duckdb_libpgquery::PGCreateDatabaseStmt>(stmt));
 	default:
 		throw NotImplementedException(NodetypeToString(stmt.type));
 	}

package/src/duckdb/src/planner/binder/statement/bind_create.cpp

@@ -13,7 +13,6 @@
 #include "duckdb/parser/parsed_data/create_index_info.hpp"
 #include "duckdb/parser/parsed_data/create_macro_info.hpp"
 #include "duckdb/parser/parsed_data/create_view_info.hpp"
-#include "duckdb/parser/parsed_data/create_database_info.hpp"
 #include "duckdb/parser/tableref/table_function_ref.hpp"
 #include "duckdb/parser/parsed_expression_iterator.hpp"
 #include "duckdb/parser/statement/create_statement.hpp"
@@ -656,32 +655,6 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 		}
 		break;
 	}
-	case CatalogType::DATABASE_ENTRY: {
-		// not supported in DuckDB yet but allow extensions to intercept and implement this functionality
-		auto &base = stmt.info->Cast<CreateDatabaseInfo>();
-		string database_name = base.name;
-		string source_path = base.path;
-
-		auto &config = DBConfig::GetConfig(context);
-
-		if (config.storage_extensions.empty()) {
-			throw NotImplementedException("CREATE DATABASE not supported in DuckDB yet");
-		}
-		// for now assume only one storage extension provides the custom create_database impl
-		for (auto &extension_entry : config.storage_extensions) {
-			if (extension_entry.second->create_database != nullptr) {
-				auto &storage_extension = extension_entry.second;
-				auto create_database_function_ref = storage_extension->create_database(
-				    storage_extension->storage_info.get(), context, database_name, source_path);
-				if (create_database_function_ref) {
-					auto bound_create_database_func = Bind(*create_database_function_ref);
-					result.plan = CreatePlan(*bound_create_database_func);
-					break;
-				}
-			}
-		}
-		break;
-	}
 	default:
 		throw Exception("Unrecognized type!");
 	}

package/src/duckdb/src/planner/binder/statement/bind_drop.cpp

@@ -47,31 +47,6 @@ BoundStatement Binder::Bind(DropStatement &stmt) {
 		stmt.info->schema = entry->ParentSchema().name;
 		break;
 	}
-	case CatalogType::DATABASE_ENTRY: {
-		auto &base = (DropInfo &)*stmt.info;
-		string database_name = base.name;
-
-		auto &config = DBConfig::GetConfig(context);
-		// for now assume only one storage extension provides the custom drop_database impl
-		for (auto &extension_entry : config.storage_extensions) {
-			if (extension_entry.second->drop_database == nullptr) {
-				continue;
-			}
-			auto &storage_extension = extension_entry.second;
-			auto drop_database_function_ref =
-			    storage_extension->drop_database(storage_extension->storage_info.get(), context, database_name);
-			if (drop_database_function_ref) {
-				auto bound_drop_database_func = Bind(*drop_database_function_ref);
-				result.plan = CreatePlan(*bound_drop_database_func);
-				result.names = {"Success"};
-				result.types = {LogicalType::BIGINT};
-				properties.allow_stream_result = false;
-				properties.return_type = StatementReturnType::NOTHING;
-				return result;
-			}
-		}
-		throw BinderException("Drop is not supported for this database!");
-	}
 	default:
 		throw BinderException("Unknown catalog type for drop statement!");
 	}

package/src/duckdb/src/planner/operator/logical_pivot.cpp

@@ -19,11 +19,23 @@ vector<ColumnBinding> LogicalPivot::GetColumnBindings() {
 }
 
 void LogicalPivot::Serialize(FieldWriter &writer) const {
-	throw NotImplementedException("Serializing pivot is not supported yet");
+	writer.WriteField(pivot_index);
+	writer.WriteOptional<LogicalOperator>(children.back());
+	writer.WriteField(bound_pivot.group_count);
+	writer.WriteRegularSerializableList<LogicalType>(bound_pivot.types);
+	writer.WriteList<string>(bound_pivot.pivot_values);
+	writer.WriteSerializableList<Expression>(bound_pivot.aggregates);
 }
 
 unique_ptr<LogicalOperator> LogicalPivot::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	throw NotImplementedException("Deserializing pivot is not supported yet");
+	auto pivot_index = reader.ReadRequired<idx_t>();
+	auto plan = reader.ReadOptional<LogicalOperator>(nullptr, state.gstate);
+	BoundPivotInfo info;
+	info.group_count = reader.ReadRequired<idx_t>();
+	info.types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
+	info.pivot_values = reader.ReadRequiredList<string>();
+	info.aggregates = reader.ReadRequiredSerializableList<Expression>(state.gstate);
+	return make_uniq<LogicalPivot>(pivot_index, std::move(plan), std::move(info));
 }
 
 vector<idx_t> LogicalPivot::GetTableIndex() const {

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/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
  * ----------------------