duckdb 0.8.2-dev5154.0 → 0.8.2-dev5216.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.8.2-dev5154.0",
+  "version": "0.8.2-dev5216.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb/extension/json/buffered_json_reader.cpp

@@ -23,7 +23,7 @@ bool JSONFileHandle::IsOpen() const {
 }
 
 void JSONFileHandle::Close() {
-	if (IsOpen() && plain_file_source) {
+	if (IsOpen() && file_handle->OnDiskFile()) {
 		file_handle->Close();
 		file_handle = nullptr;
 	}
@@ -34,7 +34,7 @@ void JSONFileHandle::Reset() {
 	read_position = 0;
 	requested_reads = 0;
 	actual_reads = 0;
-	if (IsOpen() && plain_file_source) {
+	if (IsOpen() && CanSeek()) {
 		file_handle->Reset();
 	}
 }

package/src/duckdb/src/catalog/catalog.cpp

@@ -432,7 +432,8 @@ void FindMinimalQualification(ClientContext &context, const string &catalog_name
 	qualify_schema = true;
 }
 
-bool Catalog::TryAutoLoad(ClientContext &context, const string &extension_name) noexcept {
+bool Catalog::TryAutoLoad(ClientContext &context, const string &original_name) noexcept {
+	string extension_name = ExtensionHelper::ApplyExtensionAlias(original_name);
 	if (context.db->ExtensionIsLoaded(extension_name)) {
 		return true;
 	}

package/src/duckdb/src/execution/operator/csv_scanner/parallel_csv_reader.cpp

@@ -333,9 +333,23 @@ normal : {
 	for (; position_buffer < end_buffer; position_buffer++) {
 		auto c = (*buffer)[position_buffer];
 		if (c == options.dialect_options.state_machine_options.delimiter) {
+			// Check if previous character is a quote, if yes, this means we are in a non-initialized quoted value
+			// This only matters for when trying to figure out where csv lines start
+			if (position_buffer > 0 && try_add_line) {
+				if ((*buffer)[position_buffer - 1] == options.dialect_options.state_machine_options.quote) {
+					return false;
+				}
+			}
 			// delimiter: end the value and add it to the chunk
 			goto add_value;
 		} else if (StringUtil::CharacterIsNewline(c)) {
+			// Check if previous character is a quote, if yes, this means we are in a non-initialized quoted value
+			// This only matters for when trying to figure out where csv lines start
+			if (position_buffer > 0 && try_add_line) {
+				if ((*buffer)[position_buffer - 1] == options.dialect_options.state_machine_options.quote) {
+					return false;
+				}
+			}
 			// newline: add row
 			if (column > 0 || try_add_line || parse_chunk.data.size() == 1) {
 				goto add_row;

package/src/duckdb/src/execution/operator/csv_scanner/sniffer/type_detection.cpp

@@ -290,37 +290,37 @@ void CSVSniffer::DetectTypes() {
 		vector<TupleSniffing> tuples(STANDARD_VECTOR_SIZE);
 		candidate->csv_buffer_iterator.Process<SniffValue>(*candidate, tuples);
 		// Potentially Skip empty rows (I find this dirty, but it is what the original code does)
-		idx_t true_start = 0;
+		// The true line where parsing starts in reference to the csv file
+		idx_t true_line_start = 0;
 		idx_t true_pos = 0;
-		idx_t values_start = 0;
-		while (true_start < tuples.size()) {
-			if (tuples[true_start].values.empty() ||
-			    (tuples[true_start].values.size() == 1 && tuples[true_start].values[0].IsNull())) {
-				true_start = tuples[true_start].line_number;
-				if (true_start < tuples.size()) {
-					true_pos = tuples[true_start].position;
-				}
-				values_start++;
+		// The start point of the tuples
+		idx_t tuple_true_start = 0;
+		while (tuple_true_start < tuples.size()) {
+			if (tuples[tuple_true_start].values.empty() ||
+			    (tuples[tuple_true_start].values.size() == 1 && tuples[tuple_true_start].values[0].IsNull())) {
+				true_line_start = tuples[tuple_true_start].line_number;
+				true_pos = tuples[tuple_true_start].position;
+				tuple_true_start++;
 			} else {
 				break;
 			}
 		}
 
 		// Potentially Skip Notes (I also find this dirty, but it is what the original code does)
-		while (true_start < tuples.size()) {
-			if (tuples[true_start].values.size() < max_columns_found && !options.null_padding) {
-
-				true_start = tuples[true_start].line_number;
-				if (true_start < tuples.size()) {
-					true_pos = tuples[true_start].position;
-				}
-				values_start++;
+		while (tuple_true_start < tuples.size()) {
+			if (tuples[tuple_true_start].values.size() < max_columns_found && !options.null_padding) {
+				true_line_start = tuples[tuple_true_start].line_number;
+				true_pos = tuples[tuple_true_start].position;
+				tuple_true_start++;
 			} else {
 				break;
 			}
 		}
-		if (values_start > 0) {
-			tuples.erase(tuples.begin(), tuples.begin() + values_start);
+		if (tuple_true_start < tuples.size()) {
+			true_pos = tuples[tuple_true_start].position;
+		}
+		if (tuple_true_start > 0) {
+			tuples.erase(tuples.begin(), tuples.begin() + tuple_true_start);
 		}
 
 		idx_t row_idx = 0;
@@ -390,9 +390,9 @@ void CSVSniffer::DetectTypes() {
 		// it's good if the dialect creates more non-varchar columns, but only if we sacrifice < 30% of best_num_cols.
 		if (varchar_cols < min_varchar_cols && info_sql_types_candidates.size() > (max_columns_found * 0.7)) {
 			// we have a new best_options candidate
-			if (true_start > 0) {
+			if (true_line_start > 0) {
 				// Add empty rows to skip_rows
-				candidate->dialect_options.skip_rows += true_start;
+				candidate->dialect_options.skip_rows += true_line_start;
 			}
 			best_candidate = std::move(candidate);
 			min_varchar_cols = varchar_cols;

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

@@ -178,7 +178,8 @@ public:
 		current_file_path = files_path_p[0];
 		CSVFileHandle *file_handle_ptr;
 
-		if (!buffer_manager || (options.skip_rows_set && options.dialect_options.skip_rows > 0)) {
+		if (!buffer_manager || (options.skip_rows_set && options.dialect_options.skip_rows > 0) ||
+		    buffer_manager->file_handle->GetFilePath() != current_file_path) {
 			// If our buffers are too small, and we skip too many rows there is a chance things will go over-buffer
 			// for now don't reuse the buffer manager
 			buffer_manager.reset();
@@ -210,6 +211,7 @@ public:
 			line_info.lines_read[0][0]++;
 		}
 		first_position = options.dialect_options.true_start;
+		next_byte = options.dialect_options.true_start;
 	}
 	explicit ParallelCSVGlobalState(idx_t system_threads_p)
 	    : system_threads(system_threads_p), line_info(main_mutex, batch_to_tuple_end, tuple_start, tuple_end) {

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

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.8.2-dev5154"
+#define DUCKDB_VERSION "0.8.2-dev5216"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "78bea4f92a"
+#define DUCKDB_SOURCE_ID "7ffdb9fd0e"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/include/duckdb/main/extension_entries.hpp

@@ -117,8 +117,10 @@ static constexpr ExtensionEntry EXTENSION_FUNCTIONS[] = {
     {"st_dwithin", "spatial"},
     {"st_dwithin_spheroid", "spatial"},
     {"st_envelope", "spatial"},
+    {"st_envelope_agg", "spatial"},
     {"st_equals", "spatial"},
     {"st_extent", "spatial"},
+    {"st_exteriorring", "spatial"},
     {"st_flipcoordinates", "spatial"},
     {"st_geometrytype", "spatial"},
     {"st_geomfromgeojson", "spatial"},
@@ -129,6 +131,7 @@ static constexpr ExtensionEntry EXTENSION_FUNCTIONS[] = {
     {"st_intersection", "spatial"},
     {"st_intersection_agg", "spatial"},
     {"st_intersects", "spatial"},
+    {"st_intersects_extent", "spatial"},
     {"st_isclosed", "spatial"},
     {"st_isempty", "spatial"},
     {"st_isring", "spatial"},
@@ -139,8 +142,12 @@ static constexpr ExtensionEntry EXTENSION_FUNCTIONS[] = {
     {"st_linestring2dfromwkb", "spatial"},
     {"st_list_proj_crs", "spatial"},
     {"st_makeline", "spatial"},
+    {"st_ngeometries", "spatial"},
+    {"st_ninteriorrings", "spatial"},
     {"st_normalize", "spatial"},
     {"st_npoints", "spatial"},
+    {"st_numgeometries", "spatial"},
+    {"st_numinteriorrings", "spatial"},
     {"st_numpoints", "spatial"},
     {"st_overlaps", "spatial"},
     {"st_perimeter", "spatial"},
@@ -150,6 +157,7 @@ static constexpr ExtensionEntry EXTENSION_FUNCTIONS[] = {
     {"st_point2dfromwkb", "spatial"},
     {"st_point3d", "spatial"},
     {"st_point4d", "spatial"},
+    {"st_pointn", "spatial"},
     {"st_pointonsurface", "spatial"},
     {"st_polygon2dfromwkb", "spatial"},
     {"st_read", "spatial"},

package/src/duckdb/src/include/duckdb/main/settings.hpp

@@ -508,7 +508,7 @@ struct SchemaSetting {
 struct SearchPathSetting {
 	static constexpr const char *Name = "search_path";
 	static constexpr const char *Description =
-	    "Sets the default search search path as a comma-separated list of values";
+	    "Sets the default catalog search path as a comma-separated list of values";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
 	static void SetLocal(ClientContext &context, const Value &parameter);
 	static void ResetLocal(ClientContext &context);

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

@@ -38,6 +38,7 @@ public:
 	virtual unique_ptr<TableDataWriter> GetTableDataWriter(TableCatalogEntry &table) = 0;
 
 protected:
+	virtual void WriteEntry(CatalogEntry &entry, Serializer &serializer);
 	virtual void WriteSchema(SchemaCatalogEntry &schema, Serializer &serializer);
 	virtual void WriteTable(TableCatalogEntry &table, Serializer &serializer);
 	virtual void WriteView(ViewCatalogEntry &table, Serializer &serializer);
@@ -60,6 +61,7 @@ protected:
 
 protected:
 	virtual void LoadCheckpoint(ClientContext &context, MetadataReader &reader);
+	virtual void ReadEntry(ClientContext &context, Deserializer &deserializer);
 	virtual void ReadSchema(ClientContext &context, Deserializer &deserializer);
 	virtual void ReadTable(ClientContext &context, Deserializer &deserializer);
 	virtual void ReadView(ClientContext &context, Deserializer &deserializer);

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

@@ -491,7 +491,11 @@ BoundStatement Binder::BindReturning(vector<unique_ptr<ParsedExpression>> return
 	projection->AddChild(std::move(child_operator));
 	D_ASSERT(result.types.size() == result.names.size());
 	result.plan = std::move(projection);
-	properties.allow_stream_result = true;
+	// If an insert/delete/update statement returns data, there are sometimes issues with streaming results
+	// where the data modification doesn't take place until the streamed result is exhausted. Once a row is
+	// returned, it should be guaranteed that the row has been inserted.
+	// see https://github.com/duckdb/duckdb/issues/8310
+	properties.allow_stream_result = false;
 	properties.return_type = StatementReturnType::QUERY_RESULT;
 	return result;
 }

package/src/duckdb/src/storage/checkpoint_manager.cpp

@@ -54,6 +54,74 @@ unique_ptr<TableDataWriter> SingleFileCheckpointWriter::GetTableDataWriter(Table
 	return make_uniq<SingleFileTableDataWriter>(*this, table, *table_metadata_writer);
 }
 
+static catalog_entry_vector_t GetCatalogEntries(vector<reference<SchemaCatalogEntry>> &schemas) {
+	catalog_entry_vector_t entries;
+	for (auto &schema_p : schemas) {
+		auto &schema = schema_p.get();
+		entries.push_back(schema);
+		schema.Scan(CatalogType::TYPE_ENTRY, [&](CatalogEntry &entry) {
+			if (entry.internal) {
+				return;
+			}
+			entries.push_back(entry);
+		});
+
+		schema.Scan(CatalogType::SEQUENCE_ENTRY, [&](CatalogEntry &entry) {
+			if (entry.internal) {
+				return;
+			}
+			entries.push_back(entry);
+		});
+
+		catalog_entry_vector_t tables;
+		vector<reference<ViewCatalogEntry>> views;
+		schema.Scan(CatalogType::TABLE_ENTRY, [&](CatalogEntry &entry) {
+			if (entry.internal) {
+				return;
+			}
+			if (entry.type == CatalogType::TABLE_ENTRY) {
+				tables.push_back(entry.Cast<TableCatalogEntry>());
+			} else if (entry.type == CatalogType::VIEW_ENTRY) {
+				views.push_back(entry.Cast<ViewCatalogEntry>());
+			} else {
+				throw NotImplementedException("Catalog type for entries");
+			}
+		});
+		// Reorder tables because of foreign key constraint
+		ReorderTableEntries(tables);
+		for (auto &table : tables) {
+			entries.push_back(table.get());
+		}
+		for (auto &view : views) {
+			entries.push_back(view.get());
+		}
+
+		schema.Scan(CatalogType::SCALAR_FUNCTION_ENTRY, [&](CatalogEntry &entry) {
+			if (entry.internal) {
+				return;
+			}
+			if (entry.type == CatalogType::MACRO_ENTRY) {
+				entries.push_back(entry);
+			}
+		});
+
+		schema.Scan(CatalogType::TABLE_FUNCTION_ENTRY, [&](CatalogEntry &entry) {
+			if (entry.internal) {
+				return;
+			}
+			if (entry.type == CatalogType::TABLE_MACRO_ENTRY) {
+				entries.push_back(entry);
+			}
+		});
+
+		schema.Scan(CatalogType::INDEX_ENTRY, [&](CatalogEntry &entry) {
+			D_ASSERT(!entry.internal);
+			entries.push_back(entry);
+		});
+	}
+	return entries;
+}
+
 void SingleFileCheckpointWriter::CreateCheckpoint() {
 	auto &config = DBConfig::Get(db);
 	auto &storage_manager = db.GetStorageManager().Cast<SingleFileStorageManager>();
@@ -97,11 +165,12 @@ void SingleFileCheckpointWriter::CreateCheckpoint() {
 	        ]
 	    }
 	 */
+	auto catalog_entries = GetCatalogEntries(schemas);
 	BinarySerializer serializer(*metadata_writer);
 	serializer.Begin();
-	serializer.WriteList(100, "schemas", schemas.size(), [&](Serializer::List &list, idx_t i) {
-		auto &schema = schemas[i];
-		list.WriteObject([&](Serializer &obj) { WriteSchema(schema.get(), obj); });
+	serializer.WriteList(100, "catalog_entries", catalog_entries.size(), [&](Serializer::List &list, idx_t i) {
+		auto &entry = catalog_entries[i];
+		list.WriteObject([&](Serializer &obj) { WriteEntry(entry.get(), obj); });
 	});
 	serializer.End();
 
@@ -141,8 +210,8 @@ void SingleFileCheckpointWriter::CreateCheckpoint() {
 void CheckpointReader::LoadCheckpoint(ClientContext &context, MetadataReader &reader) {
 	BinaryDeserializer deserializer(reader);
 	deserializer.Begin();
-	deserializer.ReadList(100, "schemas", [&](Deserializer::List &list, idx_t i) {
-		return list.ReadObject([&](Deserializer &obj) { ReadSchema(context, obj); });
+	deserializer.ReadList(100, "catalog_entries", [&](Deserializer::List &list, idx_t i) {
+		return list.ReadObject([&](Deserializer &obj) { ReadEntry(context, obj); });
 	});
 	deserializer.End();
 }
@@ -169,112 +238,102 @@ void SingleFileCheckpointReader::LoadFromStorage() {
 	con.Commit();
 }
 
+void CheckpointWriter::WriteEntry(CatalogEntry &entry, Serializer &serializer) {
+	serializer.WriteProperty(99, "catalog_type", entry.type);
+
+	switch (entry.type) {
+	case CatalogType::SCHEMA_ENTRY: {
+		auto &schema = entry.Cast<SchemaCatalogEntry>();
+		WriteSchema(schema, serializer);
+		break;
+	}
+	case CatalogType::TYPE_ENTRY: {
+		auto &custom_type = entry.Cast<TypeCatalogEntry>();
+		WriteType(custom_type, serializer);
+		break;
+	}
+	case CatalogType::SEQUENCE_ENTRY: {
+		auto &seq = entry.Cast<SequenceCatalogEntry>();
+		WriteSequence(seq, serializer);
+		break;
+	}
+	case CatalogType::TABLE_ENTRY: {
+		auto &table = entry.Cast<TableCatalogEntry>();
+		WriteTable(table, serializer);
+		break;
+	}
+	case CatalogType::VIEW_ENTRY: {
+		auto &view = entry.Cast<ViewCatalogEntry>();
+		WriteView(view, serializer);
+		break;
+	}
+	case CatalogType::MACRO_ENTRY: {
+		auto &macro = entry.Cast<ScalarMacroCatalogEntry>();
+		WriteMacro(macro, serializer);
+		break;
+	}
+	case CatalogType::TABLE_MACRO_ENTRY: {
+		auto &macro = entry.Cast<TableMacroCatalogEntry>();
+		WriteTableMacro(macro, serializer);
+		break;
+	}
+	case CatalogType::INDEX_ENTRY: {
+		auto &index = entry.Cast<IndexCatalogEntry>();
+		WriteIndex(index, serializer);
+		break;
+	}
+	default:
+		throw InternalException("Unrecognized catalog type in CheckpointWriter::WriteEntry");
+	}
+}
+
 //===--------------------------------------------------------------------===//
 // Schema
 //===--------------------------------------------------------------------===//
 void CheckpointWriter::WriteSchema(SchemaCatalogEntry &schema, Serializer &serializer) {
 	// write the schema data
 	serializer.WriteProperty(100, "schema", &schema);
+}
 
-	// Write the custom types
-	vector<reference<TypeCatalogEntry>> custom_types;
-	schema.Scan(CatalogType::TYPE_ENTRY, [&](CatalogEntry &entry) {
-		if (entry.internal) {
-			return;
-		}
-		custom_types.push_back(entry.Cast<TypeCatalogEntry>());
-	});
-
-	serializer.WriteList(101, "custom_types", custom_types.size(), [&](Serializer::List &list, idx_t i) {
-		auto &entry = custom_types[i];
-		list.WriteObject([&](Serializer &obj) { WriteType(entry, obj); });
-	});
-
-	// Write the sequences
-	vector<reference<SequenceCatalogEntry>> sequences;
-	schema.Scan(CatalogType::SEQUENCE_ENTRY, [&](CatalogEntry &entry) {
-		if (entry.internal) {
-			return;
-		}
-		sequences.push_back(entry.Cast<SequenceCatalogEntry>());
-	});
-
-	serializer.WriteList(102, "sequences", sequences.size(), [&](Serializer::List &list, idx_t i) {
-		auto &entry = sequences[i];
-		list.WriteObject([&](Serializer &obj) { WriteSequence(entry, obj); });
-	});
-
-	// Read the tables and views
-	catalog_entry_vector_t tables;
-	vector<reference<ViewCatalogEntry>> views;
-	schema.Scan(CatalogType::TABLE_ENTRY, [&](CatalogEntry &entry) {
-		if (entry.internal) {
-			return;
-		}
-		if (entry.type == CatalogType::TABLE_ENTRY) {
-			tables.push_back(entry.Cast<TableCatalogEntry>());
-		} else if (entry.type == CatalogType::VIEW_ENTRY) {
-			views.push_back(entry.Cast<ViewCatalogEntry>());
-		} else {
-			throw NotImplementedException("Catalog type for entries");
-		}
-	});
-	// Reorder tables because of foreign key constraint
-	ReorderTableEntries(tables);
-	// Tables
-	serializer.WriteList(103, "tables", tables.size(), [&](Serializer::List &list, idx_t i) {
-		auto &entry = tables[i];
-		auto &table = entry.get().Cast<TableCatalogEntry>();
-		list.WriteObject([&](Serializer &obj) { WriteTable(table, obj); });
-	});
-
-	// Views
-	serializer.WriteList(104, "views", views.size(), [&](Serializer::List &list, idx_t i) {
-		auto &entry = views[i];
-		list.WriteObject([&](Serializer &obj) { WriteView(entry.get(), obj); });
-	});
-
-	// Scalar macros
-	vector<reference<ScalarMacroCatalogEntry>> macros;
-	schema.Scan(CatalogType::SCALAR_FUNCTION_ENTRY, [&](CatalogEntry &entry) {
-		if (entry.internal) {
-			return;
-		}
-		if (entry.type == CatalogType::MACRO_ENTRY) {
-			macros.push_back(entry.Cast<ScalarMacroCatalogEntry>());
-		}
-	});
-	serializer.WriteList(105, "macros", macros.size(), [&](Serializer::List &list, idx_t i) {
-		auto &entry = macros[i];
-		list.WriteObject([&](Serializer &obj) { WriteMacro(entry.get(), obj); });
-	});
-
-	// Table macros
-	vector<reference<TableMacroCatalogEntry>> table_macros;
-	schema.Scan(CatalogType::TABLE_FUNCTION_ENTRY, [&](CatalogEntry &entry) {
-		if (entry.internal) {
-			return;
-		}
-		if (entry.type == CatalogType::TABLE_MACRO_ENTRY) {
-			table_macros.push_back(entry.Cast<TableMacroCatalogEntry>());
-		}
-	});
-	serializer.WriteList(106, "table_macros", table_macros.size(), [&](Serializer::List &list, idx_t i) {
-		auto &entry = table_macros[i];
-		list.WriteObject([&](Serializer &obj) { WriteTableMacro(entry.get(), obj); });
-	});
-
-	// Indexes
-	vector<reference<IndexCatalogEntry>> indexes;
-	schema.Scan(CatalogType::INDEX_ENTRY, [&](CatalogEntry &entry) {
-		D_ASSERT(!entry.internal);
-		indexes.push_back(entry.Cast<IndexCatalogEntry>());
-	});
+void CheckpointReader::ReadEntry(ClientContext &context, Deserializer &deserializer) {
+	auto type = deserializer.ReadProperty<CatalogType>(99, "type");
 
-	serializer.WriteList(107, "indexes", indexes.size(), [&](Serializer::List &list, idx_t i) {
-		auto &entry = indexes[i];
-		list.WriteObject([&](Serializer &obj) { WriteIndex(entry.get(), obj); });
-	});
+	switch (type) {
+	case CatalogType::SCHEMA_ENTRY: {
+		ReadSchema(context, deserializer);
+		break;
+	}
+	case CatalogType::TYPE_ENTRY: {
+		ReadType(context, deserializer);
+		break;
+	}
+	case CatalogType::SEQUENCE_ENTRY: {
+		ReadSequence(context, deserializer);
+		break;
+	}
+	case CatalogType::TABLE_ENTRY: {
+		ReadTable(context, deserializer);
+		break;
+	}
+	case CatalogType::VIEW_ENTRY: {
+		ReadView(context, deserializer);
+		break;
+	}
+	case CatalogType::MACRO_ENTRY: {
+		ReadMacro(context, deserializer);
+		break;
+	}
+	case CatalogType::TABLE_MACRO_ENTRY: {
+		ReadTableMacro(context, deserializer);
+		break;
+	}
+	case CatalogType::INDEX_ENTRY: {
+		ReadIndex(context, deserializer);
+		break;
+	}
+	default:
+		throw InternalException("Unrecognized catalog type in CheckpointWriter::WriteEntry");
+	}
 }
 
 void CheckpointReader::ReadSchema(ClientContext &context, Deserializer &deserializer) {
@@ -285,41 +344,6 @@ void CheckpointReader::ReadSchema(ClientContext &context, Deserializer &deserial
 	// we set create conflict to IGNORE_ON_CONFLICT, so that we can ignore a failure when recreating the main schema
 	schema_info.on_conflict = OnCreateConflict::IGNORE_ON_CONFLICT;
 	catalog.CreateSchema(context, schema_info);
-
-	// Read the custom types
-	deserializer.ReadList(101, "custom_types", [&](Deserializer::List &list, idx_t i) {
-		return list.ReadObject([&](Deserializer &obj) { ReadType(context, obj); });
-	});
-
-	// Read the sequences
-	deserializer.ReadList(102, "sequences", [&](Deserializer::List &list, idx_t i) {
-		return list.ReadObject([&](Deserializer &obj) { ReadSequence(context, obj); });
-	});
-
-	// Read the tables
-	deserializer.ReadList(103, "tables", [&](Deserializer::List &list, idx_t i) {
-		return list.ReadObject([&](Deserializer &obj) { ReadTable(context, obj); });
-	});
-
-	// Read the views
-	deserializer.ReadList(104, "views", [&](Deserializer::List &list, idx_t i) {
-		return list.ReadObject([&](Deserializer &obj) { ReadView(context, obj); });
-	});
-
-	// Read the macros
-	deserializer.ReadList(105, "macros", [&](Deserializer::List &list, idx_t i) {
-		return list.ReadObject([&](Deserializer &obj) { ReadMacro(context, obj); });
-	});
-
-	// Read the table macros
-	deserializer.ReadList(106, "table_macros", [&](Deserializer::List &list, idx_t i) {
-		return list.ReadObject([&](Deserializer &obj) { ReadTableMacro(context, obj); });
-	});
-
-	// Read the indexes
-	deserializer.ReadList(107, "indexes", [&](Deserializer::List &list, idx_t i) {
-		return list.ReadObject([&](Deserializer &obj) { ReadIndex(context, obj); });
-	});
 }
 
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/storage/storage_info.cpp

@@ -2,7 +2,7 @@
 
 namespace duckdb {
 
-const uint64_t VERSION_NUMBER = 61;
+const uint64_t VERSION_NUMBER = 62;
 
 struct StorageVersionInfo {
 	const char *version_name;