duckdb 0.8.2-dev3300.0 → 0.8.2-dev3456.0

package/binding.gyp

@@ -313,7 +313,9 @@
                 "NAPI_VERSION=6", 
                 "DUCKDB_EXTENSION_PARQUET_LINKED", 
                 "DUCKDB_EXTENSION_ICU_LINKED", 
-                "DUCKDB_EXTENSION_JSON_LINKED"
+                "DUCKDB_EXTENSION_JSON_LINKED", 
+                "DUCKDB_EXTENSION_AUTOLOAD_DEFAULT=1", 
+                "DUCKDB_EXTENSION_AUTOINSTALL_DEFAULT=1"
             ], 
             "cflags_cc": [
                 "-frtti", 

package/configure.py

@@ -22,6 +22,9 @@ import package_build
 
 defines = ['DUCKDB_EXTENSION_{}_LINKED'.format(ext.upper()) for ext in extensions]
 
+# Autoloading is on by default for node distributions
+defines.extend(['DUCKDB_EXTENSION_AUTOLOAD_DEFAULT=1', 'DUCKDB_EXTENSION_AUTOINSTALL_DEFAULT=1'])
+
 if os.environ.get('DUCKDB_NODE_BUILD_CACHE') == '1' and os.path.isfile(cache_file):
     with open(cache_file, 'rb') as f:
         cache = pickle.load(f)

package/package.json

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

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

@@ -11,6 +11,7 @@
 #include "duckdb/main/client_data.hpp"
 #include "duckdb/main/database.hpp"
 #include "duckdb/parser/expression/function_expression.hpp"
+#include "duckdb/main/extension_helper.hpp"
 #include "duckdb/parser/parsed_data/alter_table_info.hpp"
 #include "duckdb/parser/parsed_data/create_aggregate_function_info.hpp"
 #include "duckdb/parser/parsed_data/create_collation_info.hpp"
@@ -28,6 +29,7 @@
 #include "duckdb/planner/binder.hpp"
 #include "duckdb/catalog/default/default_types.hpp"
 #include "duckdb/main/extension_entries.hpp"
+#include "duckdb/main/extension/generated_extension_loader.hpp"
 #include "duckdb/main/connection.hpp"
 #include "duckdb/main/attached_database.hpp"
 #include "duckdb/main/database_manager.hpp"
@@ -297,6 +299,7 @@ struct CatalogLookup {
 struct CatalogEntryLookup {
 	optional_ptr<SchemaCatalogEntry> schema;
 	optional_ptr<CatalogEntry> entry;
+	PreservedError error;
 
 	DUCKDB_API bool Found() const {
 		return entry;
@@ -315,6 +318,7 @@ void Catalog::DropEntry(ClientContext &context, DropInfo &info) {
 	}
 
 	auto lookup = LookupEntry(context, info.type, info.schema, info.name, info.if_not_found);
+
 	if (!lookup.Found()) {
 		return;
 	}
@@ -363,26 +367,6 @@ SimilarCatalogEntry Catalog::SimilarEntryInSchemas(ClientContext &context, const
 	return result;
 }
 
-string FindExtensionGeneric(const string &name, const ExtensionEntry entries[], idx_t size) {
-	auto lcase = StringUtil::Lower(name);
-	auto it = std::lower_bound(entries, entries + size, lcase,
-	                           [](const ExtensionEntry &element, const string &value) { return element.name < value; });
-	if (it != entries + size && it->name == lcase) {
-		return it->extension;
-	}
-	return "";
-}
-
-string FindExtensionForFunction(const string &name) {
-	idx_t size = sizeof(EXTENSION_FUNCTIONS) / sizeof(ExtensionEntry);
-	return FindExtensionGeneric(name, EXTENSION_FUNCTIONS, size);
-}
-
-string FindExtensionForSetting(const string &name) {
-	idx_t size = sizeof(EXTENSION_SETTINGS) / sizeof(ExtensionEntry);
-	return FindExtensionGeneric(name, EXTENSION_SETTINGS, size);
-}
-
 vector<CatalogSearchEntry> GetCatalogEntries(ClientContext &context, const string &catalog, const string &schema) {
 	vector<CatalogSearchEntry> entries;
 	auto &search_path = *context.client_data->catalog_search_path;
@@ -447,14 +431,53 @@ void FindMinimalQualification(ClientContext &context, const string &catalog_name
 	qualify_schema = true;
 }
 
+void Catalog::AutoloadExtensionByConfigName(ClientContext &context, const string &configuration_name) {
+#ifndef DUCKDB_DISABLE_EXTENSION_LOAD
+	auto &dbconfig = DBConfig::GetConfig(context);
+	if (dbconfig.options.autoload_known_extensions) {
+		auto extension_name = ExtensionHelper::FindExtensionInEntries(configuration_name, EXTENSION_SETTINGS);
+		if (ExtensionHelper::CanAutoloadExtension(extension_name)) {
+			ExtensionHelper::AutoLoadExtension(context, extension_name);
+			return;
+		}
+	}
+#endif
+
+	throw Catalog::UnrecognizedConfigurationError(context, configuration_name);
+}
+
+bool Catalog::AutoLoadExtensionByCatalogEntry(ClientContext &context, CatalogType type, const string &entry_name) {
+#ifndef DUCKDB_DISABLE_EXTENSION_LOAD
+	auto &dbconfig = DBConfig::GetConfig(context);
+	if (dbconfig.options.autoload_known_extensions) {
+		string extension_name;
+		if (type == CatalogType::TABLE_FUNCTION_ENTRY || type == CatalogType::SCALAR_FUNCTION_ENTRY ||
+		    type == CatalogType::AGGREGATE_FUNCTION_ENTRY || type == CatalogType::PRAGMA_FUNCTION_ENTRY) {
+			extension_name = ExtensionHelper::FindExtensionInEntries(entry_name, EXTENSION_FUNCTIONS);
+		} else if (type == CatalogType::COPY_FUNCTION_ENTRY) {
+			extension_name = ExtensionHelper::FindExtensionInEntries(entry_name, EXTENSION_COPY_FUNCTIONS);
+		} else if (type == CatalogType::TYPE_ENTRY) {
+			extension_name = ExtensionHelper::FindExtensionInEntries(entry_name, EXTENSION_TYPES);
+		}
+
+		if (!extension_name.empty() && ExtensionHelper::CanAutoloadExtension(extension_name)) {
+			ExtensionHelper::AutoLoadExtension(context, extension_name);
+			return true;
+		}
+	}
+#endif
+
+	return false;
+}
+
 CatalogException Catalog::UnrecognizedConfigurationError(ClientContext &context, const string &name) {
 	// check if the setting exists in any extensions
-	auto extension_name = FindExtensionForSetting(name);
+	auto extension_name = ExtensionHelper::FindExtensionInEntries(name, EXTENSION_SETTINGS);
 	if (!extension_name.empty()) {
-		return CatalogException(
-		    "Setting with name \"%s\" is not in the catalog, but it exists in the %s extension.\n\nTo "
-		    "install and load the extension, run:\nINSTALL %s;\nLOAD %s;",
-		    name, extension_name, extension_name, extension_name);
+		auto error_message = "Setting with name \"" + name + "\" is not in the catalog, but it exists in the " +
+		                     extension_name + " extension.";
+		error_message = ExtensionHelper::AddExtensionInstallHintToErrorMsg(context, error_message, extension_name);
+		return CatalogException(error_message);
 	}
 	// the setting is not in an extension
 	// get a list of all options
@@ -484,16 +507,24 @@ CatalogException Catalog::CreateMissingEntryException(ClientContext &context, co
 		}
 	}
 	// check if the entry exists in any extension
+	string extension_name;
 	if (type == CatalogType::TABLE_FUNCTION_ENTRY || type == CatalogType::SCALAR_FUNCTION_ENTRY ||
-	    type == CatalogType::AGGREGATE_FUNCTION_ENTRY) {
-		auto extension_name = FindExtensionForFunction(entry_name);
-		if (!extension_name.empty()) {
-			return CatalogException(
-			    "Function with name \"%s\" is not in the catalog, but it exists in the %s extension.\n\nTo "
-			    "install and load the extension, run:\nINSTALL %s;\nLOAD %s;",
-			    entry_name, extension_name, extension_name, extension_name);
-		}
+	    type == CatalogType::AGGREGATE_FUNCTION_ENTRY || type == CatalogType::PRAGMA_FUNCTION_ENTRY) {
+		extension_name = ExtensionHelper::FindExtensionInEntries(entry_name, EXTENSION_FUNCTIONS);
+	} else if (type == CatalogType::TYPE_ENTRY) {
+		extension_name = ExtensionHelper::FindExtensionInEntries(entry_name, EXTENSION_TYPES);
+	} else if (type == CatalogType::COPY_FUNCTION_ENTRY) {
+		extension_name = ExtensionHelper::FindExtensionInEntries(entry_name, EXTENSION_COPY_FUNCTIONS);
+	}
+
+	// if we found an extension that can handle this catalog entry, create an error hinting the user
+	if (!extension_name.empty()) {
+		auto error_message = CatalogTypeToString(type) + " with name \"" + entry_name +
+		                     "\" is not in the catalog, but it exists in the " + extension_name + " extension.";
+		error_message = ExtensionHelper::AddExtensionInstallHintToErrorMsg(context, error_message, extension_name);
+		return CatalogException(error_message);
 	}
+
 	auto unseen_entry = SimilarEntryInSchemas(context, entry_name, type, unseen_schemas);
 	string did_you_mean;
 	if (unseen_entry.Found() && unseen_entry.distance < entry.distance) {
@@ -513,22 +544,22 @@ CatalogException Catalog::CreateMissingEntryException(ClientContext &context, co
 	                                                  entry_name, did_you_mean));
 }
 
-CatalogEntryLookup Catalog::LookupEntryInternal(CatalogTransaction transaction, CatalogType type, const string &schema,
-                                                const string &name) {
+CatalogEntryLookup Catalog::TryLookupEntryInternal(CatalogTransaction transaction, CatalogType type,
+                                                   const string &schema, const string &name) {
 	auto schema_entry = GetSchema(transaction, schema, OnEntryNotFound::RETURN_NULL);
 	if (!schema_entry) {
-		return {nullptr, nullptr};
+		return {nullptr, nullptr, PreservedError()};
 	}
 	auto entry = schema_entry->GetEntry(transaction, type, name);
 	if (!entry) {
-		return {schema_entry, nullptr};
+		return {schema_entry, nullptr, PreservedError()};
 	}
-	return {schema_entry, entry};
+	return {schema_entry, entry, PreservedError()};
 }
 
-CatalogEntryLookup Catalog::LookupEntry(ClientContext &context, CatalogType type, const string &schema,
-                                        const string &name, OnEntryNotFound if_not_found,
-                                        QueryErrorContext error_context) {
+CatalogEntryLookup Catalog::TryLookupEntry(ClientContext &context, CatalogType type, const string &schema,
+                                           const string &name, OnEntryNotFound if_not_found,
+                                           QueryErrorContext error_context) {
 	reference_set_t<SchemaCatalogEntry> schemas;
 	if (IsInvalidSchema(schema)) {
 		// try all schemas for this catalog
@@ -536,7 +567,7 @@ CatalogEntryLookup Catalog::LookupEntry(ClientContext &context, CatalogType type
 		for (auto &entry : entries) {
 			auto &candidate_schema = entry.schema;
 			auto transaction = GetCatalogTransaction(context);
-			auto result = LookupEntryInternal(transaction, type, candidate_schema, name);
+			auto result = TryLookupEntryInternal(transaction, type, candidate_schema, name);
 			if (result.Found()) {
 				return result;
 			}
@@ -546,7 +577,7 @@ CatalogEntryLookup Catalog::LookupEntry(ClientContext &context, CatalogType type
 		}
 	} else {
 		auto transaction = GetCatalogTransaction(context);
-		auto result = LookupEntryInternal(transaction, type, schema, name);
+		auto result = TryLookupEntryInternal(transaction, type, schema, name);
 		if (result.Found()) {
 			return result;
 		}
@@ -554,19 +585,34 @@ CatalogEntryLookup Catalog::LookupEntry(ClientContext &context, CatalogType type
 			schemas.insert(*result.schema);
 		}
 	}
+
 	if (if_not_found == OnEntryNotFound::RETURN_NULL) {
-		return {nullptr, nullptr};
+		return {nullptr, nullptr, PreservedError()};
+	} else {
+		auto except = CreateMissingEntryException(context, name, type, schemas, error_context);
+		return {nullptr, nullptr, PreservedError(except)};
 	}
-	throw CreateMissingEntryException(context, name, type, schemas, error_context);
 }
 
-CatalogEntryLookup Catalog::LookupEntry(ClientContext &context, vector<CatalogLookup> &lookups, CatalogType type,
+CatalogEntryLookup Catalog::LookupEntry(ClientContext &context, CatalogType type, const string &schema,
                                         const string &name, OnEntryNotFound if_not_found,
                                         QueryErrorContext error_context) {
+	auto res = TryLookupEntry(context, type, schema, name, if_not_found, error_context);
+
+	if (res.error) {
+		res.error.Throw();
+	}
+
+	return res;
+}
+
+CatalogEntryLookup Catalog::TryLookupEntry(ClientContext &context, vector<CatalogLookup> &lookups, CatalogType type,
+                                           const string &name, OnEntryNotFound if_not_found,
+                                           QueryErrorContext error_context) {
 	reference_set_t<SchemaCatalogEntry> schemas;
 	for (auto &lookup : lookups) {
 		auto transaction = lookup.catalog.GetCatalogTransaction(context);
-		auto result = lookup.catalog.LookupEntryInternal(transaction, type, lookup.schema, name);
+		auto result = lookup.catalog.TryLookupEntryInternal(transaction, type, lookup.schema, name);
 		if (result.Found()) {
 			return result;
 		}
@@ -574,10 +620,33 @@ CatalogEntryLookup Catalog::LookupEntry(ClientContext &context, vector<CatalogLo
 			schemas.insert(*result.schema);
 		}
 	}
+
 	if (if_not_found == OnEntryNotFound::RETURN_NULL) {
-		return {nullptr, nullptr};
+		return {nullptr, nullptr, PreservedError()};
+	} else {
+		auto except = CreateMissingEntryException(context, name, type, schemas, error_context);
+		return {nullptr, nullptr, PreservedError(except)};
 	}
-	throw CreateMissingEntryException(context, name, type, schemas, error_context);
+}
+
+CatalogEntryLookup Catalog::TryLookupEntry(ClientContext &context, CatalogType type, const string &catalog,
+                                           const string &schema, const string &name, OnEntryNotFound if_not_found,
+                                           QueryErrorContext error_context) {
+	auto entries = GetCatalogEntries(context, catalog, schema);
+	vector<CatalogLookup> lookups;
+	lookups.reserve(entries.size());
+	for (auto &entry : entries) {
+		if (if_not_found == OnEntryNotFound::RETURN_NULL) {
+			auto catalog_entry = Catalog::GetCatalogEntry(context, entry.catalog);
+			if (!catalog_entry) {
+				return {nullptr, nullptr, PreservedError()};
+			}
+			lookups.emplace_back(*catalog_entry, entry.schema);
+		} else {
+			lookups.emplace_back(Catalog::GetCatalog(context, entry.catalog), entry.schema);
+		}
+	}
+	return Catalog::TryLookupEntry(context, lookups, type, name, if_not_found, error_context);
 }
 
 CatalogEntry &Catalog::GetEntry(ClientContext &context, const string &schema, const string &name) {
@@ -596,7 +665,20 @@ CatalogEntry &Catalog::GetEntry(ClientContext &context, const string &schema, co
 optional_ptr<CatalogEntry> Catalog::GetEntry(ClientContext &context, CatalogType type, const string &schema_name,
                                              const string &name, OnEntryNotFound if_not_found,
                                              QueryErrorContext error_context) {
-	return LookupEntry(context, type, schema_name, name, if_not_found, error_context).entry.get();
+	auto lookup_entry = TryLookupEntry(context, type, schema_name, name, if_not_found, error_context);
+
+	// Try autoloading extension to resolve lookup
+	if (!lookup_entry.Found()) {
+		if (AutoLoadExtensionByCatalogEntry(context, type, name)) {
+			lookup_entry = TryLookupEntry(context, type, schema_name, name, if_not_found, error_context);
+		}
+	}
+
+	if (lookup_entry.error) {
+		lookup_entry.error.Throw();
+	}
+
+	return lookup_entry.entry.get();
 }
 
 CatalogEntry &Catalog::GetEntry(ClientContext &context, CatalogType type, const string &schema, const string &name,
@@ -607,21 +689,19 @@ CatalogEntry &Catalog::GetEntry(ClientContext &context, CatalogType type, const
 optional_ptr<CatalogEntry> Catalog::GetEntry(ClientContext &context, CatalogType type, const string &catalog,
                                              const string &schema, const string &name, OnEntryNotFound if_not_found,
                                              QueryErrorContext error_context) {
-	auto entries = GetCatalogEntries(context, catalog, schema);
-	vector<CatalogLookup> lookups;
-	lookups.reserve(entries.size());
-	for (auto &entry : entries) {
-		if (if_not_found == OnEntryNotFound::RETURN_NULL) {
-			auto catalog_entry = Catalog::GetCatalogEntry(context, entry.catalog);
-			if (!catalog_entry) {
-				return nullptr;
-			}
-			lookups.emplace_back(*catalog_entry, entry.schema);
-		} else {
-			lookups.emplace_back(Catalog::GetCatalog(context, entry.catalog), entry.schema);
+	auto result = TryLookupEntry(context, type, catalog, schema, name, if_not_found, error_context);
+
+	// Try autoloading extension to resolve lookup
+	if (!result.Found()) {
+		if (AutoLoadExtensionByCatalogEntry(context, type, name)) {
+			result = TryLookupEntry(context, type, catalog, schema, name, if_not_found, error_context);
 		}
 	}
-	auto result = LookupEntry(context, lookups, type, name, if_not_found, error_context);
+
+	if (result.error) {
+		result.error.Throw();
+	}
+
 	if (!result.Found()) {
 		D_ASSERT(if_not_found == OnEntryNotFound::RETURN_NULL);
 		return nullptr;
@@ -724,6 +804,7 @@ vector<reference<SchemaCatalogEntry>> Catalog::GetAllSchemas(ClientContext &cont
 void Catalog::Alter(ClientContext &context, AlterInfo &info) {
 	ModifyCatalog();
 	auto lookup = LookupEntry(context, info.GetCatalogType(), info.schema, info.name, info.if_not_found);
+
 	if (!lookup.Found()) {
 		return;
 	}

package/src/duckdb/src/common/exception.cpp

@@ -158,8 +158,12 @@ string Exception::ExceptionTypeToString(ExceptionType type) {
 		return "Parameter Not Allowed";
 	case ExceptionType::DEPENDENCY:
 		return "Dependency";
+	case ExceptionType::MISSING_EXTENSION:
+		return "Missing Extension";
 	case ExceptionType::HTTP:
 		return "HTTP";
+	case ExceptionType::AUTOLOAD:
+		return "Extension Autoloading";
 	default:
 		return "Unknown";
 	}
@@ -225,6 +229,8 @@ void Exception::ThrowAsTypeWithMessage(ExceptionType type, const string &message
 	case ExceptionType::HTTP: {
 		original->AsHTTPException().Throw();
 	}
+	case ExceptionType::MISSING_EXTENSION:
+		throw MissingExtensionException(message);
 	default:
 		throw Exception(type, message);
 	}
@@ -347,6 +353,13 @@ MissingExtensionException::MissingExtensionException(const string &msg)
     : Exception(ExceptionType::MISSING_EXTENSION, msg) {
 }
 
+AutoloadException::AutoloadException(const string &extension_name, Exception &e)
+    : Exception(ExceptionType::AUTOLOAD,
+                "An error occured while trying to automatically install the required extension '" + extension_name +
+                    "':\n" + e.RawMessage()),
+      wrapped_exception(e) {
+}
+
 SerializationException::SerializationException(const string &msg) : Exception(ExceptionType::SERIALIZATION, msg) {
 }
 

package/src/duckdb/src/common/file_system.cpp

@@ -397,16 +397,31 @@ bool FileSystem::CanHandleFile(const string &fpath) {
 	throw NotImplementedException("%s: CanHandleFile is not implemented!", GetName());
 }
 
+static string LookupExtensionForPattern(const string &pattern) {
+	for (const auto &entry : EXTENSION_FILE_PREFIXES) {
+		if (StringUtil::StartsWith(pattern, entry.name)) {
+			return entry.extension;
+		}
+	}
+	return "";
+}
+
 vector<string> FileSystem::GlobFiles(const string &pattern, ClientContext &context, FileGlobOptions options) {
 	auto result = Glob(pattern);
 	if (result.empty()) {
-		string required_extension;
-		if (FileSystem::IsRemoteFile(pattern)) {
-			required_extension = "httpfs";
-		}
+		string required_extension = LookupExtensionForPattern(pattern);
 		if (!required_extension.empty() && !context.db->ExtensionIsLoaded(required_extension)) {
-			// an extension is required to read this file but it is not loaded - try to load it
-			ExtensionHelper::LoadExternalExtension(context, required_extension);
+			auto &dbconfig = DBConfig::GetConfig(context);
+			if (!ExtensionHelper::CanAutoloadExtension(required_extension) ||
+			    !dbconfig.options.autoload_known_extensions) {
+				auto error_message =
+				    "File " + pattern + " requires the extension " + required_extension + " to be loaded";
+				error_message =
+				    ExtensionHelper::AddExtensionInstallHintToErrorMsg(context, error_message, required_extension);
+				throw MissingExtensionException(error_message);
+			}
+			// an extension is required to read this file, but it is not loaded - try to load it
+			ExtensionHelper::AutoLoadExtension(context, required_extension);
 			// success! glob again
 			// check the extension is loaded just in case to prevent an infinite loop here
 			if (!context.db->ExtensionIsLoaded(required_extension)) {

package/src/duckdb/src/core_functions/scalar/enum/enum_functions.cpp

@@ -3,24 +3,27 @@
 namespace duckdb {
 
 static void EnumFirstFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	D_ASSERT(input.GetTypes().size() == 1);
-	auto &enum_vector = EnumType::GetValuesInsertOrder(input.GetTypes()[0]);
+	auto types = input.GetTypes();
+	D_ASSERT(types.size() == 1);
+	auto &enum_vector = EnumType::GetValuesInsertOrder(types[0]);
 	auto val = Value(enum_vector.GetValue(0));
 	result.Reference(val);
 }
 
 static void EnumLastFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	D_ASSERT(input.GetTypes().size() == 1);
-	auto enum_size = EnumType::GetSize(input.GetTypes()[0]);
-	auto &enum_vector = EnumType::GetValuesInsertOrder(input.GetTypes()[0]);
+	auto types = input.GetTypes();
+	D_ASSERT(types.size() == 1);
+	auto enum_size = EnumType::GetSize(types[0]);
+	auto &enum_vector = EnumType::GetValuesInsertOrder(types[0]);
 	auto val = Value(enum_vector.GetValue(enum_size - 1));
 	result.Reference(val);
 }
 
 static void EnumRangeFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	D_ASSERT(input.GetTypes().size() == 1);
-	auto enum_size = EnumType::GetSize(input.GetTypes()[0]);
-	auto &enum_vector = EnumType::GetValuesInsertOrder(input.GetTypes()[0]);
+	auto types = input.GetTypes();
+	D_ASSERT(types.size() == 1);
+	auto enum_size = EnumType::GetSize(types[0]);
+	auto &enum_vector = EnumType::GetValuesInsertOrder(types[0]);
 	vector<Value> enum_values;
 	for (idx_t i = 0; i < enum_size; i++) {
 		enum_values.emplace_back(enum_vector.GetValue(i));
@@ -30,13 +33,14 @@ static void EnumRangeFunction(DataChunk &input, ExpressionState &state, Vector &
 }
 
 static void EnumRangeBoundaryFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	D_ASSERT(input.GetTypes().size() == 2);
+	auto types = input.GetTypes();
+	D_ASSERT(types.size() == 2);
 	idx_t start, end;
 	auto first_param = input.GetValue(0, 0);
 	auto second_param = input.GetValue(1, 0);
 
-	auto &enum_vector = first_param.IsNull() ? EnumType::GetValuesInsertOrder(input.GetTypes()[1])
-	                                         : EnumType::GetValuesInsertOrder(input.GetTypes()[0]);
+	auto &enum_vector =
+	    first_param.IsNull() ? EnumType::GetValuesInsertOrder(types[1]) : EnumType::GetValuesInsertOrder(types[0]);
 
 	if (first_param.IsNull()) {
 		start = 0;
@@ -44,7 +48,7 @@ static void EnumRangeBoundaryFunction(DataChunk &input, ExpressionState &state,
 		start = first_param.GetValue<uint32_t>();
 	}
 	if (second_param.IsNull()) {
-		end = EnumType::GetSize(input.GetTypes()[0]);
+		end = EnumType::GetSize(types[0]);
 	} else {
 		end = second_param.GetValue<uint32_t>() + 1;
 	}

package/src/duckdb/src/core_functions/scalar/generic/current_setting.cpp

@@ -51,7 +51,9 @@ unique_ptr<FunctionData> CurrentSettingBind(ClientContext &context, ScalarFuncti
 	auto key = StringUtil::Lower(key_str);
 	Value val;
 	if (!context.TryGetCurrentSetting(key, val)) {
-		throw Catalog::UnrecognizedConfigurationError(context, key);
+		Catalog::AutoloadExtensionByConfigName(context, key);
+		// If autoloader didn't throw, the config is now available
+		context.TryGetCurrentSetting(key, val);
 	}
 
 	bound_function.return_type = val.type();

package/src/duckdb/src/execution/operator/helper/physical_load.cpp

@@ -5,7 +5,8 @@ namespace duckdb {
 
 SourceResultType PhysicalLoad::GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const {
 	if (info->load_type == LoadType::INSTALL || info->load_type == LoadType::FORCE_INSTALL) {
-		ExtensionHelper::InstallExtension(context.client, info->filename, info->load_type == LoadType::FORCE_INSTALL);
+		ExtensionHelper::InstallExtension(context.client, info->filename, info->load_type == LoadType::FORCE_INSTALL,
+		                                  info->repository);
 	} else {
 		ExtensionHelper::LoadExternalExtension(context.client, info->filename);
 	}

package/src/duckdb/src/execution/operator/helper/physical_reset.cpp

@@ -30,7 +30,9 @@ SourceResultType PhysicalReset::GetData(ExecutionContext &context, DataChunk &ch
 		// check if this is an extra extension variable
 		auto entry = config.extension_parameters.find(name);
 		if (entry == config.extension_parameters.end()) {
-			throw Catalog::UnrecognizedConfigurationError(context.client, name);
+			Catalog::AutoloadExtensionByConfigName(context.client, name);
+			entry = config.extension_parameters.find(name);
+			D_ASSERT(entry != config.extension_parameters.end());
 		}
 		ResetExtensionVariable(context, config, entry->second);
 		return SourceResultType::FINISHED;

package/src/duckdb/src/execution/operator/helper/physical_set.cpp

@@ -33,7 +33,9 @@ SourceResultType PhysicalSet::GetData(ExecutionContext &context, DataChunk &chun
 		// check if this is an extra extension variable
 		auto entry = config.extension_parameters.find(name);
 		if (entry == config.extension_parameters.end()) {
-			throw Catalog::UnrecognizedConfigurationError(context.client, name);
+			Catalog::AutoloadExtensionByConfigName(context.client, name);
+			entry = config.extension_parameters.find(name);
+			D_ASSERT(entry != config.extension_parameters.end());
 		}
 		SetExtensionVariable(context.client, entry->second, name, scope, value);
 		return SourceResultType::FINISHED;

package/src/duckdb/src/function/pragma/pragma_queries.cpp

@@ -123,7 +123,8 @@ string PragmaShow(ClientContext &context, const FunctionParameters &parameters)
 	LEFT JOIN duckdb_columns cols 
 	ON cols.column_name = pragma_table_info.name 
 	AND cols.table_name='%table_name%'
-	AND cols.schema_name='%table_schema%';)";
+	AND cols.schema_name='%table_schema%'
+	ORDER BY column_index;)";
 	// clang-format on
 
 	sql = StringUtil::Replace(sql, "%func_param_table%", parameters.values[0].ToString());

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

@@ -325,9 +325,6 @@ public:
 			file_handle->ReadLine();
 		}
 		first_position = current_csv_position;
-		current_buffer = make_shared<CSVBuffer>(context, buffer_size, *file_handle, current_csv_position, file_number);
-		next_buffer = shared_ptr<CSVBuffer>(
-		    current_buffer->Next(*file_handle, buffer_size, current_csv_position, file_number).release());
 		running_threads = MaxThreads();
 
 		// Initialize all the book-keeping variables
@@ -441,6 +438,8 @@ private:
 	vector<column_t> column_ids;
 	//! Line Info used in error messages
 	LineInfo line_info;
+	//! Have we initialized our reading
+	bool initialized = false;
 };
 
 idx_t ParallelCSVGlobalState::MaxThreads() const {
@@ -543,6 +542,12 @@ void LineInfo::Verify(idx_t file_idx, idx_t batch_idx, idx_t cur_first_pos) {
 bool ParallelCSVGlobalState::Next(ClientContext &context, const ReadCSVData &bind_data,
                                   unique_ptr<ParallelCSVReader> &reader) {
 	lock_guard<mutex> parallel_lock(main_mutex);
+	if (!initialized && file_handle) {
+		current_buffer = make_shared<CSVBuffer>(context, buffer_size, *file_handle, current_csv_position, file_number);
+		next_buffer = shared_ptr<CSVBuffer>(
+		    current_buffer->Next(*file_handle, buffer_size, current_csv_position, file_number).release());
+		initialized = true;
+	}
 	if (!current_buffer) {
 		// This means we are done with the current file, we need to go to the next one (if exists).
 		if (file_index < bind_data.files.size()) {

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

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.8.2-dev3300"
+#define DUCKDB_VERSION "0.8.2-dev3456"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "26931f7ac6"
+#define DUCKDB_SOURCE_ID "44fec4a812"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/include/duckdb/catalog/catalog.hpp

@@ -301,18 +301,33 @@ public:
 
 	static CatalogException UnrecognizedConfigurationError(ClientContext &context, const string &name);
 
+	//! Autoload the extension required for `configuration_name` or throw a CatalogException
+	static void AutoloadExtensionByConfigName(ClientContext &context, const string &configuration_name);
+	//! Autoload the extension required for `function_name` or throw a CatalogException
+	static bool AutoLoadExtensionByCatalogEntry(ClientContext &context, CatalogType type, const string &entry_name);
+
 protected:
 	//! Reference to the database
 	AttachedDatabase &db;
 
 private:
-	CatalogEntryLookup LookupEntryInternal(CatalogTransaction transaction, CatalogType type, const string &schema,
-	                                       const string &name);
+	//! Lookup an entry in the schema, returning a lookup with the entry and schema if they exist
+	CatalogEntryLookup TryLookupEntryInternal(CatalogTransaction transaction, CatalogType type, const string &schema,
+	                                          const string &name);
+	//! Calls LookupEntryInternal on the schema, trying other schemas if the schema is invalid. Sets
+	//! CatalogEntryLookup->error depending on if_not_found when no entry is found
+	CatalogEntryLookup TryLookupEntry(ClientContext &context, CatalogType type, const string &schema,
+	                                  const string &name, OnEntryNotFound if_not_found,
+	                                  QueryErrorContext error_context = QueryErrorContext());
+	//! Lookup an entry using TryLookupEntry, throws if entry not found and if_not_found == THROW_EXCEPTION
 	CatalogEntryLookup LookupEntry(ClientContext &context, CatalogType type, const string &schema, const string &name,
 	                               OnEntryNotFound if_not_found, QueryErrorContext error_context = QueryErrorContext());
-	static CatalogEntryLookup LookupEntry(ClientContext &context, vector<CatalogLookup> &lookups, CatalogType type,
-	                                      const string &name, OnEntryNotFound if_not_found,
-	                                      QueryErrorContext error_context = QueryErrorContext());
+	static CatalogEntryLookup TryLookupEntry(ClientContext &context, vector<CatalogLookup> &lookups, CatalogType type,
+	                                         const string &name, OnEntryNotFound if_not_found,
+	                                         QueryErrorContext error_context = QueryErrorContext());
+	static CatalogEntryLookup TryLookupEntry(ClientContext &context, CatalogType type, const string &catalog,
+	                                         const string &schema, const string &name, OnEntryNotFound if_not_found,
+	                                         QueryErrorContext error_context);
 
 	//! Return an exception with did-you-mean suggestion.
 	static CatalogException CreateMissingEntryException(ClientContext &context, const string &entry_name,