duckdb 0.7.2-dev321.0 → 0.7.2-dev3294.0

package/src/duckdb/src/transaction/duck_transaction.cpp

@@ -29,7 +29,7 @@ TransactionData::TransactionData(transaction_t transaction_id_p, transaction_t s
 DuckTransaction::DuckTransaction(TransactionManager &manager, ClientContext &context_p, transaction_t start_time,
                                  transaction_t transaction_id)
     : Transaction(manager, context_p), start_time(start_time), transaction_id(transaction_id), commit_id(0),
-      highest_active_query(0), undo_buffer(context_p), storage(make_unique<LocalStorage>(context_p, *this)) {
+      highest_active_query(0), undo_buffer(context_p), storage(make_uniq<LocalStorage>(context_p, *this)) {
 }
 
 DuckTransaction::~DuckTransaction() {
@@ -51,14 +51,14 @@ LocalStorage &DuckTransaction::GetLocalStorage() {
 	return *storage;
 }
 
-void DuckTransaction::PushCatalogEntry(CatalogEntry *entry, data_ptr_t extra_data, idx_t extra_data_size) {
+void DuckTransaction::PushCatalogEntry(CatalogEntry &entry, data_ptr_t extra_data, idx_t extra_data_size) {
 	idx_t alloc_size = sizeof(CatalogEntry *);
 	if (extra_data_size > 0) {
 		alloc_size += extra_data_size + sizeof(idx_t);
 	}
 	auto baseptr = undo_buffer.CreateEntry(UndoFlags::CATALOG_ENTRY, alloc_size);
 	// store the pointer to the catalog entry
-	Store<CatalogEntry *>(entry, baseptr);
+	Store<CatalogEntry *>(&entry, baseptr);
 	if (extra_data_size > 0) {
 		// copy the extra data behind the catalog entry pointer (if any)
 		baseptr += sizeof(CatalogEntry *);
@@ -70,19 +70,19 @@ void DuckTransaction::PushCatalogEntry(CatalogEntry *entry, data_ptr_t extra_dat
 	}
 }
 
-void DuckTransaction::PushDelete(DataTable *table, ChunkVectorInfo *vinfo, row_t rows[], idx_t count, idx_t base_row) {
+void DuckTransaction::PushDelete(DataTable &table, ChunkVectorInfo *vinfo, row_t rows[], idx_t count, idx_t base_row) {
 	auto delete_info =
 	    (DeleteInfo *)undo_buffer.CreateEntry(UndoFlags::DELETE_TUPLE, sizeof(DeleteInfo) + sizeof(row_t) * count);
 	delete_info->vinfo = vinfo;
-	delete_info->table = table;
+	delete_info->table = &table;
 	delete_info->count = count;
 	delete_info->base_row = base_row;
 	memcpy(delete_info->rows, rows, sizeof(row_t) * count);
 }
 
-void DuckTransaction::PushAppend(DataTable *table, idx_t start_row, idx_t row_count) {
+void DuckTransaction::PushAppend(DataTable &table, idx_t start_row, idx_t row_count) {
 	auto append_info = (AppendInfo *)undo_buffer.CreateEntry(UndoFlags::INSERT_TUPLE, sizeof(AppendInfo));
-	append_info->table = table;
+	append_info->table = &table;
 	append_info->start_row = start_row;
 	append_info->count = row_count;
 }
@@ -116,7 +116,7 @@ string DuckTransaction::Commit(AttachedDatabase &db, transaction_t commit_id, bo
 	UndoBuffer::IteratorState iterator_state;
 	LocalStorage::CommitState commit_state;
 	unique_ptr<StorageCommitState> storage_commit_state;
-	WriteAheadLog *log;
+	optional_ptr<WriteAheadLog> log;
 	if (!db.IsSystem()) {
 		auto &storage_manager = db.GetStorageManager();
 		log = storage_manager.GetWriteAheadLog();
@@ -130,7 +130,7 @@ string DuckTransaction::Commit(AttachedDatabase &db, transaction_t commit_id, bo
 		if (log) {
 			// commit any sequences that were used to the WAL
 			for (auto &entry : sequence_usage) {
-				log->WriteSequenceValue(entry.first, entry.second);
+				log->WriteSequenceValue(*entry.first, entry.second);
 			}
 		}
 		if (storage_commit_state) {
@@ -138,7 +138,6 @@ string DuckTransaction::Commit(AttachedDatabase &db, transaction_t commit_id, bo
 		}
 		return string();
 	} catch (std::exception &ex) {
-		undo_buffer.RevertCommit(iterator_state, transaction_id);
 		return ex.what();
 	}
 }

package/src/duckdb/src/transaction/duck_transaction_manager.cpp

@@ -81,7 +81,7 @@ Transaction *DuckTransactionManager::StartTransaction(ClientContext &context) {
 	}
 
 	// create the actual transaction
-	auto transaction = make_unique<DuckTransaction>(*this, context, start_time, transaction_id);
+	auto transaction = make_uniq<DuckTransaction>(*this, context, start_time, transaction_id);
 	auto transaction_ptr = transaction.get();
 
 	// store it in the set of active transactions
@@ -91,7 +91,7 @@ Transaction *DuckTransactionManager::StartTransaction(ClientContext &context) {
 
 struct ClientLockWrapper {
 	ClientLockWrapper(mutex &client_lock, shared_ptr<ClientContext> connection)
-	    : connection(std::move(connection)), connection_lock(make_unique<lock_guard<mutex>>(client_lock)) {
+	    : connection(std::move(connection)), connection_lock(make_uniq<lock_guard<mutex>>(client_lock)) {
 	}
 
 	shared_ptr<ClientContext> connection;
@@ -186,7 +186,7 @@ bool DuckTransactionManager::CanCheckpoint(DuckTransaction *current) {
 string DuckTransactionManager::CommitTransaction(ClientContext &context, Transaction *transaction_p) {
 	auto transaction = (DuckTransaction *)transaction_p;
 	vector<ClientLockWrapper> client_locks;
-	auto lock = make_unique<lock_guard<mutex>>(transaction_lock);
+	auto lock = make_uniq<lock_guard<mutex>>(transaction_lock);
 	CheckpointLock checkpoint_lock(*this);
 	// check if we can checkpoint
 	bool checkpoint = thread_is_checkpointing ? false : CanCheckpoint(transaction);
@@ -199,7 +199,7 @@ string DuckTransactionManager::CommitTransaction(ClientContext &context, Transac
 
 			LockClients(client_locks, context);
 
-			lock = make_unique<lock_guard<mutex>>(transaction_lock);
+			lock = make_uniq<lock_guard<mutex>>(transaction_lock);
 			checkpoint = CanCheckpoint(transaction);
 			if (!checkpoint) {
 				checkpoint_lock.Unlock();

package/src/duckdb/src/transaction/meta_transaction.cpp

@@ -20,19 +20,19 @@ ValidChecker &ValidChecker::Get(MetaTransaction &transaction) {
 
 Transaction &Transaction::Get(ClientContext &context, AttachedDatabase &db) {
 	auto &meta_transaction = MetaTransaction::Get(context);
-	return meta_transaction.GetTransaction(&db);
+	return meta_transaction.GetTransaction(db);
 }
 
-Transaction &MetaTransaction::GetTransaction(AttachedDatabase *db) {
-	auto entry = transactions.find(db);
+Transaction &MetaTransaction::GetTransaction(AttachedDatabase &db) {
+	auto entry = transactions.find(&db);
 	if (entry == transactions.end()) {
-		auto new_transaction = db->GetTransactionManager().StartTransaction(context);
+		auto new_transaction = db.GetTransactionManager().StartTransaction(context);
 		if (!new_transaction) {
 			throw InternalException("StartTransaction did not return a valid transaction");
 		}
 		new_transaction->active_query = active_query;
-		all_transactions.push_back(db);
-		transactions[db] = new_transaction;
+		all_transactions.push_back(&db);
+		transactions[&db] = new_transaction;
 		return *new_transaction;
 	} else {
 		D_ASSERT(entry->second->active_query == active_query);
@@ -49,7 +49,7 @@ string MetaTransaction::Commit() {
 	// commit transactions in reverse order
 	for (idx_t i = all_transactions.size(); i > 0; i--) {
 		auto db = all_transactions[i - 1];
-		auto entry = transactions.find(db);
+		auto entry = transactions.find(db.get());
 		if (entry == transactions.end()) {
 			throw InternalException("Could not find transaction corresponding to database in MetaTransaction");
 		}
@@ -71,7 +71,7 @@ void MetaTransaction::Rollback() {
 	for (idx_t i = all_transactions.size(); i > 0; i--) {
 		auto db = all_transactions[i - 1];
 		auto &transaction_manager = db->GetTransactionManager();
-		auto entry = transactions.find(db);
+		auto entry = transactions.find(db.get());
 		D_ASSERT(entry != transactions.end());
 		auto transaction = entry->second;
 		transaction_manager.RollbackTransaction(transaction);
@@ -89,20 +89,20 @@ void MetaTransaction::SetActiveQuery(transaction_t query_number) {
 	}
 }
 
-void MetaTransaction::ModifyDatabase(AttachedDatabase *db) {
-	if (db->IsSystem() || db->IsTemporary()) {
+void MetaTransaction::ModifyDatabase(AttachedDatabase &db) {
+	if (db.IsSystem() || db.IsTemporary()) {
 		// we can always modify the system and temp databases
 		return;
 	}
 	if (!modified_database) {
-		modified_database = db;
+		modified_database = &db;
 		return;
 	}
-	if (db != modified_database) {
+	if (&db != modified_database.get()) {
 		throw TransactionException(
 		    "Attempting to write to database \"%s\" in a transaction that has already modified database \"%s\" - a "
 		    "single transaction can only write to a single attached database.",
-		    db->GetName(), modified_database->GetName());
+		    db.GetName(), modified_database->GetName());
 	}
 }
 

package/src/duckdb/src/transaction/rollback_state.cpp

@@ -18,7 +18,7 @@ void RollbackState::RollbackEntry(UndoFlags type, data_ptr_t data) {
 		// undo this catalog entry
 		auto catalog_entry = Load<CatalogEntry *>(data);
 		D_ASSERT(catalog_entry->set);
-		catalog_entry->set->Undo(catalog_entry);
+		catalog_entry->set->Undo(*catalog_entry);
 		break;
 	}
 	case UndoFlags::INSERT_TUPLE: {
@@ -35,7 +35,7 @@ void RollbackState::RollbackEntry(UndoFlags type, data_ptr_t data) {
 	}
 	case UndoFlags::UPDATE_TUPLE: {
 		auto info = (UpdateInfo *)data;
-		info->segment->RollbackUpdate(info);
+		info->segment->RollbackUpdate(*info);
 		break;
 	}
 	default: // LCOV_EXCL_START

package/src/duckdb/src/transaction/transaction.cpp

@@ -18,7 +18,7 @@ bool Transaction::IsReadOnly() {
 		throw InternalException("Transaction::IsReadOnly() called after client context has been destroyed");
 	}
 	auto &db = manager.GetDB();
-	return MetaTransaction::Get(*ctxt).ModifiedDatabase() != &db;
+	return MetaTransaction::Get(*ctxt).ModifiedDatabase().get() != &db;
 }
 
 } // namespace duckdb

package/src/duckdb/src/transaction/transaction_context.cpp

@@ -27,14 +27,14 @@ void TransactionContext::BeginTransaction() {
 	}
 	auto start_timestamp = Timestamp::GetCurrentTimestamp();
 	auto catalog_version = Catalog::GetSystemCatalog(context).GetCatalogVersion();
-	current_transaction = make_unique<MetaTransaction>(context, start_timestamp, catalog_version);
+	current_transaction = make_uniq<MetaTransaction>(context, start_timestamp, catalog_version);
 
 	auto &config = DBConfig::GetConfig(context);
 	if (config.options.immediate_transaction_mode) {
 		// if immediate transaction mode is enabled then start all transactions immediately
 		auto databases = DatabaseManager::Get(context).GetDatabases(context);
 		for (auto db : databases) {
-			current_transaction->GetTransaction(db);
+			current_transaction->GetTransaction(db.get());
 		}
 	}
 }

package/src/duckdb/src/transaction/undo_buffer.cpp

@@ -126,9 +126,18 @@ void UndoBuffer::Cleanup() {
 	CleanupState state;
 	UndoBuffer::IteratorState iterator_state;
 	IterateEntries(iterator_state, [&](UndoFlags type, data_ptr_t data) { state.CleanupEntry(type, data); });
+
+	// possibly vacuum indexes
+	for (const auto &table : state.indexed_tables) {
+		table.second->info->indexes.Scan([&](Index &index) {
+			index.Vacuum();
+			return false;
+		});
+	}
 }
 
-void UndoBuffer::Commit(UndoBuffer::IteratorState &iterator_state, WriteAheadLog *log, transaction_t commit_id) {
+void UndoBuffer::Commit(UndoBuffer::IteratorState &iterator_state, optional_ptr<WriteAheadLog> log,
+                        transaction_t commit_id) {
 	CommitState state(context, commit_id, log);
 	if (log) {
 		// commit WITH write ahead log

package/src/duckdb/src/verification/copied_statement_verifier.cpp

@@ -7,7 +7,7 @@ CopiedStatementVerifier::CopiedStatementVerifier(unique_ptr<SQLStatement> statem
 }
 
 unique_ptr<StatementVerifier> CopiedStatementVerifier::Create(const SQLStatement &statement) {
-	return make_unique<CopiedStatementVerifier>(statement.Copy());
+	return make_uniq<CopiedStatementVerifier>(statement.Copy());
 }
 
 } // namespace duckdb

package/src/duckdb/src/verification/deserialized_statement_verifier.cpp

@@ -1,7 +1,7 @@
 #include "duckdb/verification/deserialized_statement_verifier.hpp"
-
 #include "duckdb/common/serializer/buffered_deserializer.hpp"
-
+#include "duckdb/common/serializer/binary_serializer.hpp"
+#include "duckdb/common/serializer/binary_deserializer.hpp"
 namespace duckdb {
 
 DeserializedStatementVerifier::DeserializedStatementVerifier(unique_ptr<SQLStatement> statement_p)
@@ -9,11 +9,11 @@ DeserializedStatementVerifier::DeserializedStatementVerifier(unique_ptr<SQLState
 }
 
 unique_ptr<StatementVerifier> DeserializedStatementVerifier::Create(const SQLStatement &statement) {
-	auto &select_stmt = (SelectStatement &)statement;
+	auto &select_stmt = statement.Cast<SelectStatement>();
 	BufferedSerializer serializer;
 	select_stmt.Serialize(serializer);
 	BufferedDeserializer source(serializer);
-	return make_unique<DeserializedStatementVerifier>(SelectStatement::Deserialize(source));
+	return make_uniq<DeserializedStatementVerifier>(SelectStatement::Deserialize(source));
 }
 
 } // namespace duckdb

package/src/duckdb/src/verification/deserialized_statement_verifier_v2.cpp

@@ -0,0 +1,20 @@
+#include "duckdb/verification/deserialized_statement_verifier_v2.hpp"
+#include "duckdb/common/serializer/buffered_deserializer.hpp"
+#include "duckdb/common/serializer/binary_serializer.hpp"
+#include "duckdb/common/serializer/binary_deserializer.hpp"
+namespace duckdb {
+
+DeserializedStatementVerifierV2::DeserializedStatementVerifierV2(unique_ptr<SQLStatement> statement_p)
+    : StatementVerifier(VerificationType::DESERIALIZED_V2, "Deserialized V2", std::move(statement_p)) {
+}
+
+unique_ptr<StatementVerifier> DeserializedStatementVerifierV2::Create(const SQLStatement &statement) {
+	auto &select_stmt = statement.Cast<SelectStatement>();
+
+	auto blob = BinarySerializer::Serialize(select_stmt);
+	auto result = BinaryDeserializer::Deserialize<SelectStatement>(blob.data(), blob.size());
+
+	return make_uniq<DeserializedStatementVerifierV2>(std::move(result));
+}
+
+} // namespace duckdb

package/src/duckdb/src/verification/external_statement_verifier.cpp

@@ -7,7 +7,7 @@ ExternalStatementVerifier::ExternalStatementVerifier(unique_ptr<SQLStatement> st
 }
 
 unique_ptr<StatementVerifier> ExternalStatementVerifier::Create(const SQLStatement &statement) {
-	return make_unique<ExternalStatementVerifier>(statement.Copy());
+	return make_uniq<ExternalStatementVerifier>(statement.Copy());
 }
 
 } // namespace duckdb

package/src/duckdb/src/verification/no_operator_caching_verifier.cpp

@@ -0,0 +1,13 @@
+#include "duckdb/verification/no_operator_caching_verifier.hpp"
+
+namespace duckdb {
+
+NoOperatorCachingVerifier::NoOperatorCachingVerifier(unique_ptr<SQLStatement> statement_p)
+    : StatementVerifier(VerificationType::NO_OPERATOR_CACHING, "No operator caching", std::move(statement_p)) {
+}
+
+unique_ptr<StatementVerifier> NoOperatorCachingVerifier::Create(const SQLStatement &statement_p) {
+	return make_uniq<NoOperatorCachingVerifier>(statement_p.Copy());
+}
+
+} // namespace duckdb

package/src/duckdb/src/verification/parsed_statement_verifier.cpp

@@ -18,7 +18,7 @@ unique_ptr<StatementVerifier> ParsedStatementVerifier::Create(const SQLStatement
 	}
 	D_ASSERT(parser.statements.size() == 1);
 	D_ASSERT(parser.statements[0]->type == StatementType::SELECT_STATEMENT);
-	return make_unique<ParsedStatementVerifier>(std::move(parser.statements[0]));
+	return make_uniq<ParsedStatementVerifier>(std::move(parser.statements[0]));
 }
 
 } // namespace duckdb

package/src/duckdb/src/verification/prepared_statement_verifier.cpp

@@ -14,7 +14,7 @@ PreparedStatementVerifier::PreparedStatementVerifier(unique_ptr<SQLStatement> st
 }
 
 unique_ptr<StatementVerifier> PreparedStatementVerifier::Create(const SQLStatement &statement) {
-	return make_unique<PreparedStatementVerifier>(statement.Copy());
+	return make_uniq<PreparedStatementVerifier>(statement.Copy());
 }
 
 void PreparedStatementVerifier::Extract() {
@@ -25,15 +25,15 @@ void PreparedStatementVerifier::Extract() {
 	statement->n_param = values.size();
 	// create the PREPARE and EXECUTE statements
 	string name = "__duckdb_verification_prepared_statement";
-	auto prepare = make_unique<PrepareStatement>();
+	auto prepare = make_uniq<PrepareStatement>();
 	prepare->name = name;
 	prepare->statement = std::move(statement);
 
-	auto execute = make_unique<ExecuteStatement>();
+	auto execute = make_uniq<ExecuteStatement>();
 	execute->name = name;
 	execute->values = std::move(values);
 
-	auto dealloc = make_unique<DropStatement>();
+	auto dealloc = make_uniq<DropStatement>();
 	dealloc->info->type = CatalogType::PREPARED_STATEMENT;
 	dealloc->info->name = string(name);
 
@@ -60,7 +60,7 @@ void PreparedStatementVerifier::ConvertConstants(unique_ptr<ParsedExpression> &c
 			values.push_back(std::move(child));
 		}
 		// replace it with an expression
-		auto parameter = make_unique<ParameterExpression>();
+		auto parameter = make_uniq<ParameterExpression>();
 		parameter->parameter_nr = index + 1;
 		parameter->alias = alias;
 		child = std::move(parameter);
@@ -90,11 +90,11 @@ bool PreparedStatementVerifier::Run(
 		materialized_result = unique_ptr_cast<QueryResult, MaterializedQueryResult>(std::move(execute_result));
 	} catch (const Exception &ex) {
 		if (ex.type != ExceptionType::PARAMETER_NOT_ALLOWED) {
-			materialized_result = make_unique<MaterializedQueryResult>(PreservedError(ex));
+			materialized_result = make_uniq<MaterializedQueryResult>(PreservedError(ex));
 		}
 		failed = true;
 	} catch (std::exception &ex) {
-		materialized_result = make_unique<MaterializedQueryResult>(PreservedError(ex));
+		materialized_result = make_uniq<MaterializedQueryResult>(PreservedError(ex));
 		failed = true;
 	}
 	run(string(), std::move(dealloc_statement));

package/src/duckdb/src/verification/statement_verifier.cpp

@@ -1,14 +1,16 @@
 #include "duckdb/verification/statement_verifier.hpp"
 
 #include "duckdb/common/preserved_error.hpp"
-#include "duckdb/common/types/column_data_collection.hpp"
+#include "duckdb/common/types/column/column_data_collection.hpp"
 #include "duckdb/parser/parser.hpp"
 #include "duckdb/verification/copied_statement_verifier.hpp"
 #include "duckdb/verification/deserialized_statement_verifier.hpp"
+#include "duckdb/verification/deserialized_statement_verifier_v2.hpp"
 #include "duckdb/verification/external_statement_verifier.hpp"
 #include "duckdb/verification/parsed_statement_verifier.hpp"
 #include "duckdb/verification/prepared_statement_verifier.hpp"
 #include "duckdb/verification/unoptimized_statement_verifier.hpp"
+#include "duckdb/verification/no_operator_caching_verifier.hpp"
 
 namespace duckdb {
 
@@ -31,10 +33,14 @@ unique_ptr<StatementVerifier> StatementVerifier::Create(VerificationType type, c
 		return CopiedStatementVerifier::Create(statement_p);
 	case VerificationType::DESERIALIZED:
 		return DeserializedStatementVerifier::Create(statement_p);
+	case VerificationType::DESERIALIZED_V2:
+		return DeserializedStatementVerifierV2::Create(statement_p);
 	case VerificationType::PARSED:
 		return ParsedStatementVerifier::Create(statement_p);
 	case VerificationType::UNOPTIMIZED:
 		return UnoptimizedStatementVerifier::Create(statement_p);
+	case VerificationType::NO_OPERATOR_CACHING:
+		return NoOperatorCachingVerifier::Create(statement_p);
 	case VerificationType::PREPARED:
 		return PreparedStatementVerifier::Create(statement_p);
 	case VerificationType::EXTERNAL:
@@ -104,6 +110,7 @@ bool StatementVerifier::Run(
 
 	context.interrupted = false;
 	context.config.enable_optimizer = !DisableOptimizer();
+	context.config.enable_caching_operators = !DisableOperatorCaching();
 	context.config.force_external = ForceExternal();
 	try {
 		auto result = run(query, std::move(statement));
@@ -113,10 +120,10 @@ bool StatementVerifier::Run(
 		materialized_result = unique_ptr_cast<QueryResult, MaterializedQueryResult>(std::move(result));
 	} catch (const Exception &ex) {
 		failed = true;
-		materialized_result = make_unique<MaterializedQueryResult>(PreservedError(ex));
+		materialized_result = make_uniq<MaterializedQueryResult>(PreservedError(ex));
 	} catch (std::exception &ex) {
 		failed = true;
-		materialized_result = make_unique<MaterializedQueryResult>(PreservedError(ex));
+		materialized_result = make_uniq<MaterializedQueryResult>(PreservedError(ex));
 	}
 	context.interrupted = false;
 

package/src/duckdb/src/verification/unoptimized_statement_verifier.cpp

@@ -7,7 +7,7 @@ UnoptimizedStatementVerifier::UnoptimizedStatementVerifier(unique_ptr<SQLStateme
 }
 
 unique_ptr<StatementVerifier> UnoptimizedStatementVerifier::Create(const SQLStatement &statement_p) {
-	return make_unique<UnoptimizedStatementVerifier>(statement_p.Copy());
+	return make_uniq<UnoptimizedStatementVerifier>(statement_p.Copy());
 }
 
 } // namespace duckdb

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