duckdb 0.7.2-dev2740.0 → 0.7.2-dev2867.0

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

@@ -4,6 +4,10 @@
 #include "duckdb/main/error_manager.hpp"
 #include "mbedtls_wrapper.hpp"
 
+#ifndef DUCKDB_NO_THREADS
+#include <thread>
+#endif // DUCKDB_NO_THREADS
+
 #ifdef WASM_LOADABLE_EXTENSIONS
 #include <emscripten.h>
 #endif
@@ -15,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) {
@@ -26,6 +30,16 @@ static T LoadFunctionFromDLL(void *dll, const string &function_name, const strin
 	return (T)function;
 }
 
+void ComputeSHA256(FileHandle *handle, const idx_t start, const idx_t end, std::string *res) {
+	const idx_t len = end - start;
+	string file_content;
+	file_content.resize(len);
+	handle->Read((void *)file_content.data(), len, start);
+
+	// Invoke MbedTls function to actually compute sha256
+	*res = duckdb_mbedtls::MbedTlsWrapper::ComputeSha256Hash(file_content);
+}
+
 bool ExtensionHelper::TryInitialLoad(DBConfig &config, FileOpener *opener, const string &extension,
                                      ExtensionInitResult &result, string &error) {
 	if (!config.options.enable_external_access) {
@@ -70,15 +84,45 @@ bool ExtensionHelper::TryInitialLoad(DBConfig &config, FileOpener *opener, const
 
 		auto signature_offset = handle->GetFileSize() - signature.size();
 
+		const idx_t maxLenChunks = 1024 * 1024;
+		const idx_t numChunks = (signature_offset + maxLenChunks - 1) / maxLenChunks;
+		std::vector<std::string> chunks(numChunks);
+		std::vector<idx_t> splits(numChunks + 1);
+
+		splits.back() = signature_offset;
+		for (idx_t i = 0; i < chunks.size(); i++) {
+			splits[i] = maxLenChunks * i;
+		}
+
+#ifndef DUCKDB_NO_THREADS
+		std::vector<std::thread> threads;
+		threads.reserve(numChunks);
+		for (idx_t i = 0; i < numChunks; i++) {
+			threads.emplace_back(ComputeSHA256, handle.get(), splits[i], splits[i + 1], &chunks[i]);
+		}
+
+		for (auto &thread : threads) {
+			thread.join();
+		}
+#else
+		for (idx_t i = 0; i < numChunks; i++) {
+			ComputeSHA256(handle.get(), splits[i], splits[i + 1], &chunks[i]);
+		}
+#endif // DUCKDB_NO_THREADS
+
 		string file_content;
-		file_content.resize(signature_offset);
-		handle->Read((void *)file_content.data(), signature_offset, 0);
+		file_content.reserve(256 * numChunks);
+
+		for (auto &chunk : chunks) {
+			file_content += chunk;
+		}
+
+		string hash;
+		ComputeSHA256(handle.get(), 0, file_content.size(), &hash);
 
 		// TODO maybe we should do a stream read / hash update here
 		handle->Read((void *)signature.data(), signature.size(), signature_offset);
 
-		auto hash = duckdb_mbedtls::MbedTlsWrapper::ComputeSha256Hash(file_content);
-
 		bool any_valid = false;
 		for (auto &key : ExtensionHelper::GetPublicKeys()) {
 			if (duckdb_mbedtls::MbedTlsWrapper::IsValidSha256Signature(key, signature, hash)) {
@@ -157,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;
 }
@@ -207,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/main/extension/extension_util.cpp

@@ -0,0 +1,90 @@
+#include "duckdb/main/extension_util.hpp"
+#include "duckdb/function/scalar_function.hpp"
+#include "duckdb/parser/parsed_data/create_type_info.hpp"
+#include "duckdb/parser/parsed_data/create_copy_function_info.hpp"
+#include "duckdb/parser/parsed_data/create_pragma_function_info.hpp"
+#include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
+#include "duckdb/parser/parsed_data/create_table_function_info.hpp"
+#include "duckdb/parser/parsed_data/create_macro_info.hpp"
+#include "duckdb/catalog/catalog.hpp"
+#include "duckdb/main/config.hpp"
+
+namespace duckdb {
+
+void ExtensionUtil::RegisterFunction(DatabaseInstance &db, ScalarFunctionSet set) {
+	D_ASSERT(!set.name.empty());
+	CreateScalarFunctionInfo info(std::move(set));
+	auto &system_catalog = Catalog::GetSystemCatalog(db);
+	auto data = CatalogTransaction::GetSystemTransaction(db);
+	system_catalog.CreateFunction(data, info);
+}
+
+void ExtensionUtil::RegisterFunction(DatabaseInstance &db, ScalarFunction function) {
+	D_ASSERT(!function.name.empty());
+	ScalarFunctionSet set(function.name);
+	set.AddFunction(std::move(function));
+	RegisterFunction(db, std::move(set));
+}
+
+void ExtensionUtil::RegisterFunction(DatabaseInstance &db, TableFunction function) {
+	D_ASSERT(!function.name.empty());
+	TableFunctionSet set(function.name);
+	set.AddFunction(std::move(function));
+	RegisterFunction(db, std::move(set));
+}
+
+void ExtensionUtil::RegisterFunction(DatabaseInstance &db, TableFunctionSet function) {
+	D_ASSERT(!function.name.empty());
+	CreateTableFunctionInfo info(std::move(function));
+	auto &system_catalog = Catalog::GetSystemCatalog(db);
+	auto data = CatalogTransaction::GetSystemTransaction(db);
+	system_catalog.CreateFunction(data, info);
+}
+
+void ExtensionUtil::RegisterFunction(DatabaseInstance &db, PragmaFunction function) {
+	D_ASSERT(!function.name.empty());
+	PragmaFunctionSet set(function.name);
+	set.AddFunction(std::move(function));
+	RegisterFunction(db, std::move(set));
+}
+
+void ExtensionUtil::RegisterFunction(DatabaseInstance &db, PragmaFunctionSet function) {
+	D_ASSERT(!function.name.empty());
+	auto function_name = function.name;
+	CreatePragmaFunctionInfo info(std::move(function_name), std::move(function));
+	auto &system_catalog = Catalog::GetSystemCatalog(db);
+	auto data = CatalogTransaction::GetSystemTransaction(db);
+	system_catalog.CreatePragmaFunction(data, info);
+}
+
+void ExtensionUtil::RegisterFunction(DatabaseInstance &db, CopyFunction function) {
+	CreateCopyFunctionInfo info(std::move(function));
+	auto &system_catalog = Catalog::GetSystemCatalog(db);
+	auto data = CatalogTransaction::GetSystemTransaction(db);
+	system_catalog.CreateCopyFunction(data, info);
+}
+
+void ExtensionUtil::RegisterFunction(DatabaseInstance &db, CreateMacroInfo &info) {
+	auto &system_catalog = Catalog::GetSystemCatalog(db);
+	auto data = CatalogTransaction::GetSystemTransaction(db);
+	system_catalog.CreateFunction(data, info);
+}
+
+void ExtensionUtil::RegisterType(DatabaseInstance &db, string type_name, LogicalType type) {
+	D_ASSERT(!type_name.empty());
+	CreateTypeInfo info(std::move(type_name), std::move(type));
+	info.temporary = true;
+	info.internal = true;
+	auto &system_catalog = Catalog::GetSystemCatalog(db);
+	auto data = CatalogTransaction::GetSystemTransaction(db);
+	system_catalog.CreateType(data, info);
+}
+
+void ExtensionUtil::RegisterCastFunction(DatabaseInstance &db, const LogicalType &source, const LogicalType &target,
+                                         BoundCastInfo function, int64_t implicit_cast_cost) {
+	auto &config = DBConfig::GetConfig(db);
+	auto &casts = config.GetCastFunctions();
+	casts.RegisterCastFunction(source, target, std::move(function), implicit_cast_cost);
+}
+
+} // namespace duckdb

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

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

@@ -18,33 +18,45 @@
 
 namespace duckdb {
 
-void Transformer::AddPivotEntry(string enum_name, unique_ptr<SelectNode> base, unique_ptr<ParsedExpression> column) {
+void Transformer::AddPivotEntry(string enum_name, unique_ptr<SelectNode> base, unique_ptr<ParsedExpression> column,
+                                unique_ptr<QueryNode> subquery) {
 	if (parent) {
-		parent->AddPivotEntry(std::move(enum_name), std::move(base), std::move(column));
+		parent->AddPivotEntry(std::move(enum_name), std::move(base), std::move(column), std::move(subquery));
 		return;
 	}
 	auto result = make_uniq<CreatePivotEntry>();
 	result->enum_name = std::move(enum_name);
 	result->base = std::move(base);
 	result->column = std::move(column);
+	result->subquery = std::move(subquery);
 
 	pivot_entries.push_back(std::move(result));
 }
 
 bool Transformer::HasPivotEntries() {
-	if (parent) {
-		return parent->HasPivotEntries();
-	}
-	return !pivot_entries.empty();
+	return !GetPivotEntries().empty();
 }
 
 idx_t Transformer::PivotEntryCount() {
+	return GetPivotEntries().size();
+}
+
+vector<unique_ptr<Transformer::CreatePivotEntry>> &Transformer::GetPivotEntries() {
 	if (parent) {
-		return parent->PivotEntryCount();
+		return parent->GetPivotEntries();
 	}
-	return pivot_entries.size();
+	return pivot_entries;
 }
 
+void Transformer::PivotEntryCheck(const string &type) {
+	auto &entries = GetPivotEntries();
+	if (!entries.empty()) {
+		throw ParserException(
+		    "PIVOT statements with pivot elements extracted from the data cannot be used in %ss.\nIn order to use "
+		    "PIVOT in a %s the PIVOT values must be manually specified, e.g.:\nPIVOT ... ON %s IN (val1, val2, ...)",
+		    type, type, entries[0]->column->ToString());
+	}
+}
 unique_ptr<SQLStatement> Transformer::GenerateCreateEnumStmt(unique_ptr<CreatePivotEntry> entry) {
 	auto result = make_uniq<CreateStatement>();
 	auto info = make_uniq<CreateTypeInfo>();
@@ -57,23 +69,30 @@ unique_ptr<SQLStatement> Transformer::GenerateCreateEnumStmt(unique_ptr<CreatePi
 	info->on_conflict = OnCreateConflict::REPLACE_ON_CONFLICT;
 
 	// generate the query that will result in the enum creation
-	auto select_node = std::move(entry->base);
-	auto columnref = entry->column->Copy();
-	auto cast = make_uniq<CastExpression>(LogicalType::VARCHAR, std::move(columnref));
-	select_node->select_list.push_back(std::move(cast));
-
-	auto is_not_null = make_uniq<OperatorExpression>(ExpressionType::OPERATOR_IS_NOT_NULL, std::move(entry->column));
-	select_node->where_clause = std::move(is_not_null);
-
-	// order by the column
-	select_node->modifiers.push_back(make_uniq<DistinctModifier>());
-	auto modifier = make_uniq<OrderModifier>();
-	modifier->orders.emplace_back(OrderType::ASCENDING, OrderByNullType::ORDER_DEFAULT,
-	                              make_uniq<ConstantExpression>(Value::INTEGER(1)));
-	select_node->modifiers.push_back(std::move(modifier));
+	unique_ptr<QueryNode> subselect;
+	if (!entry->subquery) {
+		auto select_node = std::move(entry->base);
+		auto columnref = entry->column->Copy();
+		auto cast = make_uniq<CastExpression>(LogicalType::VARCHAR, std::move(columnref));
+		select_node->select_list.push_back(std::move(cast));
+
+		auto is_not_null =
+		    make_uniq<OperatorExpression>(ExpressionType::OPERATOR_IS_NOT_NULL, std::move(entry->column));
+		select_node->where_clause = std::move(is_not_null);
+
+		// order by the column
+		select_node->modifiers.push_back(make_uniq<DistinctModifier>());
+		auto modifier = make_uniq<OrderModifier>();
+		modifier->orders.emplace_back(OrderType::ASCENDING, OrderByNullType::ORDER_DEFAULT,
+		                              make_uniq<ConstantExpression>(Value::INTEGER(1)));
+		select_node->modifiers.push_back(std::move(modifier));
+		subselect = std::move(select_node);
+	} else {
+		subselect = std::move(entry->subquery);
+	}
 
 	auto select = make_uniq<SelectStatement>();
-	select->node = std::move(select_node);
+	select->node = std::move(subselect);
 	info->query = std::move(select);
 	info->type = LogicalType::INVALID;
 
@@ -150,7 +169,7 @@ unique_ptr<QueryNode> Transformer::TransformPivotStatement(duckdb_libpgquery::PG
 		auto new_select = make_uniq<SelectNode>();
 		ExtractCTEsRecursive(new_select->cte_map);
 		new_select->from_table = source->Copy();
-		AddPivotEntry(enum_name, std::move(new_select), col.pivot_expressions[0]->Copy());
+		AddPivotEntry(enum_name, std::move(new_select), col.pivot_expressions[0]->Copy(), std::move(col.subquery));
 		col.pivot_enum = enum_name;
 	}
 

package/src/duckdb/src/parser/transform/tableref/transform_pivot.cpp

@@ -59,6 +59,9 @@ PivotColumn Transformer::TransformPivotColumn(duckdb_libpgquery::PGPivot *pivot)
 			col.entries.push_back(std::move(entry));
 		}
 	}
+	if (pivot->subquery) {
+		col.subquery = TransformSelectNode(reinterpret_cast<duckdb_libpgquery::PGSelectStmt *>(pivot->subquery));
+	}
 	if (pivot->pivot_enum) {
 		col.pivot_enum = pivot->pivot_enum;
 	}

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

@@ -8,6 +8,8 @@
 #include "duckdb/parser/expression/constant_expression.hpp"
 #include "duckdb/parser/expression/function_expression.hpp"
 #include "duckdb/parser/expression/subquery_expression.hpp"
+#include "duckdb/planner/expression/bound_cast_expression.hpp"
+#include "duckdb/planner/expression/bound_columnref_expression.hpp"
 #include "duckdb/parser/parsed_data/create_index_info.hpp"
 #include "duckdb/parser/parsed_data/create_macro_info.hpp"
 #include "duckdb/parser/parsed_data/create_view_info.hpp"
@@ -24,6 +26,7 @@
 #include "duckdb/planner/operator/logical_create_table.hpp"
 #include "duckdb/planner/operator/logical_get.hpp"
 #include "duckdb/planner/operator/logical_distinct.hpp"
+#include "duckdb/planner/operator/logical_projection.hpp"
 #include "duckdb/planner/parsed_data/bound_create_table_info.hpp"
 #include "duckdb/planner/query_node/bound_select_node.hpp"
 #include "duckdb/planner/tableref/bound_basetableref.hpp"
@@ -605,41 +608,27 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 	}
 	case CatalogType::TYPE_ENTRY: {
 		auto &schema = BindCreateSchema(*stmt.info);
-		auto &create_type_info = (CreateTypeInfo &)(*stmt.info);
+		auto &create_type_info = stmt.info->Cast<CreateTypeInfo>();
 		result.plan = make_uniq<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_TYPE, std::move(stmt.info), &schema);
 		if (create_type_info.query) {
 			// CREATE TYPE mood AS ENUM (SELECT 'happy')
-			auto &select_stmt = create_type_info.query->Cast<SelectStatement>();
-			auto &query_node = *select_stmt.node;
-
-			// We always add distinct modifier implicitly
-			bool need_to_add = true;
-			if (!query_node.modifiers.empty()) {
-				if (query_node.modifiers[0]->type == ResultModifierType::DISTINCT_MODIFIER) {
-					// There are cases where the same column is grouped repeatedly
-					// CREATE TYPE mood AS ENUM (SELECT DISTINCT ON(x) x FROM test);
-					// When we push into a constant expression
-					// => CREATE TYPE mood AS ENUM (SELECT DISTINCT ON(x, x) x FROM test);
-					auto &distinct_modifier = (DistinctModifier &)*query_node.modifiers[0];
-					if (distinct_modifier.distinct_on_targets.empty()) {
-						need_to_add = false;
-					}
-				}
-			}
-
-			// Add distinct modifier
-			if (need_to_add) {
-				auto distinct_modifier = make_uniq<DistinctModifier>();
-				query_node.modifiers.emplace(query_node.modifiers.begin(), std::move(distinct_modifier));
-			}
-
 			auto query_obj = Bind(*create_type_info.query);
 			auto query = std::move(query_obj.plan);
 
 			auto &sql_types = query_obj.types;
-			if (sql_types.size() != 1 || sql_types[0].id() != LogicalType::VARCHAR) {
+			if (sql_types.size() != 1) {
 				// add cast expression?
-				throw BinderException("The query must return one varchar column");
+				throw BinderException("The query must return a single column");
+			}
+			if (sql_types[0].id() != LogicalType::VARCHAR) {
+				// push a projection casting to varchar
+				vector<unique_ptr<Expression>> select_list;
+				auto ref = make_uniq<BoundColumnRefExpression>(sql_types[0], query->GetColumnBindings()[0]);
+				auto cast_expr = BoundCastExpression::AddCastToType(context, std::move(ref), LogicalType::VARCHAR);
+				select_list.push_back(std::move(cast_expr));
+				auto proj = make_uniq<LogicalProjection>(GenerateTableIndex(), std::move(select_list));
+				proj->AddChild(std::move(query));
+				query = std::move(proj);
 			}
 
 			result.plan->AddChild(std::move(query));
@@ -660,7 +649,7 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 	}
 	case CatalogType::DATABASE_ENTRY: {
 		// not supported in DuckDB yet but allow extensions to intercept and implement this functionality
-		auto &base = (CreateDatabaseInfo &)*stmt.info;
+		auto &base = stmt.info->Cast<CreateDatabaseInfo>();
 		string database_name = base.name;
 		string source_path = base.path;
 

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

@@ -25,7 +25,7 @@
 namespace duckdb {
 
 static void CreateColumnDependencyManager(BoundCreateTableInfo &info) {
-	auto &base = (CreateTableInfo &)*info.base;
+	auto &base = info.base->Cast<CreateTableInfo>();
 	for (auto &col : base.columns.Logical()) {
 		if (!col.Generated()) {
 			continue;
@@ -35,13 +35,12 @@ static void CreateColumnDependencyManager(BoundCreateTableInfo &info) {
 }
 
 static void BindCheckConstraint(Binder &binder, BoundCreateTableInfo &info, const unique_ptr<Constraint> &cond) {
-	auto &base = (CreateTableInfo &)*info.base;
+	auto &base = info.base->Cast<CreateTableInfo>();
 
 	auto bound_constraint = make_uniq<BoundCheckConstraint>();
 	// check constraint: bind the expression
 	CheckBinder check_binder(binder, binder.context, base.table, base.columns, bound_constraint->bound_columns);
 	auto &check = cond->Cast<CheckConstraint>();
-	;
 	// create a copy of the unbound expression because the binding destroys the constraint
 	auto unbound_expression = check.expression->Copy();
 	// now bind the constraint and create a new BoundCheckConstraint
@@ -52,7 +51,7 @@ static void BindCheckConstraint(Binder &binder, BoundCreateTableInfo &info, cons
 }
 
 static void BindConstraints(Binder &binder, BoundCreateTableInfo &info) {
-	auto &base = (CreateTableInfo &)*info.base;
+	auto &base = info.base->Cast<CreateTableInfo>();
 
 	bool has_primary_key = false;
 	logical_index_set_t not_null_columns;
@@ -155,7 +154,7 @@ static void BindConstraints(Binder &binder, BoundCreateTableInfo &info) {
 }
 
 void Binder::BindGeneratedColumns(BoundCreateTableInfo &info) {
-	auto &base = (CreateTableInfo &)*info.base;
+	auto &base = info.base->Cast<CreateTableInfo>();
 
 	vector<string> names;
 	vector<LogicalType> types;
@@ -252,7 +251,7 @@ static void ExtractDependencies(BoundCreateTableInfo &info) {
 	}
 }
 unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateInfo> info, SchemaCatalogEntry &schema) {
-	auto &base = (CreateTableInfo &)*info;
+	auto &base = info->Cast<CreateTableInfo>();
 	auto result = make_uniq<BoundCreateTableInfo>(schema, std::move(info));
 	if (base.query) {
 		// construct the result object
@@ -305,7 +304,7 @@ unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateIn
 }
 
 unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateInfo> info) {
-	auto &base = (CreateTableInfo &)*info;
+	auto &base = info->Cast<CreateTableInfo>();
 	auto &schema = BindCreateSchema(base);
 	return BindCreateTableInfo(std::move(info), schema);
 }

package/src/duckdb/third_party/fmt/format.cc

@@ -128,11 +128,6 @@ int (*instantiate_format_float)(double, int, internal::float_specs,
                                 internal::buffer<char>&) =
     internal::format_float;
 
-#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
-template FMT_API internal::locale_ref::locale_ref(const std::locale& loc);
-template FMT_API std::locale internal::locale_ref::get<std::locale>() const;
-#endif
-
 // Explicit instantiations for char.
 
 template FMT_API std::string internal::grouping_impl<char>(locale_ref);

package/src/duckdb/third_party/fmt/include/fmt/core.h

@@ -62,15 +62,9 @@
 
 // Check if relaxed C++14 constexpr is supported.
 // GCC doesn't allow throw in constexpr until version 6 (bug 67371).
-#ifndef FMT_USE_CONSTEXPR
-#  define FMT_USE_CONSTEXPR                                           \
-    (FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VER >= 1910 || \
-     (FMT_GCC_VERSION >= 600 && __cplusplus >= 201402L)) &&           \
-        !FMT_NVCC
-#endif
 #if FMT_USE_CONSTEXPR
-#  define FMT_CONSTEXPR constexpr
-#  define FMT_CONSTEXPR_DECL constexpr
+#  define FMT_CONSTEXPR inline
+#  define FMT_CONSTEXPR_DECL
 #else
 #  define FMT_CONSTEXPR inline
 #  define FMT_CONSTEXPR_DECL
@@ -323,6 +317,10 @@ template <typename Char> class basic_string_view {
     size_ -= n;
   }
 
+  std::string to_string() {
+	  return std::string((char *) data(), size());
+  }
+
   // Lexicographically compare this string reference to other.
   int compare(basic_string_view other) const {
     size_t str_size = size_ < other.size_ ? size_ : other.size_;
@@ -416,7 +414,7 @@ template <typename S>
 struct is_compile_string : std::is_base_of<compile_string, S> {};
 
 template <typename S, FMT_ENABLE_IF(is_compile_string<S>::value)>
-constexpr basic_string_view<typename S::char_type> to_string_view(const S& s) {
+FMT_CONSTEXPR basic_string_view<typename S::char_type> to_string_view(const S& s) {
   return s;
 }
 
@@ -442,7 +440,7 @@ struct error_handler {
   FMT_CONSTEXPR error_handler(const error_handler&) = default;
 
   // This function is intentionally not constexpr to give a compile-time error.
-  FMT_NORETURN FMT_API void on_error(const char* message);
+  FMT_NORETURN FMT_API void on_error(std::string message);
 };
 }  // namespace internal
 
@@ -520,7 +518,7 @@ class basic_format_parse_context : private ErrorHandler {
 
   FMT_CONSTEXPR void check_arg_id(basic_string_view<Char>) {}
 
-  FMT_CONSTEXPR void on_error(const char* message) {
+  FMT_CONSTEXPR void on_error(std::string message) {
     ErrorHandler::on_error(message);
   }
 
@@ -1158,7 +1156,7 @@ template <typename OutputIt, typename Char> class basic_format_context {
   format_arg arg(basic_string_view<char_type> name);
 
   internal::error_handler error_handler() { return {}; }
-  void on_error(const char* message) { error_handler().on_error(message); }
+  void on_error(std::string message) { error_handler().on_error(message); }
 
   // Returns an iterator to the beginning of the output range.
   iterator out() { return out_; }

package/src/duckdb/third_party/fmt/include/fmt/format-inl.h

@@ -17,10 +17,6 @@
 #include <cstdarg>
 #include <cstring>  // for std::memmove
 #include <cwchar>
-#if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
-#  include <locale>
-#endif
-
 #if FMT_EXCEPTIONS
 #  define FMT_TRY try
 #  define FMT_CATCH(x) catch (x)
@@ -162,45 +158,18 @@ FMT_FUNC void report_error(format_func func, int error_code,
 }
 }  // namespace internal
 
-#if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
-namespace internal {
-
-template <typename Locale>
-locale_ref::locale_ref(const Locale& loc) : locale_(&loc) {
-  static_assert(std::is_same<Locale, std::locale>::value, "");
-}
-
-template <typename Locale> Locale locale_ref::get() const {
-  static_assert(std::is_same<Locale, std::locale>::value, "");
-  return locale_ ? *static_cast<const std::locale*>(locale_) : std::locale();
-}
-
-template <typename Char> FMT_FUNC std::string grouping_impl(locale_ref loc) {
-  return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>()).grouping();
-}
-template <typename Char> FMT_FUNC Char thousands_sep_impl(locale_ref loc) {
-  return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>())
-      .thousands_sep();
-}
-template <typename Char> FMT_FUNC Char decimal_point_impl(locale_ref loc) {
-  return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>())
-      .decimal_point();
-}
-}  // namespace internal
-#else
 template <typename Char>
 FMT_FUNC std::string internal::grouping_impl(locale_ref) {
   return "\03";
 }
 template <typename Char>
 FMT_FUNC Char internal::thousands_sep_impl(locale_ref) {
-  return FMT_STATIC_THOUSANDS_SEPARATOR;
+  return ',';
 }
 template <typename Char>
 FMT_FUNC Char internal::decimal_point_impl(locale_ref) {
   return '.';
 }
-#endif
 
 namespace internal {
 
@@ -1203,7 +1172,7 @@ template <> struct formatter<internal::bigint> {
   }
 };
 
-FMT_FUNC void internal::error_handler::on_error(const char* message) {
+FMT_FUNC void internal::error_handler::on_error(std::string message) {
   FMT_THROW(duckdb::Exception(message));
 }