duckdb 0.8.2-dev5120.0 → 0.8.2-dev5216.0

package/src/duckdb/extension/icu/icu-timezone.cpp

@@ -2,6 +2,7 @@
 #include "duckdb/common/types/time.hpp"
 #include "duckdb/common/types/timestamp.hpp"
 #include "duckdb/function/cast/cast_function_set.hpp"
+#include "duckdb/main/extension_util.hpp"
 #include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
 #include "duckdb/parser/parsed_data/create_table_function_info.hpp"
 #include "include/icu-datefunc.hpp"
@@ -143,8 +144,8 @@ struct ICUFromNaiveTimestamp : public ICUDateFunc {
 		return BoundCastInfo(CastFromNaive, std::move(cast_data));
 	}
 
-	static void AddCasts(ClientContext &context) {
-		auto &config = DBConfig::GetConfig(context);
+	static void AddCasts(DatabaseInstance &db) {
+		auto &config = DBConfig::GetConfig(db);
 		auto &casts = config.GetCastFunctions();
 
 		casts.RegisterCastFunction(LogicalType::TIMESTAMP, LogicalType::TIMESTAMP_TZ, BindCastFromNaive);
@@ -206,8 +207,8 @@ struct ICUToNaiveTimestamp : public ICUDateFunc {
 		return BoundCastInfo(CastToNaive, std::move(cast_data));
 	}
 
-	static void AddCasts(ClientContext &context) {
-		auto &config = DBConfig::GetConfig(context);
+	static void AddCasts(DatabaseInstance &db) {
+		auto &config = DBConfig::GetConfig(db);
 		auto &casts = config.GetCastFunctions();
 
 		casts.RegisterCastFunction(LogicalType::TIMESTAMP_TZ, LogicalType::TIMESTAMP, BindCastToNaive);
@@ -262,18 +263,14 @@ struct ICULocalTimestampFunc : public ICUDateFunc {
 		rdata[0] = GetLocalTimestamp(state);
 	}
 
-	static void AddFunction(const string &name, ClientContext &context) {
+	static void AddFunction(const string &name, DatabaseInstance &db) {
 		ScalarFunctionSet set(name);
 		set.AddFunction(ScalarFunction({}, LogicalType::TIMESTAMP, Execute, BindNow));
-
-		CreateScalarFunctionInfo func_info(set);
-		auto &catalog = Catalog::GetSystemCatalog(context);
-		catalog.AddFunction(context, func_info);
+		ExtensionUtil::RegisterFunction(db, set);
 	}
 };
 
 struct ICULocalTimeFunc : public ICUDateFunc {
-
 	static void Execute(DataChunk &input, ExpressionState &state, Vector &result) {
 		D_ASSERT(input.ColumnCount() == 0);
 		result.SetVectorType(VectorType::CONSTANT_VECTOR);
@@ -282,13 +279,10 @@ struct ICULocalTimeFunc : public ICUDateFunc {
 		rdata[0] = Timestamp::GetTime(local);
 	}
 
-	static void AddFunction(const string &name, ClientContext &context) {
+	static void AddFunction(const string &name, DatabaseInstance &db) {
 		ScalarFunctionSet set(name);
 		set.AddFunction(ScalarFunction({}, LogicalType::TIME, Execute, ICULocalTimestampFunc::BindNow));
-
-		CreateScalarFunctionInfo func_info(set);
-		auto &catalog = Catalog::GetSystemCatalog(context);
-		catalog.AddFunction(context, func_info);
+		ExtensionUtil::RegisterFunction(db, set);
 	}
 };
 
@@ -326,16 +320,13 @@ struct ICUTimeZoneFunc : public ICUDateFunc {
 		}
 	}
 
-	static void AddFunction(const string &name, ClientContext &context) {
+	static void AddFunction(const string &name, DatabaseInstance &db) {
 		ScalarFunctionSet set(name);
 		set.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::TIMESTAMP}, LogicalType::TIMESTAMP_TZ,
 		                               Execute<ICUFromNaiveTimestamp>, Bind));
 		set.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::TIMESTAMP_TZ}, LogicalType::TIMESTAMP,
 		                               Execute<ICUToNaiveTimestamp>, Bind));
-
-		CreateScalarFunctionInfo func_info(set);
-		auto &catalog = Catalog::GetSystemCatalog(context);
-		catalog.AddFunction(context, func_info);
+		ExtensionUtil::AddFunctionOverload(db, set);
 	}
 };
 
@@ -343,21 +334,19 @@ timestamp_t ICUDateFunc::FromNaive(icu::Calendar *calendar, timestamp_t naive) {
 	return ICUFromNaiveTimestamp::Operation(calendar, naive);
 }
 
-void RegisterICUTimeZoneFunctions(ClientContext &context) {
+void RegisterICUTimeZoneFunctions(DatabaseInstance &db) {
 	//	Table functions
-	auto &catalog = Catalog::GetSystemCatalog(context);
 	TableFunction tz_names("pg_timezone_names", {}, ICUTimeZoneFunction, ICUTimeZoneBind, ICUTimeZoneInit);
-	CreateTableFunctionInfo tz_names_info(std::move(tz_names));
-	catalog.CreateTableFunction(context, tz_names_info);
+	ExtensionUtil::RegisterFunction(db, tz_names);
 
 	//	Scalar functions
-	ICUTimeZoneFunc::AddFunction("timezone", context);
-	ICULocalTimestampFunc::AddFunction("current_localtimestamp", context);
-	ICULocalTimeFunc::AddFunction("current_localtime", context);
+	ICUTimeZoneFunc::AddFunction("timezone", db);
+	ICULocalTimestampFunc::AddFunction("current_localtimestamp", db);
+	ICULocalTimeFunc::AddFunction("current_localtime", db);
 
 	// 	Casts
-	ICUFromNaiveTimestamp::AddCasts(context);
-	ICUToNaiveTimestamp::AddCasts(context);
+	ICUFromNaiveTimestamp::AddCasts(db);
+	ICUToNaiveTimestamp::AddCasts(db);
 }
 
 } // namespace duckdb

package/src/duckdb/extension/icu/icu_extension.cpp

@@ -8,6 +8,7 @@
 #include "duckdb/main/config.hpp"
 #include "duckdb/main/connection.hpp"
 #include "duckdb/main/database.hpp"
+#include "duckdb/main/extension_util.hpp"
 #include "duckdb/parser/parsed_data/create_collation_info.hpp"
 #include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
 #include "duckdb/parser/parsed_data/create_table_function_info.hpp"
@@ -220,11 +221,9 @@ static void SetICUCalendar(ClientContext &context, SetScope scope, Value &parame
 	}
 }
 
-void IcuExtension::Load(DuckDB &db) {
-	Connection con(db);
-	con.BeginTransaction();
-
-	auto &catalog = Catalog::GetSystemCatalog(*con.context);
+void IcuExtension::Load(DuckDB &ddb) {
+	auto &db = *ddb.instance;
+	auto &catalog = Catalog::GetSystemCatalog(db);
 
 	// iterate over all the collations
 	int32_t count;
@@ -241,17 +240,14 @@ void IcuExtension::Load(DuckDB &db) {
 		collation = StringUtil::Lower(collation);
 
 		CreateCollationInfo info(collation, GetICUFunction(collation), false, true);
-		info.on_conflict = OnCreateConflict::IGNORE_ON_CONFLICT;
-		catalog.CreateCollation(*con.context, info);
+		ExtensionUtil::RegisterCollation(db, info);
 	}
 	ScalarFunction sort_key("icu_sort_key", {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::VARCHAR,
 	                        ICUCollateFunction, ICUSortKeyBind);
-
-	CreateScalarFunctionInfo sort_key_info(std::move(sort_key));
-	catalog.CreateFunction(*con.context, sort_key_info);
+	ExtensionUtil::RegisterFunction(db, sort_key);
 
 	// Time Zones
-	auto &config = DBConfig::GetConfig(*db.instance);
+	auto &config = DBConfig::GetConfig(db);
 	duckdb::unique_ptr<icu::TimeZone> tz(icu::TimeZone::createDefault());
 	icu::UnicodeString tz_id;
 	std::string tz_string;
@@ -259,16 +255,16 @@ void IcuExtension::Load(DuckDB &db) {
 	config.AddExtensionOption("TimeZone", "The current time zone", LogicalType::VARCHAR, Value(tz_string),
 	                          SetICUTimeZone);
 
-	RegisterICUDateAddFunctions(*con.context);
-	RegisterICUDatePartFunctions(*con.context);
-	RegisterICUDateSubFunctions(*con.context);
-	RegisterICUDateTruncFunctions(*con.context);
-	RegisterICUMakeDateFunctions(*con.context);
-	RegisterICUTableRangeFunctions(*con.context);
-	RegisterICUListRangeFunctions(*con.context);
-	RegisterICUStrptimeFunctions(*con.context);
-	RegisterICUTimeBucketFunctions(*con.context);
-	RegisterICUTimeZoneFunctions(*con.context);
+	RegisterICUDateAddFunctions(db);
+	RegisterICUDatePartFunctions(db);
+	RegisterICUDateSubFunctions(db);
+	RegisterICUDateTruncFunctions(db);
+	RegisterICUMakeDateFunctions(db);
+	RegisterICUTableRangeFunctions(db);
+	RegisterICUListRangeFunctions(db);
+	RegisterICUStrptimeFunctions(db);
+	RegisterICUTimeBucketFunctions(db);
+	RegisterICUTimeZoneFunctions(db);
 
 	// Calendars
 	UErrorCode status = U_ZERO_ERROR;
@@ -277,10 +273,7 @@ void IcuExtension::Load(DuckDB &db) {
 	                          SetICUCalendar);
 
 	TableFunction cal_names("icu_calendar_names", {}, ICUCalendarFunction, ICUCalendarBind, ICUCalendarInit);
-	CreateTableFunctionInfo cal_names_info(std::move(cal_names));
-	catalog.CreateTableFunction(*con.context, cal_names_info);
-
-	con.Commit();
+	ExtensionUtil::RegisterFunction(db, cal_names);
 }
 
 std::string IcuExtension::Name() {

package/src/duckdb/extension/icu/include/icu-dateadd.hpp

@@ -12,6 +12,6 @@
 
 namespace duckdb {
 
-void RegisterICUDateAddFunctions(ClientContext &context);
+void RegisterICUDateAddFunctions(DatabaseInstance &db);
 
 } // namespace duckdb

package/src/duckdb/extension/icu/include/icu-datepart.hpp

@@ -12,6 +12,6 @@
 
 namespace duckdb {
 
-void RegisterICUDatePartFunctions(ClientContext &context);
+void RegisterICUDatePartFunctions(DatabaseInstance &db);
 
 } // namespace duckdb

package/src/duckdb/extension/icu/include/icu-datesub.hpp

@@ -12,6 +12,6 @@
 
 namespace duckdb {
 
-void RegisterICUDateSubFunctions(ClientContext &context);
+void RegisterICUDateSubFunctions(DatabaseInstance &db);
 
 } // namespace duckdb

package/src/duckdb/extension/icu/include/icu-datetrunc.hpp

@@ -12,6 +12,6 @@
 
 namespace duckdb {
 
-void RegisterICUDateTruncFunctions(ClientContext &context);
+void RegisterICUDateTruncFunctions(DatabaseInstance &db);
 
 } // namespace duckdb

package/src/duckdb/extension/icu/include/icu-list-range.hpp

@@ -12,6 +12,6 @@
 
 namespace duckdb {
 
-void RegisterICUListRangeFunctions(ClientContext &context);
+void RegisterICUListRangeFunctions(DatabaseInstance &db);
 
 } // namespace duckdb

package/src/duckdb/extension/icu/include/icu-makedate.hpp

@@ -12,6 +12,6 @@
 
 namespace duckdb {
 
-void RegisterICUMakeDateFunctions(ClientContext &context);
+void RegisterICUMakeDateFunctions(DatabaseInstance &db);
 
 } // namespace duckdb

package/src/duckdb/extension/icu/include/icu-strptime.hpp

@@ -12,6 +12,6 @@
 
 namespace duckdb {
 
-void RegisterICUStrptimeFunctions(ClientContext &context);
+void RegisterICUStrptimeFunctions(DatabaseInstance &db);
 
 } // namespace duckdb

package/src/duckdb/extension/icu/include/icu-table-range.hpp

@@ -12,6 +12,6 @@
 
 namespace duckdb {
 
-void RegisterICUTableRangeFunctions(ClientContext &context);
+void RegisterICUTableRangeFunctions(DatabaseInstance &db);
 
 } // namespace duckdb

package/src/duckdb/extension/icu/include/icu-timebucket.hpp

@@ -12,6 +12,6 @@
 
 namespace duckdb {
 
-void RegisterICUTimeBucketFunctions(ClientContext &context);
+void RegisterICUTimeBucketFunctions(DatabaseInstance &db);
 
 } // namespace duckdb

package/src/duckdb/extension/icu/include/icu-timezone.hpp

@@ -12,6 +12,6 @@
 
 namespace duckdb {
 
-void RegisterICUTimeZoneFunctions(ClientContext &context);
+void RegisterICUTimeZoneFunctions(DatabaseInstance &db);
 
 } // namespace duckdb

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/extension/json/json_functions/read_json.cpp

@@ -229,6 +229,21 @@ unique_ptr<FunctionData> ReadJSONBind(ClientContext &context, TableFunctionBindI
 	transform_options.error_unknown_key = bind_data->auto_detect && !bind_data->ignore_errors;
 	transform_options.delay_error = true;
 
+	if (bind_data->auto_detect) {
+		// JSON may contain columns such as "id" and "Id", which are duplicates for us due to case-insensitivity
+		// We rename them so we can parse the file anyway. Note that we can't change bind_data->names,
+		// because the JSON reader gets columns by exact name, not position
+		case_insensitive_map_t<idx_t> name_count_map;
+		for (auto &name : names) {
+			auto it = name_count_map.find(name);
+			if (it == name_count_map.end()) {
+				name_count_map[name] = 1;
+			} else {
+				name = StringUtil::Format("%s_%llu", name, it->second++);
+			}
+		}
+	}
+
 	return std::move(bind_data);
 }
 

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;
 	}
@@ -479,6 +480,8 @@ bool Catalog::AutoLoadExtensionByCatalogEntry(ClientContext &context, CatalogTyp
 			extension_name = ExtensionHelper::FindExtensionInEntries(entry_name, EXTENSION_COPY_FUNCTIONS);
 		} else if (type == CatalogType::TYPE_ENTRY) {
 			extension_name = ExtensionHelper::FindExtensionInEntries(entry_name, EXTENSION_TYPES);
+		} else if (type == CatalogType::COLLATION_ENTRY) {
+			extension_name = ExtensionHelper::FindExtensionInEntries(entry_name, EXTENSION_COLLATIONS);
 		}
 
 		if (!extension_name.empty() && ExtensionHelper::CanAutoloadExtension(extension_name)) {
@@ -536,6 +539,8 @@ CatalogException Catalog::CreateMissingEntryException(ClientContext &context, co
 		extension_name = ExtensionHelper::FindExtensionInEntries(entry_name, EXTENSION_TYPES);
 	} else if (type == CatalogType::COPY_FUNCTION_ENTRY) {
 		extension_name = ExtensionHelper::FindExtensionInEntries(entry_name, EXTENSION_COPY_FUNCTIONS);
+	} else if (type == CatalogType::COLLATION_ENTRY) {
+		extension_name = ExtensionHelper::FindExtensionInEntries(entry_name, EXTENSION_COLLATIONS);
 	}
 
 	// if we found an extension that can handle this catalog entry, create an error hinting the user

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/execution/operator/schema/physical_attach.cpp

@@ -56,7 +56,10 @@ SourceResultType PhysicalAttach::GetData(ExecutionContext &context, DataChunk &c
 
 	// if we are loading a database type from an extension - check if that extension is loaded
 	if (!type.empty()) {
-		if (!db.ExtensionIsLoaded(type)) {
+		if (!Catalog::TryAutoLoad(context.client, type)) {
+			// FIXME: Here it might be preferrable to use an AutoLoadOrThrow kind of function
+			// so that either there will be success or a message to throw, and load will be
+			// attempted only once respecting the autoloading options
 			ExtensionHelper::LoadExternalExtension(context.client, type);
 		}
 	}

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-dev5120"
+#define DUCKDB_VERSION "0.8.2-dev5216"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "fc2e4b26a6"
+#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"},
@@ -218,6 +226,32 @@ static constexpr ExtensionEntry EXTENSION_COPY_FUNCTIONS[] = {{"parquet", "parqu
 static constexpr ExtensionEntry EXTENSION_TYPES[] = {
     {"json", "json"}, {"inet", "inet"}, {"geometry", "spatial"}}; // END_OF_EXTENSION_TYPES
 
+// Note: these are currently hardcoded in scripts/generate_extensions_function.py
+// TODO: automate by passing though to script via duckdb
+static constexpr ExtensionEntry EXTENSION_COLLATIONS[] = {
+    {"af", "icu"},    {"am", "icu"},    {"ar", "icu"},     {"ar_sa", "icu"}, {"as", "icu"},    {"az", "icu"},
+    {"be", "icu"},    {"bg", "icu"},    {"bn", "icu"},     {"bo", "icu"},    {"br", "icu"},    {"bs", "icu"},
+    {"ca", "icu"},    {"ceb", "icu"},   {"chr", "icu"},    {"cs", "icu"},    {"cy", "icu"},    {"da", "icu"},
+    {"de", "icu"},    {"de_at", "icu"}, {"dsb", "icu"},    {"dz", "icu"},    {"ee", "icu"},    {"el", "icu"},
+    {"en", "icu"},    {"en_us", "icu"}, {"eo", "icu"},     {"es", "icu"},    {"et", "icu"},    {"fa", "icu"},
+    {"fa_af", "icu"}, {"ff", "icu"},    {"fi", "icu"},     {"fil", "icu"},   {"fo", "icu"},    {"fr", "icu"},
+    {"fr_ca", "icu"}, {"fy", "icu"},    {"ga", "icu"},     {"gl", "icu"},    {"gu", "icu"},    {"ha", "icu"},
+    {"haw", "icu"},   {"he", "icu"},    {"he_il", "icu"},  {"hi", "icu"},    {"hr", "icu"},    {"hsb", "icu"},
+    {"hu", "icu"},    {"hy", "icu"},    {"id", "icu"},     {"id_id", "icu"}, {"ig", "icu"},    {"is", "icu"},
+    {"it", "icu"},    {"ja", "icu"},    {"ka", "icu"},     {"kk", "icu"},    {"kl", "icu"},    {"km", "icu"},
+    {"kn", "icu"},    {"ko", "icu"},    {"kok", "icu"},    {"ku", "icu"},    {"ky", "icu"},    {"lb", "icu"},
+    {"lkt", "icu"},   {"ln", "icu"},    {"lo", "icu"},     {"lt", "icu"},    {"lv", "icu"},    {"mk", "icu"},
+    {"ml", "icu"},    {"mn", "icu"},    {"mr", "icu"},     {"ms", "icu"},    {"mt", "icu"},    {"my", "icu"},
+    {"nb", "icu"},    {"nb_no", "icu"}, {"ne", "icu"},     {"nl", "icu"},    {"nn", "icu"},    {"om", "icu"},
+    {"or", "icu"},    {"pa", "icu"},    {"pa_in", "icu"},  {"pl", "icu"},    {"ps", "icu"},    {"pt", "icu"},
+    {"ro", "icu"},    {"ru", "icu"},    {"sa", "icu"},     {"se", "icu"},    {"si", "icu"},    {"sk", "icu"},
+    {"sl", "icu"},    {"smn", "icu"},   {"sq", "icu"},     {"sr", "icu"},    {"sr_ba", "icu"}, {"sr_me", "icu"},
+    {"sr_rs", "icu"}, {"sv", "icu"},    {"sw", "icu"},     {"ta", "icu"},    {"te", "icu"},    {"th", "icu"},
+    {"tk", "icu"},    {"to", "icu"},    {"tr", "icu"},     {"ug", "icu"},    {"uk", "icu"},    {"ur", "icu"},
+    {"uz", "icu"},    {"vi", "icu"},    {"wae", "icu"},    {"wo", "icu"},    {"xh", "icu"},    {"yi", "icu"},
+    {"yo", "icu"},    {"yue", "icu"},   {"yue_cn", "icu"}, {"zh", "icu"},    {"zh_cn", "icu"}, {"zh_hk", "icu"},
+    {"zh_mo", "icu"}, {"zh_sg", "icu"}, {"zh_tw", "icu"},  {"zu", "icu"}}; // END_OF_EXTENSION_COLLATIONS
+
 // Note: these are currently hardcoded in scripts/generate_extensions_function.py
 // TODO: automate by passing though to script via duckdb
 static constexpr ExtensionEntry EXTENSION_FILE_PREFIXES[] = {

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

@@ -14,6 +14,7 @@
 
 namespace duckdb {
 struct CreateMacroInfo;
+struct CreateCollationInfo;
 class DatabaseInstance;
 
 //! The ExtensionUtil class contains methods that are useful for extensions
@@ -40,6 +41,19 @@ public:
 	//! Register a new macro function - throw an exception if the function already exists
 	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, CreateMacroInfo &info);
 
+	//! Register a new collation
+	DUCKDB_API static void RegisterCollation(DatabaseInstance &db, CreateCollationInfo &info);
+
+	//! Returns a reference to the function in the catalog - throws an exception if it does not exist
+	DUCKDB_API static ScalarFunctionCatalogEntry &GetFunction(DatabaseInstance &db, const string &name);
+	DUCKDB_API static TableFunctionCatalogEntry &GetTableFunction(DatabaseInstance &db, const string &name);
+
+	//! Add a function overload
+	DUCKDB_API static void AddFunctionOverload(DatabaseInstance &db, ScalarFunction function);
+	DUCKDB_API static void AddFunctionOverload(DatabaseInstance &db, ScalarFunctionSet function);
+
+	DUCKDB_API static void AddFunctionOverload(DatabaseInstance &db, TableFunctionSet function);
+
 	//! Registers a new type
 	DUCKDB_API static void RegisterType(DatabaseInstance &db, string type_name, LogicalType type);
 

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);