duckdb 0.7.2-dev2820.0 → 0.7.2-dev2867.0

package/package.json

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

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

@@ -203,6 +203,14 @@ struct ICUDatePart : public ICUDateFunc {
 		return Date::EpochToDate(ExtractEpoch(calendar, 0));
 	}
 
+	static string_t MonthName(icu::Calendar *calendar, const uint64_t micros) {
+		return Date::MONTH_NAMES[ExtractMonth(calendar, micros) - 1];
+	}
+
+	static string_t DayName(icu::Calendar *calendar, const uint64_t micros) {
+		return Date::DAY_NAMES[ExtractDayOfWeek(calendar, micros)];
+	}
+
 	template <typename RESULT_TYPE>
 	struct BindAdapterData : public BindData {
 		using result_t = RESULT_TYPE;
@@ -246,7 +254,7 @@ struct ICUDatePart : public ICUDateFunc {
 				                                                         return info.adapters[0](calendar, micros);
 			                                                         } else {
 				                                                         mask.SetInvalid(idx);
-				                                                         return RESULT_TYPE(0);
+				                                                         return RESULT_TYPE();
 			                                                         }
 		                                                         });
 	}
@@ -482,6 +490,44 @@ struct ICUDatePart : public ICUDateFunc {
 		CreateScalarFunctionInfo func_info(set);
 		catalog.AddFunction(context, func_info);
 	}
+
+	static unique_ptr<FunctionData> BindMonthName(ClientContext &context, ScalarFunction &bound_function,
+	                                              vector<unique_ptr<Expression>> &arguments) {
+		using data_t = BindAdapterData<string_t>;
+		return BindAdapter<data_t>(context, bound_function, arguments, MonthName);
+	}
+
+	template <typename INPUT_TYPE>
+	static ScalarFunction GetMonthNameFunction(const LogicalType &temporal_type) {
+		return ScalarFunction({temporal_type}, LogicalType::VARCHAR, UnaryTimestampFunction<INPUT_TYPE, string_t>,
+		                      BindMonthName);
+	}
+	static void AddMonthNameFunctions(const string &name, ClientContext &context) {
+		auto &catalog = Catalog::GetSystemCatalog(context);
+		ScalarFunctionSet set(name);
+		set.AddFunction(GetMonthNameFunction<timestamp_t>(LogicalType::TIMESTAMP_TZ));
+		CreateScalarFunctionInfo func_info(set);
+		catalog.AddFunction(context, func_info);
+	}
+
+	static unique_ptr<FunctionData> BindDayName(ClientContext &context, ScalarFunction &bound_function,
+	                                            vector<unique_ptr<Expression>> &arguments) {
+		using data_t = BindAdapterData<string_t>;
+		return BindAdapter<data_t>(context, bound_function, arguments, DayName);
+	}
+
+	template <typename INPUT_TYPE>
+	static ScalarFunction GetDayNameFunction(const LogicalType &temporal_type) {
+		return ScalarFunction({temporal_type}, LogicalType::VARCHAR, UnaryTimestampFunction<INPUT_TYPE, string_t>,
+		                      BindDayName);
+	}
+	static void AddDayNameFunctions(const string &name, ClientContext &context) {
+		auto &catalog = Catalog::GetSystemCatalog(context);
+		ScalarFunctionSet set(name);
+		set.AddFunction(GetDayNameFunction<timestamp_t>(LogicalType::TIMESTAMP_TZ));
+		CreateScalarFunctionInfo func_info(set);
+		catalog.AddFunction(context, func_info);
+	}
 };
 
 void RegisterICUDatePartFunctions(ClientContext &context) {
@@ -520,6 +566,10 @@ void RegisterICUDatePartFunctions(ClientContext &context) {
 	//  register the last_day function
 	ICUDatePart::AddLastDayFunctions("last_day", context);
 
+	// register the dayname/monthname functions
+	ICUDatePart::AddMonthNameFunctions("monthname", context);
+	ICUDatePart::AddDayNameFunctions("dayname", context);
+
 	// finally the actual date_part function
 	ICUDatePart::AddDatePartFunctions("date_part", context);
 	ICUDatePart::AddDatePartFunctions("datepart", context);

package/src/duckdb/extension/parquet/parquet-extension.cpp

@@ -369,7 +369,8 @@ public:
 				continue;
 			}
 			MultiFileReader::InitializeReader(*reader, bind_data.parquet_options.file_options, bind_data.reader_bind,
-			                                  bind_data.types, bind_data.names, input.column_ids, input.filters);
+			                                  bind_data.types, bind_data.names, input.column_ids, input.filters,
+			                                  bind_data.files[0]);
 		}
 
 		result->column_ids = input.column_ids;
@@ -561,9 +562,9 @@ public:
 				shared_ptr<ParquetReader> reader;
 				try {
 					reader = make_shared<ParquetReader>(context, file, pq_options);
-					MultiFileReader::InitializeReader(*reader, bind_data.parquet_options.file_options,
-					                                  bind_data.reader_bind, bind_data.types, bind_data.names,
-					                                  parallel_state.column_ids, parallel_state.filters);
+					MultiFileReader::InitializeReader(
+					    *reader, bind_data.parquet_options.file_options, bind_data.reader_bind, bind_data.types,
+					    bind_data.names, parallel_state.column_ids, parallel_state.filters, bind_data.files.front());
 				} catch (...) {
 					parallel_lock.lock();
 					parallel_state.error_opening_file = true;

package/src/duckdb/src/common/local_file_system.cpp

@@ -977,7 +977,6 @@ vector<string> LocalFileSystem::Glob(const string &path, FileOpener *opener) {
 		throw IOException("Cannot use multiple \'**\' in one path");
 	}
 
-	bool recursive_search = false;
 	for (idx_t i = absolute_path ? 1 : 0; i < splits.size(); i++) {
 		bool is_last_chunk = i + 1 == splits.size();
 		bool has_glob = HasGlob(splits[i]);
@@ -989,7 +988,7 @@ vector<string> LocalFileSystem::Glob(const string &path, FileOpener *opener) {
 			if (previous_directories.empty()) {
 				result.push_back(splits[i]);
 			} else {
-				if (recursive_search && is_last_chunk) {
+				if (is_last_chunk) {
 					for (auto &prev_directory : previous_directories) {
 						const string filename = JoinPath(prev_directory, splits[i]);
 						if (FileExists(filename) || DirectoryExists(filename)) {
@@ -1004,7 +1003,6 @@ vector<string> LocalFileSystem::Glob(const string &path, FileOpener *opener) {
 			}
 		} else {
 			if (IsCrawl(splits[i])) {
-				recursive_search = true;
 				if (!is_last_chunk) {
 					result = previous_directories;
 				}

package/src/duckdb/src/common/multi_file_reader.cpp

@@ -192,7 +192,7 @@ void MultiFileReader::FinalizeBind(const MultiFileReaderOptions &file_options, c
 void MultiFileReader::CreateNameMapping(const string &file_name, const vector<LogicalType> &local_types,
                                         const vector<string> &local_names, const vector<LogicalType> &global_types,
                                         const vector<string> &global_names, const vector<column_t> &global_column_ids,
-                                        MultiFileReaderData &reader_data) {
+                                        MultiFileReaderData &reader_data, const string &initial_file) {
 	D_ASSERT(global_types.size() == global_names.size());
 	D_ASSERT(local_types.size() == local_names.size());
 	// we have expected types: create a map of name -> column index
@@ -229,11 +229,12 @@ void MultiFileReader::CreateNameMapping(const string &file_name, const vector<Lo
 				}
 				candidate_names += local_name;
 			}
-			throw IOException(StringUtil::Format(
-			    "Failed to read file \"%s\": schema mismatch in glob: column \"%s\" was read from "
-			    "the original file, but could not be found in file \"%s\".\nCandidate names: %s\nIf you are trying to "
-			    "read files with different schemas, try setting union_by_name=True",
-			    file_name, global_name, file_name, candidate_names));
+			throw IOException(
+			    StringUtil::Format("Failed to read file \"%s\": schema mismatch in glob: column \"%s\" was read from "
+			                       "the original file \"%s\", but could not be found in file \"%s\".\nCandidate names: "
+			                       "%s\nIf you are trying to "
+			                       "read files with different schemas, try setting union_by_name=True",
+			                       file_name, global_name, initial_file, file_name, candidate_names));
 		}
 		// we found the column in the local file - check if the types are the same
 		auto local_id = entry->second;
@@ -254,8 +255,10 @@ void MultiFileReader::CreateNameMapping(const string &file_name, const vector<Lo
 void MultiFileReader::CreateMapping(const string &file_name, const vector<LogicalType> &local_types,
                                     const vector<string> &local_names, const vector<LogicalType> &global_types,
                                     const vector<string> &global_names, const vector<column_t> &global_column_ids,
-                                    optional_ptr<TableFilterSet> filters, MultiFileReaderData &reader_data) {
-	CreateNameMapping(file_name, local_types, local_names, global_types, global_names, global_column_ids, reader_data);
+                                    optional_ptr<TableFilterSet> filters, MultiFileReaderData &reader_data,
+                                    const string &initial_file) {
+	CreateNameMapping(file_name, local_types, local_names, global_types, global_names, global_column_ids, reader_data,
+	                  initial_file);
 	if (filters) {
 		reader_data.filter_map.resize(global_types.size());
 		for (idx_t c = 0; c < reader_data.column_mapping.size(); c++) {

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

@@ -3,6 +3,7 @@
 #include "duckdb/catalog/catalog.hpp"
 #include "duckdb/common/types/column/column_data_collection.hpp"
 #include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
+#include "duckdb/common/string_map_set.hpp"
 
 namespace duckdb {
 
@@ -21,6 +22,7 @@ public:
 	Vector result;
 	idx_t size = 0;
 	idx_t capacity = STANDARD_VECTOR_SIZE;
+	string_set_t found_strings;
 };
 
 unique_ptr<GlobalSinkState> PhysicalCreateType::GetGlobalSinkState(ClientContext &context) const {
@@ -52,8 +54,15 @@ SinkResultType PhysicalCreateType::Sink(ExecutionContext &context, GlobalSinkSta
 		if (!sdata.validity.RowIsValid(idx)) {
 			throw InvalidInputException("Attempted to create ENUM type with NULL value!");
 		}
-		result_ptr[gstate.size++] =
-		    StringVector::AddStringOrBlob(gstate.result, src_ptr[idx].GetData(), src_ptr[idx].GetSize());
+		auto str = src_ptr[idx];
+		auto entry = gstate.found_strings.find(src_ptr[idx]);
+		if (entry != gstate.found_strings.end()) {
+			// entry was already found - skip
+			continue;
+		}
+		auto owned_string = StringVector::AddStringOrBlob(gstate.result, str.GetData(), str.GetSize());
+		gstate.found_strings.insert(owned_string);
+		result_ptr[gstate.size++] = owned_string;
 	}
 	return SinkResultType::NEED_MORE_INPUT;
 }

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

@@ -497,7 +497,8 @@ bool ParallelCSVGlobalState::Next(ClientContext &context, const ReadCSVData &bin
 		}
 		reader->options.file_path = current_file_path;
 		MultiFileReader::InitializeReader(*reader, bind_data.options.file_options, bind_data.reader_bind,
-		                                  bind_data.return_types, bind_data.return_names, column_ids, nullptr);
+		                                  bind_data.return_types, bind_data.return_names, column_ids, nullptr,
+		                                  bind_data.files.front());
 	} else {
 		// update the current reader
 		reader->SetBufferRead(std::move(result));
@@ -660,7 +661,8 @@ struct SingleThreadedCSVState : public GlobalTableFunctionState {
 				result->names = csv_names;
 			}
 			MultiFileReader::InitializeReader(*result, bind_data.options.file_options, bind_data.reader_bind,
-			                                  bind_data.return_types, bind_data.return_names, column_ids, nullptr);
+			                                  bind_data.return_types, bind_data.return_names, column_ids, nullptr,
+			                                  bind_data.files.front());
 		}
 		total_size = result->file_handle->FileSize();
 		return result;
@@ -707,14 +709,15 @@ static unique_ptr<GlobalTableFunctionState> SingleThreadedCSVInit(ClientContext
 		}
 	}
 	MultiFileReader::InitializeReader(*result->initial_reader, bind_data.options.file_options, bind_data.reader_bind,
-	                                  bind_data.return_types, bind_data.return_names, input.column_ids, input.filters);
+	                                  bind_data.return_types, bind_data.return_names, input.column_ids, input.filters,
+	                                  bind_data.files.front());
 	for (auto &reader : bind_data.union_readers) {
 		if (!reader) {
 			continue;
 		}
 		MultiFileReader::InitializeReader(*reader, bind_data.options.file_options, bind_data.reader_bind,
 		                                  bind_data.return_types, bind_data.return_names, input.column_ids,
-		                                  input.filters);
+		                                  input.filters, bind_data.files.front());
 	}
 	result->column_ids = input.column_ids;
 

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

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.7.2-dev2820"
+#define DUCKDB_VERSION "0.7.2-dev2867"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "fc797c18cf"
+#define DUCKDB_SOURCE_ID "aa20f173b1"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/include/duckdb/common/multi_file_reader.hpp

@@ -107,7 +107,8 @@ struct MultiFileReader {
 	DUCKDB_API static void CreateMapping(const string &file_name, const vector<LogicalType> &local_types,
 	                                     const vector<string> &local_names, const vector<LogicalType> &global_types,
 	                                     const vector<string> &global_names, const vector<column_t> &global_column_ids,
-	                                     optional_ptr<TableFilterSet> filters, MultiFileReaderData &reader_data);
+	                                     optional_ptr<TableFilterSet> filters, MultiFileReaderData &reader_data,
+	                                     const string &initial_file);
 	//! Finalize the reading of a chunk - applying any constants that are required
 	DUCKDB_API static void FinalizeChunk(const MultiFileReaderBindData &bind_data,
 	                                     const MultiFileReaderData &reader_data, DataChunk &chunk);
@@ -156,11 +157,11 @@ struct MultiFileReader {
 	static void InitializeReader(READER_CLASS &reader, const MultiFileReaderOptions &options,
 	                             const MultiFileReaderBindData &bind_data, const vector<LogicalType> &global_types,
 	                             const vector<string> &global_names, const vector<column_t> &global_column_ids,
-	                             optional_ptr<TableFilterSet> table_filters) {
+	                             optional_ptr<TableFilterSet> table_filters, const string &initial_file) {
 		FinalizeBind(options, bind_data, reader.GetFileName(), reader.GetNames(), global_types, global_names,
 		             global_column_ids, reader.reader_data);
 		CreateMapping(reader.GetFileName(), reader.GetTypes(), reader.GetNames(), global_types, global_names,
-		              global_column_ids, table_filters, reader.reader_data);
+		              global_column_ids, table_filters, reader.reader_data, initial_file);
 		reader.reader_data.filters = table_filters;
 	}
 
@@ -193,7 +194,7 @@ private:
 	static void CreateNameMapping(const string &file_name, const vector<LogicalType> &local_types,
 	                              const vector<string> &local_names, const vector<LogicalType> &global_types,
 	                              const vector<string> &global_names, const vector<column_t> &global_column_ids,
-	                              MultiFileReaderData &reader_data);
+	                              MultiFileReaderData &reader_data, const string &initial_file);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/schema/physical_create_type.hpp

@@ -47,6 +47,10 @@ public:
 	bool ParallelSink() const override {
 		return false;
 	}
+
+	bool SinkOrderDependent() const override {
+		return true;
+	}
 };
 
 } // namespace duckdb

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

@@ -60,6 +60,7 @@ public:
 
 private:
 	void Initialize(const char *path, DBConfig *config);
+	void CreateDatabase(const string &database_type);
 
 	void Configure(DBConfig &config);
 

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

@@ -57,6 +57,9 @@ public:
 	idx_t ModifyCatalog() {
 		return catalog_version++;
 	}
+	bool HasDefaultDatabase() {
+		return !default_database.empty();
+	}
 
 private:
 	//! The system database is a special database that holds system entries (e.g. functions)

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

@@ -56,8 +56,6 @@ public:
 
 	static const vector<string> GetPublicKeys();
 
-	static void StorageInit(string &extension, DBConfig &config);
-
 	// Returns extension name, or empty string if not a replacement open path
 	static string ExtractExtensionPrefixFromPath(const string &path);
 

package/src/duckdb/src/include/duckdb/parser/tableref/pivotref.hpp

@@ -9,6 +9,7 @@
 #pragma once
 
 #include "duckdb/parser/tableref.hpp"
+#include "duckdb/parser/query_node/select_node.hpp"
 
 namespace duckdb {
 
@@ -43,6 +44,8 @@ struct PivotColumn {
 	vector<PivotColumnEntry> entries;
 	//! The enum to read pivot values from (if any)
 	string pivot_enum;
+	//! Subquery (if any) - used during transform only
+	unique_ptr<QueryNode> subquery;
 
 	string ToString() const;
 	bool Equals(const PivotColumn &other) const;

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

@@ -45,6 +45,7 @@ class Transformer {
 		string enum_name;
 		unique_ptr<SelectNode> base;
 		unique_ptr<ParsedExpression> column;
+		unique_ptr<QueryNode> subquery;
 	};
 
 public:
@@ -85,10 +86,13 @@ private:
 	bool GetNamedParam(const string &name, int32_t &index);
 	bool HasNamedParameters() const;
 
-	void AddPivotEntry(string enum_name, unique_ptr<SelectNode> source, unique_ptr<ParsedExpression> column);
+	void AddPivotEntry(string enum_name, unique_ptr<SelectNode> source, unique_ptr<ParsedExpression> column,
+	                   unique_ptr<QueryNode> subquery);
 	unique_ptr<SQLStatement> GenerateCreateEnumStmt(unique_ptr<CreatePivotEntry> entry);
 	bool HasPivotEntries();
 	idx_t PivotEntryCount();
+	vector<unique_ptr<CreatePivotEntry>> &GetPivotEntries();
+	void PivotEntryCheck(const string &type);
 	void ExtractCTEsRecursive(CommonTableExpressionMap &cte_map);
 
 private:

package/src/duckdb/src/main/attached_database.cpp

@@ -1,9 +1,11 @@
 #include "duckdb/main/attached_database.hpp"
-#include "duckdb/storage/storage_manager.hpp"
-#include "duckdb/transaction/duck_transaction_manager.hpp"
-#include "duckdb/common/file_system.hpp"
+
 #include "duckdb/catalog/duck_catalog.hpp"
+#include "duckdb/common/file_system.hpp"
+#include "duckdb/parser/parsed_data/attach_info.hpp"
 #include "duckdb/storage/storage_extension.hpp"
+#include "duckdb/storage/storage_manager.hpp"
+#include "duckdb/transaction/duck_transaction_manager.hpp"
 
 namespace duckdb {
 

package/src/duckdb/src/main/database.cpp

@@ -149,8 +149,9 @@ duckdb::unique_ptr<AttachedDatabase> DatabaseInstance::CreateAttachedDatabase(At
                                                                               AccessMode access_mode) {
 	duckdb::unique_ptr<AttachedDatabase> attached_database;
 	if (!type.empty()) {
-		// find the storage extensionon database
-		auto entry = config.storage_extensions.find(type);
+		// find the storage extension
+		auto extension_name = ExtensionHelper::ApplyExtensionAlias(type);
+		auto entry = config.storage_extensions.find(extension_name);
 		if (entry == config.storage_extensions.end()) {
 			throw BinderException("Unrecognized storage type \"%s\"", type);
 		}
@@ -171,6 +172,33 @@ duckdb::unique_ptr<AttachedDatabase> DatabaseInstance::CreateAttachedDatabase(At
 	return attached_database;
 }
 
+void DatabaseInstance::CreateDatabase(const string &database_type) {
+	AttachInfo info;
+	info.name = AttachedDatabase::ExtractDatabaseName(config.options.database_path);
+	info.path = config.options.database_path;
+
+	auto attached_database = CreateAttachedDatabase(info, database_type, config.options.access_mode);
+	auto initial_database = attached_database.get();
+	{
+		Connection con(*this);
+		con.BeginTransaction();
+		db_manager->AddDatabase(*con.context, std::move(attached_database));
+		con.Commit();
+	}
+
+	// initialize the database
+	initial_database->Initialize();
+}
+
+void ThrowExtensionSetUnrecognizedOptions(const unordered_map<string, Value> &unrecognized_options) {
+	auto unrecognized_options_iter = unrecognized_options.begin();
+	string unrecognized_option_keys = unrecognized_options_iter->first;
+	for (; unrecognized_options_iter == unrecognized_options.end(); ++unrecognized_options_iter) {
+		unrecognized_option_keys = "," + unrecognized_options_iter->first;
+	}
+	throw InvalidInputException("Unrecognized configuration property \"%s\"", unrecognized_option_keys);
+}
+
 void DatabaseInstance::Initialize(const char *database_path, DBConfig *user_config) {
 	DBConfig default_config;
 	DBConfig *config_ptr = &default_config;
@@ -208,27 +236,9 @@ void DatabaseInstance::Initialize(const char *database_path, DBConfig *user_conf
 
 	// check if we are opening a standard DuckDB database or an extension database
 	auto database_type = ExtractDatabaseType(config.options.database_path);
-	if (!database_type.empty()) {
-		// we are opening an extension database, run storage_init
-		ExtensionHelper::StorageInit(database_type, config);
-	}
-	AttachInfo info;
-	info.name = AttachedDatabase::ExtractDatabaseName(config.options.database_path);
-	info.path = config.options.database_path;
-
-	auto attached_database = CreateAttachedDatabase(info, database_type, config.options.access_mode);
-	auto initial_database = attached_database.get();
-	{
-		Connection con(*this);
-		con.BeginTransaction();
-		db_manager->AddDatabase(*con.context, std::move(attached_database));
-		con.Commit();
-	}
 
 	// initialize the system catalog
 	db_manager->InitializeSystemCatalog();
-	// initialize the database
-	initial_database->Initialize();
 
 	if (!database_type.empty()) {
 		// if we are opening an extension database - load the extension
@@ -236,24 +246,11 @@ void DatabaseInstance::Initialize(const char *database_path, DBConfig *user_conf
 	}
 
 	if (!config.options.unrecognized_options.empty()) {
-		// check if all unrecognized options can be handled by the loaded extension(s)
-		for (auto &unrecognized_option : config.options.unrecognized_options) {
-			auto entry = config.extension_parameters.find(unrecognized_option.first);
-			if (entry == config.extension_parameters.end()) {
-				throw InvalidInputException("Unrecognized configuration property \"%s\"", unrecognized_option.first);
-			}
-		}
+		ThrowExtensionSetUnrecognizedOptions(config.options.unrecognized_options);
+	}
 
-		// if so - set the options
-		Connection con(*this);
-		con.BeginTransaction();
-		for (auto &unrecognized_option : config.options.unrecognized_options) {
-			auto entry = config.extension_parameters.find(unrecognized_option.first);
-			D_ASSERT(entry != config.extension_parameters.end());
-			PhysicalSet::SetExtensionVariable(*con.context, entry->second, unrecognized_option.first, SetScope::GLOBAL,
-			                                  unrecognized_option.second);
-		}
-		con.Commit();
+	if (!db_manager->HasDefaultDatabase()) {
+		CreateDatabase(database_type);
 	}
 
 	// only increase thread count after storage init because we get races on catalog otherwise

package/src/duckdb/src/main/extension/extension_load.cpp

@@ -19,7 +19,7 @@ namespace duckdb {
 //===--------------------------------------------------------------------===//
 typedef void (*ext_init_fun_t)(DatabaseInstance &);
 typedef const char *(*ext_version_fun_t)(void);
-typedef void (*ext_storage_init_t)(DBConfig &);
+typedef bool (*ext_is_storage_t)(void);
 
 template <class T>
 static T LoadFunctionFromDLL(void *dll, const string &function_name, const string &filename) {
@@ -201,7 +201,18 @@ ExtensionInitResult ExtensionHelper::InitialLoad(DBConfig &config, FileOpener *o
 	string error;
 	ExtensionInitResult result;
 	if (!TryInitialLoad(config, opener, extension, result, error)) {
-		throw IOException(error);
+		if (!ExtensionHelper::AllowAutoInstall(extension)) {
+			throw IOException(error);
+		}
+		// the extension load failed - try installing the extension
+		if (!config.file_system) {
+			throw InternalException("Attempting to install an extension without a file system");
+		}
+		ExtensionHelper::InstallExtension(config, *config.file_system, extension, false);
+		// try loading again
+		if (!TryInitialLoad(config, nullptr, extension, result, error)) {
+			throw IOException(error);
+		}
 	}
 	return result;
 }
@@ -251,38 +262,6 @@ void ExtensionHelper::LoadExternalExtension(ClientContext &context, const string
 	LoadExternalExtension(DatabaseInstance::GetDatabase(context), FileSystem::GetFileOpener(context), extension);
 }
 
-void ExtensionHelper::StorageInit(string &extension, DBConfig &config) {
-	extension = ExtensionHelper::ApplyExtensionAlias(extension);
-	ExtensionInitResult res;
-	string error;
-	if (!TryInitialLoad(config, nullptr, extension, res, error)) {
-		if (!ExtensionHelper::AllowAutoInstall(extension)) {
-			throw IOException(error);
-		}
-		// the extension load failed - try installing the extension
-		if (!config.file_system) {
-			throw InternalException("Attempting to install an extension without a file system");
-		}
-		ExtensionHelper::InstallExtension(config, *config.file_system, extension, false);
-		// try loading again
-		if (!TryInitialLoad(config, nullptr, extension, res, error)) {
-			throw IOException(error);
-		}
-	}
-	auto storage_fun_name = res.basename + "_storage_init";
-
-	ext_storage_init_t storage_init_fun;
-	storage_init_fun = LoadFunctionFromDLL<ext_storage_init_t>(res.lib_hdl, storage_fun_name, res.filename);
-
-	try {
-		(*storage_init_fun)(config);
-	} catch (std::exception &e) {
-		throw InvalidInputException(
-		    "Storage initialization function \"%s\" from file \"%s\" threw an exception: \"%s\"", storage_fun_name,
-		    res.filename, e.what());
-	}
-}
-
 string ExtensionHelper::ExtractExtensionPrefixFromPath(const string &path) {
 	auto first_colon = path.find(':');
 	if (first_colon == string::npos || first_colon < 2) { // needs to be at least two characters because windows c: ...

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

@@ -29,10 +29,7 @@ unique_ptr<CreateStatement> Transformer::TransformCreateFunction(duckdb_libpgque
 		auto query_node = TransformSelect(stmt->query, true)->node->Copy();
 		macro_func = make_uniq<TableMacroFunction>(std::move(query_node));
 	}
-	if (HasPivotEntries()) {
-		throw ParserException("Cannot use PIVOT statement syntax in a macro. Use the SQL standard PIVOT syntax in the "
-		                      "FROM clause instead.");
-	}
+	PivotEntryCheck("macro");
 
 	auto info =
 	    make_uniq<CreateMacroInfo>((stmt->function ? CatalogType::MACRO_ENTRY : CatalogType::TABLE_MACRO_ENTRY));

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

@@ -26,10 +26,8 @@ unique_ptr<CreateStatement> Transformer::TransformCreateView(duckdb_libpgquery::
 	info->on_conflict = TransformOnConflict(stmt->onconflict);
 
 	info->query = TransformSelect(stmt->query, false);
-	if (HasPivotEntries()) {
-		throw ParserException("Cannot use PIVOT statement syntax in a view. Use the SQL standard PIVOT syntax in the "
-		                      "FROM clause instead.");
-	}
+
+	PivotEntryCheck("view");
 
 	if (stmt->aliases && stmt->aliases->length > 0) {
 		for (auto c = stmt->aliases->head; c != nullptr; c = lnext(c)) {