duckdb 0.6.2-dev971.0 → 0.7.1-dev2.0

package/src/duckdb/src/main/connection.cpp

@@ -74,7 +74,7 @@ unique_ptr<QueryResult> Connection::SendQuery(const string &query) {
 unique_ptr<MaterializedQueryResult> Connection::Query(const string &query) {
 	auto result = context->Query(query, false);
 	D_ASSERT(result->type == QueryResultType::MATERIALIZED_RESULT);
-	return unique_ptr_cast<QueryResult, MaterializedQueryResult>(move(result));
+	return unique_ptr_cast<QueryResult, MaterializedQueryResult>(std::move(result));
 }
 
 DUCKDB_API string Connection::GetSubstrait(const string &query) {
@@ -106,9 +106,9 @@ DUCKDB_API unique_ptr<QueryResult> Connection::FromSubstraitJSON(const string &j
 }
 
 unique_ptr<MaterializedQueryResult> Connection::Query(unique_ptr<SQLStatement> statement) {
-	auto result = context->Query(move(statement), false);
+	auto result = context->Query(std::move(statement), false);
 	D_ASSERT(result->type == QueryResultType::MATERIALIZED_RESULT);
-	return unique_ptr_cast<QueryResult, MaterializedQueryResult>(move(result));
+	return unique_ptr_cast<QueryResult, MaterializedQueryResult>(std::move(result));
 }
 
 unique_ptr<PendingQueryResult> Connection::PendingQuery(const string &query, bool allow_stream_result) {
@@ -116,7 +116,7 @@ unique_ptr<PendingQueryResult> Connection::PendingQuery(const string &query, boo
 }
 
 unique_ptr<PendingQueryResult> Connection::PendingQuery(unique_ptr<SQLStatement> statement, bool allow_stream_result) {
-	return context->PendingQuery(move(statement), allow_stream_result);
+	return context->PendingQuery(std::move(statement), allow_stream_result);
 }
 
 unique_ptr<PreparedStatement> Connection::Prepare(const string &query) {
@@ -124,7 +124,7 @@ unique_ptr<PreparedStatement> Connection::Prepare(const string &query) {
 }
 
 unique_ptr<PreparedStatement> Connection::Prepare(unique_ptr<SQLStatement> statement) {
-	return context->Prepare(move(statement));
+	return context->Prepare(std::move(statement));
 }
 
 unique_ptr<QueryResult> Connection::QueryParamsRecursive(const string &query, vector<Value> &values) {
@@ -173,7 +173,7 @@ shared_ptr<Relation> Connection::Table(const string &schema_name, const string &
 	if (!table_info) {
 		throw CatalogException("Table '%s' does not exist!", table_name);
 	}
-	return make_shared<TableRelation>(context, move(table_info));
+	return make_shared<TableRelation>(context, std::move(table_info));
 }
 
 shared_ptr<Relation> Connection::View(const string &tname) {
@@ -220,14 +220,13 @@ shared_ptr<Relation> Connection::Values(const string &values, const vector<strin
 
 shared_ptr<Relation> Connection::ReadCSV(const string &csv_file) {
 	BufferedCSVReaderOptions options;
+	return ReadCSV(csv_file, options);
+}
+
+shared_ptr<Relation> Connection::ReadCSV(const string &csv_file, BufferedCSVReaderOptions &options) {
 	options.file_path = csv_file;
 	options.auto_detect = true;
-	BufferedCSVReader reader(*context, options);
-	vector<ColumnDefinition> column_list;
-	for (idx_t i = 0; i < reader.sql_types.size(); i++) {
-		column_list.emplace_back(reader.col_names[i], reader.sql_types[i]);
-	}
-	return make_shared<ReadCSVRelation>(context, csv_file, move(column_list), true);
+	return make_shared<ReadCSVRelation>(context, csv_file, options);
 }
 
 shared_ptr<Relation> Connection::ReadCSV(const string &csv_file, const vector<string> &columns) {
@@ -238,9 +237,9 @@ shared_ptr<Relation> Connection::ReadCSV(const string &csv_file, const vector<st
 		if (col_list.LogicalColumnCount() != 1) {
 			throw ParserException("Expected a single column definition");
 		}
-		column_list.push_back(move(col_list.GetColumnMutable(LogicalIndex(0))));
+		column_list.push_back(std::move(col_list.GetColumnMutable(LogicalIndex(0))));
 	}
-	return make_shared<ReadCSVRelation>(context, csv_file, move(column_list));
+	return make_shared<ReadCSVRelation>(context, csv_file, std::move(column_list));
 }
 
 shared_ptr<Relation> Connection::ReadParquet(const string &parquet_file, bool binary_as_string) {
@@ -259,7 +258,7 @@ shared_ptr<Relation> Connection::RelationFromQuery(const string &query, const st
 }
 
 shared_ptr<Relation> Connection::RelationFromQuery(unique_ptr<SelectStatement> select_stmt, const string &alias) {
-	return make_shared<QueryRelation>(context, move(select_stmt), alias);
+	return make_shared<QueryRelation>(context, std::move(select_stmt), alias);
 }
 
 void Connection::BeginTransaction() {

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

@@ -11,10 +11,13 @@
 #include "duckdb/main/connection_manager.hpp"
 #include "duckdb/function/compression_function.hpp"
 #include "duckdb/main/extension_helper.hpp"
-#include "duckdb/main/replacement_opens.hpp"
 #include "duckdb/function/cast/cast_function_set.hpp"
 #include "duckdb/main/error_manager.hpp"
 #include "duckdb/main/attached_database.hpp"
+#include "duckdb/parser/parsed_data/attach_info.hpp"
+#include "duckdb/storage/magic_bytes.hpp"
+#include "duckdb/storage/storage_extension.hpp"
+#include "duckdb/execution/operator/helper/physical_set.hpp"
 
 #ifndef DUCKDB_NO_THREADS
 #include "duckdb/common/thread.hpp"
@@ -24,7 +27,6 @@ namespace duckdb {
 
 DBConfig::DBConfig() {
 	compression_functions = make_unique<CompressionFunctionSet>();
-	replacement_opens.push_back(ExtensionPrefixReplacementOpen());
 	cast_functions = make_unique<CastFunctionSet>();
 	error_manager = make_unique<ErrorManager>();
 }
@@ -36,12 +38,8 @@ DBConfig::DBConfig(std::unordered_map<string, string> &config_dict, bool read_on
 	for (auto &kv : config_dict) {
 		string key = kv.first;
 		string val = kv.second;
-		auto config_property = DBConfig::GetOptionByName(key);
-		if (!config_property) {
-			throw InvalidInputException("Unrecognized configuration property \"%s\"", key);
-		}
 		auto opt_val = Value(val);
-		DBConfig::SetOption(*config_property, opt_val);
+		DBConfig::SetOptionByName(key, opt_val);
 	}
 }
 
@@ -121,6 +119,42 @@ ConnectionManager &ConnectionManager::Get(ClientContext &context) {
 	return ConnectionManager::Get(DatabaseInstance::GetDatabase(context));
 }
 
+string DatabaseInstance::ExtractDatabaseType(string &path) {
+	// first check if there is an existing prefix
+	auto extension = ExtensionHelper::ExtractExtensionPrefixFromPath(path);
+	if (!extension.empty()) {
+		// path is prefixed with an extension - remove it
+		path = StringUtil::Replace(path, extension + ":", "");
+		return extension;
+	}
+	// if there isn't - check the magic bytes of the file (if any)
+	auto file_type = MagicBytes::CheckMagicBytes(config.file_system.get(), path);
+	if (file_type == DataFileType::SQLITE_FILE) {
+		return "sqlite";
+	}
+	return string();
+}
+
+unique_ptr<AttachedDatabase> DatabaseInstance::CreateAttachedDatabase(AttachInfo &info, const string &type,
+                                                                      AccessMode access_mode) {
+	unique_ptr<AttachedDatabase> attached_database;
+	if (!type.empty()) {
+		// find the storage extensionon database
+		auto entry = config.storage_extensions.find(type);
+		if (entry == config.storage_extensions.end()) {
+			throw BinderException("Unrecognized storage type \"%s\"", type);
+		}
+		// use storage extension to create the initial database
+		attached_database = make_unique<AttachedDatabase>(*this, Catalog::GetSystemCatalog(*this), *entry->second,
+		                                                  info.name, info, access_mode);
+	} else {
+		// check if this is an in-memory database or not
+		attached_database =
+		    make_unique<AttachedDatabase>(*this, Catalog::GetSystemCatalog(*this), info.name, info.path, access_mode);
+	}
+	return attached_database;
+}
+
 void DatabaseInstance::Initialize(const char *database_path, DBConfig *user_config) {
 	DBConfig default_config;
 	DBConfig *config_ptr = &default_config;
@@ -143,15 +177,6 @@ void DatabaseInstance::Initialize(const char *database_path, DBConfig *user_conf
 	} else {
 		config_ptr->options.database_path.clear();
 	}
-
-	for (auto &open : config_ptr->replacement_opens) {
-		if (open.pre_func) {
-			open.data = open.pre_func(*config_ptr, open.static_data.get());
-			if (open.data) {
-				break;
-			}
-		}
-	}
 	Configure(*config_ptr);
 
 	if (user_config && !user_config->options.use_temporary_directory) {
@@ -159,7 +184,6 @@ void DatabaseInstance::Initialize(const char *database_path, DBConfig *user_conf
 		config.options.temporary_directory = string();
 	}
 
-	auto &config = DBConfig::GetConfig(*this);
 	db_manager = make_unique<DatabaseManager>(*this);
 	buffer_manager =
 	    make_unique<BufferManager>(*this, config.options.temporary_directory, config.options.maximum_memory);
@@ -167,14 +191,21 @@ void DatabaseInstance::Initialize(const char *database_path, DBConfig *user_conf
 	object_cache = make_unique<ObjectCache>();
 	connection_manager = make_unique<ConnectionManager>();
 
-	auto database_name = AttachedDatabase::ExtractDatabaseName(config.options.database_path);
-	auto attached_database = make_unique<AttachedDatabase>(*this, Catalog::GetSystemCatalog(*this), database_name,
-	                                                       config.options.database_path, config.options.access_mode);
+	// 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, move(attached_database));
+		db_manager->AddDatabase(*con.context, std::move(attached_database));
 		con.Commit();
 	}
 
@@ -183,15 +214,34 @@ void DatabaseInstance::Initialize(const char *database_path, DBConfig *user_conf
 	// initialize the database
 	initial_database->Initialize();
 
-	// only increase thread count after storage init because we get races on catalog otherwise
-	scheduler->SetThreads(config.options.maximum_threads);
+	if (!database_type.empty()) {
+		// if we are opening an extension database - load the extension
+		ExtensionHelper::LoadExternalExtension(*this, nullptr, database_type);
+	}
+
+	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);
+			}
+		}
 
-	for (auto &open : config.replacement_opens) {
-		if (open.post_func && open.data) {
-			open.post_func(*this, open.data.get());
-			break;
+		// 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();
 	}
+
+	// only increase thread count after storage init because we get races on catalog otherwise
+	scheduler->SetThreads(config.options.maximum_threads);
 }
 
 DuckDB::DuckDB(const char *path, DBConfig *new_config) : instance(make_shared<DatabaseInstance>()) {
@@ -260,7 +310,7 @@ void DatabaseInstance::Configure(DBConfig &new_config) {
 		config.options.access_mode = AccessMode::READ_WRITE;
 	}
 	if (new_config.file_system) {
-		config.file_system = move(new_config.file_system);
+		config.file_system = std::move(new_config.file_system);
 	} else {
 		config.file_system = make_unique<VirtualFileSystem>();
 	}
@@ -270,14 +320,13 @@ void DatabaseInstance::Configure(DBConfig &new_config) {
 	if (new_config.options.maximum_threads == (idx_t)-1) {
 		config.SetDefaultMaxThreads();
 	}
-	config.allocator = move(new_config.allocator);
+	config.allocator = std::move(new_config.allocator);
 	if (!config.allocator) {
 		config.allocator = make_unique<Allocator>();
 	}
-	config.replacement_scans = move(new_config.replacement_scans);
-	config.replacement_opens = move(new_config.replacement_opens);
-	config.parser_extensions = move(new_config.parser_extensions);
-	config.error_manager = move(new_config.error_manager);
+	config.replacement_scans = std::move(new_config.replacement_scans);
+	config.parser_extensions = std::move(new_config.parser_extensions);
+	config.error_manager = std::move(new_config.error_manager);
 	if (!config.error_manager) {
 		config.error_manager = make_unique<ErrorManager>();
 	}
@@ -306,9 +355,14 @@ idx_t DuckDB::NumberOfThreads() {
 	return instance->NumberOfThreads();
 }
 
+bool DatabaseInstance::ExtensionIsLoaded(const std::string &name) {
+	return loaded_extensions.find(name) != loaded_extensions.end();
+}
+
 bool DuckDB::ExtensionIsLoaded(const std::string &name) {
-	return instance->loaded_extensions.find(name) != instance->loaded_extensions.end();
+	return instance->ExtensionIsLoaded(name);
 }
+
 void DatabaseInstance::SetExtensionLoaded(const std::string &name) {
 	loaded_extensions.insert(name);
 }

package/src/duckdb/src/main/database_manager.cpp

@@ -32,11 +32,12 @@ AttachedDatabase *DatabaseManager::GetDatabase(ClientContext &context, const str
 
 void DatabaseManager::AddDatabase(ClientContext &context, unique_ptr<AttachedDatabase> db_instance) {
 	auto name = db_instance->GetName();
+	db_instance->oid = ModifyCatalog();
 	DependencyList dependencies;
 	if (default_database.empty()) {
 		default_database = name;
 	}
-	if (!databases->CreateEntry(context, name, move(db_instance), dependencies)) {
+	if (!databases->CreateEntry(context, name, std::move(db_instance), dependencies)) {
 		throw BinderException("Failed to attach database: database with name \"%s\" already exists", name);
 	}
 }
@@ -55,11 +56,12 @@ AttachedDatabase *DatabaseManager::GetDatabaseFromPath(ClientContext &context, c
 		if (db->IsSystem()) {
 			continue;
 		}
-		auto &storage = db->GetStorageManager();
-		if (storage.InMemory()) {
+		auto &catalog = Catalog::GetCatalog(*db);
+		if (catalog.InMemory()) {
 			continue;
 		}
-		if (StringUtil::CIEquals(path, storage.GetDBPath())) {
+		auto db_path = catalog.GetDBPath();
+		if (StringUtil::CIEquals(path, db_path)) {
 			return db;
 		}
 	}

package/src/duckdb/src/main/error_manager.cpp

@@ -56,7 +56,7 @@ string ErrorManager::InvalidUnicodeError(const string &input, const string &cont
 }
 
 void ErrorManager::AddCustomError(ErrorType type, string new_error) {
-	custom_errors.insert(make_pair(type, move(new_error)));
+	custom_errors.insert(make_pair(type, std::move(new_error)));
 }
 
 ErrorManager &ErrorManager::Get(ClientContext &context) {

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

@@ -4,6 +4,7 @@ namespace duckdb {
 
 static ExtensionAlias internal_aliases[] = {{"http", "httpfs"}, // httpfs
                                             {"https", "httpfs"},
+                                            {"md", "motherduck"}, // motherduck
                                             {"s3", "httpfs"},
                                             {"postgres", "postgres_scanner"}, // postgres
                                             {"sqlite", "sqlite_scanner"},     // sqlite

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

@@ -78,6 +78,11 @@
 #include "inet-extension.hpp"
 #endif
 
+// Load the generated header file containing our list of extension headers
+#if defined(OOTE_HEADERS_AVAILABLE) && OOTE_HEADERS_AVAILABLE
+#include "extension_oote_loader.hpp"
+#endif
+
 namespace duckdb {
 
 //===--------------------------------------------------------------------===//
@@ -92,6 +97,7 @@ static DefaultExtension internal_extensions[] = {
     {"httpfs", "Adds support for reading and writing files over a HTTP(S) connection", HTTPFS_STATICALLY_LOADED},
     {"json", "Adds support for JSON operations", JSON_STATICALLY_LOADED},
     {"jemalloc", "Overwrites system allocator with JEMalloc", JEMALLOC_STATICALLY_LOADED},
+    {"motherduck", "Enables motherduck integration with the system", false},
     {"sqlite_scanner", "Adds support for reading SQLite database files", false},
     {"postgres_scanner", "Adds support for reading from a Postgres database", false},
     {"inet", "Adds support for IP-related data types and functions", false},
@@ -118,6 +124,12 @@ void ExtensionHelper::LoadAllExtensions(DuckDB &db) {
 	for (auto &ext : extensions) {
 		LoadExtensionInternal(db, ext, true);
 	}
+
+#if defined(OOTE_HEADERS_AVAILABLE) && OOTE_HEADERS_AVAILABLE
+	for (auto &ext : OOT_EXTENSIONS) {
+		LoadExtensionInternal(db, ext, true);
+	}
+#endif
 }
 
 ExtensionLoadResult ExtensionHelper::LoadExtension(DuckDB &db, const std::string &extension) {
@@ -226,7 +238,12 @@ ExtensionLoadResult ExtensionHelper::LoadExtensionInternal(DuckDB &db, const std
 		return ExtensionLoadResult::NOT_LOADED;
 #endif
 	} else {
-		// unknown extension
+
+#if defined(OOTE_HEADERS_AVAILABLE) && OOTE_HEADERS_AVAILABLE
+		if (TryLoadLinkedExtension(db, extension)) {
+			return ExtensionLoadResult::LOADED_EXTENSION;
+		}
+#endif
 		return ExtensionLoadResult::EXTENSION_UNKNOWN;
 	}
 	return ExtensionLoadResult::LOADED_EXTENSION;

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

@@ -120,7 +120,12 @@ void ExtensionHelper::InstallExtension(ClientContext &context, const string &ext
 #ifdef DISABLE_DUCKDB_REMOTE_INSTALL
 	throw BinderException("Remote extension installation is disabled through configuration");
 #else
-	string url_template = "http://extensions.duckdb.org/${REVISION}/${PLATFORM}/${NAME}.duckdb_extension.gz";
+
+	string default_endpoint = "http://extensions.duckdb.org";
+	string versioned_path = "/${REVISION}/${PLATFORM}/${NAME}.duckdb_extension.gz";
+	string &custom_endpoint = ClientConfig::GetConfig(context).custom_extension_repo;
+	string &endpoint = !custom_endpoint.empty() ? custom_endpoint : default_endpoint;
+	string url_template = endpoint + versioned_path;
 
 	if (is_http_url) {
 		url_template = extension;

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

@@ -1,6 +1,5 @@
 #include "duckdb/common/dl.hpp"
 #include "duckdb/common/virtual_file_system.hpp"
-#include "duckdb/function/replacement_open.hpp"
 #include "duckdb/main/extension_helper.hpp"
 #include "duckdb/main/error_manager.hpp"
 #include "mbedtls_wrapper.hpp"
@@ -12,6 +11,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 &);
 
 template <class T>
 static T LoadFunctionFromDLL(void *dll, const string &function_name, const string &filename) {
@@ -121,14 +121,13 @@ ExtensionInitResult ExtensionHelper::InitialLoad(DBConfig &config, FileOpener *o
 	return res;
 }
 
-void ExtensionHelper::LoadExternalExtension(ClientContext &context, const string &extension) {
-	auto &db = DatabaseInstance::GetDatabase(context);
+void ExtensionHelper::LoadExternalExtension(DatabaseInstance &db, FileOpener *opener, const string &extension) {
 	auto &loaded_extensions = db.LoadedExtensions();
 	if (loaded_extensions.find(extension) != loaded_extensions.end()) {
 		return;
 	}
 
-	auto res = InitialLoad(DBConfig::GetConfig(context), FileSystem::GetFileOpener(context), extension);
+	auto res = InitialLoad(DBConfig::GetConfig(db), opener, extension);
 	auto init_fun_name = res.basename + "_init";
 
 	ext_init_fun_t init_fun;
@@ -141,38 +140,27 @@ void ExtensionHelper::LoadExternalExtension(ClientContext &context, const string
 		                            init_fun_name, res.filename, e.what());
 	}
 
-	DatabaseInstance::GetDatabase(context).SetExtensionLoaded(extension);
+	db.SetExtensionLoaded(extension);
 }
 
-unique_ptr<ReplacementOpenData> ExtensionHelper::ReplacementOpenPre(const string &extension, DBConfig &config) {
-
-	auto res = InitialLoad(config, nullptr, extension); // TODO opener
-	auto init_fun_name = res.basename + "_replacement_open_pre";
-
-	replacement_open_pre_t open_pre_fun;
-	open_pre_fun = LoadFunctionFromDLL<replacement_open_pre_t>(res.lib_hdl, init_fun_name, res.filename);
-
-	try {
-		return (*open_pre_fun)(config, nullptr);
-	} catch (std::exception &e) {
-		throw InvalidInputException("Initialization function \"%s\" from file \"%s\" threw an exception: \"%s\"",
-		                            init_fun_name, res.filename, e.what());
-	}
+void ExtensionHelper::LoadExternalExtension(ClientContext &context, const string &extension) {
+	LoadExternalExtension(DatabaseInstance::GetDatabase(context), FileSystem::GetFileOpener(context), extension);
 }
 
-void ExtensionHelper::ReplacementOpenPost(ClientContext &context, const string &extension, DatabaseInstance &instance,
-                                          ReplacementOpenData *open_data) {
-	auto res = InitialLoad(DBConfig::GetConfig(context), FileSystem::GetFileOpener(context), extension);
-	auto init_fun_name = res.basename + "_replacement_open_post";
+void ExtensionHelper::StorageInit(string &extension, DBConfig &config) {
+	extension = ExtensionHelper::ApplyExtensionAlias(extension);
+	auto res = InitialLoad(config, nullptr, extension); // TODO opener
+	auto storage_fun_name = res.basename + "_storage_init";
 
-	replacement_open_post_t open_post_fun;
-	open_post_fun = LoadFunctionFromDLL<replacement_open_post_t>(res.lib_hdl, init_fun_name, res.filename);
+	ext_storage_init_t storage_init_fun;
+	storage_init_fun = LoadFunctionFromDLL<ext_storage_init_t>(res.lib_hdl, storage_fun_name, res.filename);
 
 	try {
-		(*open_post_fun)(instance, open_data);
+		(*storage_init_fun)(config);
 	} catch (std::exception &e) {
-		throw InvalidInputException("Initialization function \"%s\" from file \"%s\" threw an exception: \"%s\"",
-		                            init_fun_name, res.filename, e.what());
+		throw InvalidInputException(
+		    "Storage initialization function \"%s\" from file \"%s\" threw an exception: \"%s\"", storage_fun_name,
+		    res.filename, e.what());
 	}
 }
 
@@ -182,6 +170,12 @@ string ExtensionHelper::ExtractExtensionPrefixFromPath(const string &path) {
 		return "";
 	}
 	auto extension = path.substr(0, first_colon);
+
+	if (path.substr(first_colon, 3) == "://") {
+		// these are not extensions
+		return "";
+	}
+
 	D_ASSERT(extension.size() > 1);
 	// needs to be alphanumeric
 	for (auto &ch : extension) {

package/src/duckdb/src/main/materialized_query_result.cpp

@@ -1,19 +1,20 @@
 #include "duckdb/main/materialized_query_result.hpp"
 #include "duckdb/common/to_string.hpp"
 #include "duckdb/main/client_context.hpp"
+#include "duckdb/common/box_renderer.hpp"
 
 namespace duckdb {
 
 MaterializedQueryResult::MaterializedQueryResult(StatementType statement_type, StatementProperties properties,
                                                  vector<string> names_p, unique_ptr<ColumnDataCollection> collection_p,
                                                  ClientProperties client_properties)
-    : QueryResult(QueryResultType::MATERIALIZED_RESULT, statement_type, move(properties), collection_p->Types(),
-                  move(names_p), move(client_properties)),
-      collection(move(collection_p)), scan_initialized(false) {
+    : QueryResult(QueryResultType::MATERIALIZED_RESULT, statement_type, std::move(properties), collection_p->Types(),
+                  std::move(names_p), std::move(client_properties)),
+      collection(std::move(collection_p)), scan_initialized(false) {
 }
 
 MaterializedQueryResult::MaterializedQueryResult(PreservedError error)
-    : QueryResult(QueryResultType::MATERIALIZED_RESULT, move(error)), scan_initialized(false) {
+    : QueryResult(QueryResultType::MATERIALIZED_RESULT, std::move(error)), scan_initialized(false) {
 }
 
 string MaterializedQueryResult::ToString() {
@@ -39,6 +40,17 @@ string MaterializedQueryResult::ToString() {
 	return result;
 }
 
+string MaterializedQueryResult::ToBox(ClientContext &context, const BoxRendererConfig &config) {
+	if (!success) {
+		return GetError() + "\n";
+	}
+	if (!collection) {
+		return "Internal error - result was successful but there was no collection";
+	}
+	BoxRenderer renderer(config);
+	return renderer.ToString(context, names, Collection());
+}
+
 Value MaterializedQueryResult::GetValue(idx_t column, idx_t index) {
 	if (!row_collection) {
 		row_collection = make_unique<ColumnDataRowCollection>(collection->GetRows());

package/src/duckdb/src/main/pending_query_result.cpp

@@ -6,13 +6,13 @@ namespace duckdb {
 
 PendingQueryResult::PendingQueryResult(shared_ptr<ClientContext> context_p, PreparedStatementData &statement,
                                        vector<LogicalType> types_p, bool allow_stream_result)
-    : BaseQueryResult(QueryResultType::PENDING_RESULT, statement.statement_type, statement.properties, move(types_p),
-                      statement.names),
-      context(move(context_p)), allow_stream_result(allow_stream_result) {
+    : BaseQueryResult(QueryResultType::PENDING_RESULT, statement.statement_type, statement.properties,
+                      std::move(types_p), statement.names),
+      context(std::move(context_p)), allow_stream_result(allow_stream_result) {
 }
 
 PendingQueryResult::PendingQueryResult(PreservedError error)
-    : BaseQueryResult(QueryResultType::PENDING_RESULT, move(error)) {
+    : BaseQueryResult(QueryResultType::PENDING_RESULT, std::move(error)) {
 }
 
 PendingQueryResult::~PendingQueryResult() {

package/src/duckdb/src/main/prepared_statement.cpp

@@ -7,12 +7,12 @@ namespace duckdb {
 
 PreparedStatement::PreparedStatement(shared_ptr<ClientContext> context, shared_ptr<PreparedStatementData> data_p,
                                      string query, idx_t n_param, case_insensitive_map_t<idx_t> named_param_pam_p)
-    : context(move(context)), data(move(data_p)), query(move(query)), success(true), n_param(n_param),
-      named_param_map(move(named_param_pam_p)) {
+    : context(std::move(context)), data(std::move(data_p)), query(std::move(query)), success(true), n_param(n_param),
+      named_param_map(std::move(named_param_pam_p)) {
 	D_ASSERT(data || !success);
 }
 
-PreparedStatement::PreparedStatement(PreservedError error) : context(nullptr), success(false), error(move(error)) {
+PreparedStatement::PreparedStatement(PreservedError error) : context(nullptr), success(false), error(std::move(error)) {
 }
 
 PreparedStatement::~PreparedStatement() {
@@ -52,6 +52,19 @@ const vector<string> &PreparedStatement::GetNames() {
 	return data->names;
 }
 
+vector<LogicalType> PreparedStatement::GetExpectedParameterTypes() const {
+	D_ASSERT(data);
+	vector<LogicalType> expected_types(data->value_map.size());
+	for (auto &it : data->value_map) {
+		D_ASSERT(it.first >= 1);
+		idx_t param_index = it.first - 1;
+		D_ASSERT(param_index < expected_types.size());
+		D_ASSERT(it.second);
+		expected_types[param_index] = it.second->value.type();
+	}
+	return expected_types;
+}
+
 unique_ptr<QueryResult> PreparedStatement::Execute(vector<Value> &values, bool allow_stream_result) {
 	auto pending = PendingQuery(values, allow_stream_result);
 	if (pending->HasError()) {

package/src/duckdb/src/main/query_profiler.cpp

@@ -64,7 +64,7 @@ void QueryProfiler::StartQuery(string query, bool is_explain_analyze, bool start
 		return;
 	}
 	this->running = true;
-	this->query = move(query);
+	this->query = std::move(query);
 	tree_map.clear();
 	root = nullptr;
 	phase_timings.clear();
@@ -309,7 +309,7 @@ void QueryProfiler::Flush(OperatorProfiler &profiler) {
 			if (int(entry->second->info.executors_info.size()) <= info_id) {
 				entry->second->info.executors_info.resize(info_id + 1);
 			}
-			entry->second->info.executors_info[info_id] = move(info);
+			entry->second->info.executors_info[info_id] = std::move(info);
 		}
 	}
 	profiler.timings.clear();
@@ -621,7 +621,7 @@ unique_ptr<QueryProfiler::TreeNode> QueryProfiler::CreateTree(PhysicalOperator *
 	auto children = root->GetChildren();
 	for (auto &child : children) {
 		auto child_node = CreateTree(child, depth + 1);
-		node->children.push_back(move(child_node));
+		node->children.push_back(std::move(child_node));
 	}
 	return node;
 }
@@ -673,7 +673,7 @@ void ExpressionInfo::ExtractExpressionsRecursive(unique_ptr<ExpressionState> &st
 			expr_info->tuples_count = child->profiler.tuples_count;
 		}
 		expr_info->ExtractExpressionsRecursive(child);
-		children.push_back(move(expr_info));
+		children.push_back(std::move(expr_info));
 	}
 	return;
 }
@@ -690,7 +690,7 @@ ExpressionRootInfo::ExpressionRootInfo(ExpressionExecutorState &state, string na
       sample_tuples_count(state.profiler.sample_tuples_count), tuples_count(state.profiler.tuples_count),
       name(state.name), time(state.profiler.time) {
 	// Use the name of expression-tree as extra-info
-	extra_info = move(name);
+	extra_info = std::move(name);
 	auto expression_info_p = make_unique<ExpressionInfo>();
 	// Maybe root has a function
 	if (state.root_state->expr.expression_class == ExpressionClass::BOUND_FUNCTION) {
@@ -701,6 +701,6 @@ ExpressionRootInfo::ExpressionRootInfo(ExpressionExecutorState &state, string na
 		expression_info_p->tuples_count = state.root_state->profiler.tuples_count;
 	}
 	expression_info_p->ExtractExpressionsRecursive(state.root_state);
-	root = move(expression_info_p);
+	root = std::move(expression_info_p);
 }
 } // namespace duckdb