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

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

@@ -1,331 +1,11 @@
 #include "duckdb/transaction/transaction_manager.hpp"
 
-#include "duckdb/catalog/catalog_set.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/types/timestamp.hpp"
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/dependency_manager.hpp"
-#include "duckdb/storage/storage_manager.hpp"
-#include "duckdb/transaction/transaction.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/connection_manager.hpp"
-#include "duckdb/main/attached_database.hpp"
-#include "duckdb/main/database_manager.hpp"
-
 namespace duckdb {
 
-struct CheckpointLock {
-	explicit CheckpointLock(TransactionManager &manager) : manager(manager), is_locked(false) {
-	}
-	~CheckpointLock() {
-		Unlock();
-	}
-
-	TransactionManager &manager;
-	bool is_locked;
-
-	void Lock() {
-		D_ASSERT(!manager.thread_is_checkpointing);
-		manager.thread_is_checkpointing = true;
-		is_locked = true;
-	}
-	void Unlock() {
-		if (!is_locked) {
-			return;
-		}
-		D_ASSERT(manager.thread_is_checkpointing);
-		manager.thread_is_checkpointing = false;
-		is_locked = false;
-	}
-};
-
-TransactionManager::TransactionManager(AttachedDatabase &db) : db(db), thread_is_checkpointing(false) {
-	// start timestamp starts at two
-	current_start_timestamp = 2;
-	// transaction ID starts very high:
-	// it should be much higher than the current start timestamp
-	// if transaction_id < start_timestamp for any set of active transactions
-	// uncommited data could be read by
-	current_transaction_id = TRANSACTION_ID_START;
-	lowest_active_id = TRANSACTION_ID_START;
-	lowest_active_start = MAX_TRANSACTION_ID;
+TransactionManager::TransactionManager(AttachedDatabase &db) : db(db) {
 }
 
 TransactionManager::~TransactionManager() {
 }
 
-Transaction *TransactionManager::StartTransaction(ClientContext &context) {
-	// obtain the transaction lock during this function
-	lock_guard<mutex> lock(transaction_lock);
-	if (current_start_timestamp >= TRANSACTION_ID_START) { // LCOV_EXCL_START
-		throw InternalException("Cannot start more transactions, ran out of "
-		                        "transaction identifiers!");
-	} // LCOV_EXCL_STOP
-
-	// obtain the start time and transaction ID of this transaction
-	transaction_t start_time = current_start_timestamp++;
-	transaction_t transaction_id = current_transaction_id++;
-	if (active_transactions.empty()) {
-		lowest_active_start = start_time;
-		lowest_active_id = transaction_id;
-	}
-
-	// create the actual transaction
-	auto transaction = make_unique<Transaction>(*this, context, start_time, transaction_id);
-	auto transaction_ptr = transaction.get();
-
-	// store it in the set of active transactions
-	active_transactions.push_back(move(transaction));
-	return transaction_ptr;
-}
-
-struct ClientLockWrapper {
-	ClientLockWrapper(mutex &client_lock, shared_ptr<ClientContext> connection)
-	    : connection(move(connection)), connection_lock(make_unique<lock_guard<mutex>>(client_lock)) {
-	}
-
-	shared_ptr<ClientContext> connection;
-	unique_ptr<lock_guard<mutex>> connection_lock;
-};
-
-void TransactionManager::LockClients(vector<ClientLockWrapper> &client_locks, ClientContext &context) {
-	auto &connection_manager = ConnectionManager::Get(context);
-	client_locks.emplace_back(connection_manager.connections_lock, nullptr);
-	auto connection_list = connection_manager.GetConnectionList();
-	for (auto &con : connection_list) {
-		if (con.get() == &context) {
-			continue;
-		}
-		auto &context_lock = con->context_lock;
-		client_locks.emplace_back(context_lock, move(con));
-	}
-}
-
-void TransactionManager::Checkpoint(ClientContext &context, bool force) {
-	auto &storage_manager = db.GetStorageManager();
-	if (storage_manager.InMemory()) {
-		return;
-	}
-
-	// first check if no other thread is checkpointing right now
-	auto lock = unique_lock<mutex>(transaction_lock);
-	if (thread_is_checkpointing) {
-		throw TransactionException("Cannot CHECKPOINT: another thread is checkpointing right now");
-	}
-	CheckpointLock checkpoint_lock(*this);
-	checkpoint_lock.Lock();
-	lock.unlock();
-
-	// lock all the clients AND the connection manager now
-	// this ensures no new queries can be started, and no new connections to the database can be made
-	// to avoid deadlock we release the transaction lock while locking the clients
-	vector<ClientLockWrapper> client_locks;
-	LockClients(client_locks, context);
-
-	auto current = &Transaction::Get(context, db);
-	lock.lock();
-	if (current->ChangesMade()) {
-		throw TransactionException("Cannot CHECKPOINT: the current transaction has transaction local changes");
-	}
-	if (!force) {
-		if (!CanCheckpoint(current)) {
-			throw TransactionException("Cannot CHECKPOINT: there are other transactions. Use FORCE CHECKPOINT to abort "
-			                           "the other transactions and force a checkpoint");
-		}
-	} else {
-		if (!CanCheckpoint(current)) {
-			for (size_t i = 0; i < active_transactions.size(); i++) {
-				auto &transaction = active_transactions[i];
-				// rollback the transaction
-				transaction->Rollback();
-				auto transaction_context = transaction->context.lock();
-
-				// remove the transaction id from the list of active transactions
-				// potentially resulting in garbage collection
-				RemoveTransaction(transaction.get());
-				if (transaction_context) {
-					transaction_context->transaction.ClearTransaction();
-				}
-				i--;
-			}
-			D_ASSERT(CanCheckpoint(nullptr));
-		}
-	}
-	storage_manager.CreateCheckpoint();
-}
-
-bool TransactionManager::CanCheckpoint(Transaction *current) {
-	if (db.IsSystem()) {
-		return false;
-	}
-	auto &storage_manager = db.GetStorageManager();
-	if (storage_manager.InMemory()) {
-		return false;
-	}
-	if (!recently_committed_transactions.empty() || !old_transactions.empty()) {
-		return false;
-	}
-	for (auto &transaction : active_transactions) {
-		if (transaction.get() != current) {
-			return false;
-		}
-	}
-	return true;
-}
-
-string TransactionManager::CommitTransaction(ClientContext &context, Transaction *transaction) {
-	vector<ClientLockWrapper> client_locks;
-	auto lock = make_unique<lock_guard<mutex>>(transaction_lock);
-	CheckpointLock checkpoint_lock(*this);
-	// check if we can checkpoint
-	bool checkpoint = thread_is_checkpointing ? false : CanCheckpoint(transaction);
-	if (checkpoint) {
-		if (transaction->AutomaticCheckpoint(db)) {
-			checkpoint_lock.Lock();
-			// we might be able to checkpoint: lock all clients
-			// to avoid deadlock we release the transaction lock while locking the clients
-			lock.reset();
-
-			LockClients(client_locks, context);
-
-			lock = make_unique<lock_guard<mutex>>(transaction_lock);
-			checkpoint = CanCheckpoint(transaction);
-			if (!checkpoint) {
-				checkpoint_lock.Unlock();
-				client_locks.clear();
-			}
-		} else {
-			checkpoint = false;
-		}
-	}
-	// obtain a commit id for the transaction
-	transaction_t commit_id = current_start_timestamp++;
-	// commit the UndoBuffer of the transaction
-	string error = transaction->Commit(db, commit_id, checkpoint);
-	if (!error.empty()) {
-		// commit unsuccessful: rollback the transaction instead
-		checkpoint = false;
-		transaction->commit_id = 0;
-		transaction->Rollback();
-	}
-	if (!checkpoint) {
-		// we won't checkpoint after all: unlock the clients again
-		checkpoint_lock.Unlock();
-		client_locks.clear();
-	}
-
-	// commit successful: remove the transaction id from the list of active transactions
-	// potentially resulting in garbage collection
-	RemoveTransaction(transaction);
-	// now perform a checkpoint if (1) we are able to checkpoint, and (2) the WAL has reached sufficient size to
-	// checkpoint
-	if (checkpoint) {
-		// checkpoint the database to disk
-		auto &storage_manager = db.GetStorageManager();
-		storage_manager.CreateCheckpoint(false, true);
-	}
-	return error;
-}
-
-void TransactionManager::RollbackTransaction(Transaction *transaction) {
-	// obtain the transaction lock during this function
-	lock_guard<mutex> lock(transaction_lock);
-
-	// rollback the transaction
-	transaction->Rollback();
-
-	// remove the transaction id from the list of active transactions
-	// potentially resulting in garbage collection
-	RemoveTransaction(transaction);
-}
-
-void TransactionManager::RemoveTransaction(Transaction *transaction) noexcept {
-	// remove the transaction from the list of active transactions
-	idx_t t_index = active_transactions.size();
-	// check for the lowest and highest start time in the list of transactions
-	transaction_t lowest_start_time = TRANSACTION_ID_START;
-	transaction_t lowest_transaction_id = MAX_TRANSACTION_ID;
-	transaction_t lowest_active_query = MAXIMUM_QUERY_ID;
-	for (idx_t i = 0; i < active_transactions.size(); i++) {
-		if (active_transactions[i].get() == transaction) {
-			t_index = i;
-		} else {
-			transaction_t active_query = active_transactions[i]->active_query;
-			lowest_start_time = MinValue(lowest_start_time, active_transactions[i]->start_time);
-			lowest_active_query = MinValue(lowest_active_query, active_query);
-			lowest_transaction_id = MinValue(lowest_transaction_id, active_transactions[i]->transaction_id);
-		}
-	}
-	lowest_active_start = lowest_start_time;
-	lowest_active_id = lowest_transaction_id;
-
-	transaction_t lowest_stored_query = lowest_start_time;
-	D_ASSERT(t_index != active_transactions.size());
-	auto current_transaction = move(active_transactions[t_index]);
-	auto current_query = DatabaseManager::Get(db).ActiveQueryNumber();
-	if (transaction->commit_id != 0) {
-		// the transaction was committed, add it to the list of recently
-		// committed transactions
-		recently_committed_transactions.push_back(move(current_transaction));
-	} else {
-		// the transaction was aborted, but we might still need its information
-		// add it to the set of transactions awaiting GC
-		current_transaction->highest_active_query = current_query;
-		old_transactions.push_back(move(current_transaction));
-	}
-	// remove the transaction from the set of currently active transactions
-	active_transactions.erase(active_transactions.begin() + t_index);
-	// traverse the recently_committed transactions to see if we can remove any
-	idx_t i = 0;
-	for (; i < recently_committed_transactions.size(); i++) {
-		D_ASSERT(recently_committed_transactions[i]);
-		lowest_stored_query = MinValue(recently_committed_transactions[i]->start_time, lowest_stored_query);
-		if (recently_committed_transactions[i]->commit_id < lowest_start_time) {
-			// changes made BEFORE this transaction are no longer relevant
-			// we can cleanup the undo buffer
-
-			// HOWEVER: any currently running QUERY can still be using
-			// the version information after the cleanup!
-
-			// if we remove the UndoBuffer immediately, we have a race
-			// condition
-
-			// we can only safely do the actual memory cleanup when all the
-			// currently active queries have finished running! (actually,
-			// when all the currently active scans have finished running...)
-			recently_committed_transactions[i]->Cleanup();
-			// store the current highest active query
-			recently_committed_transactions[i]->highest_active_query = current_query;
-			// move it to the list of transactions awaiting GC
-			old_transactions.push_back(move(recently_committed_transactions[i]));
-		} else {
-			// recently_committed_transactions is ordered on commit_id
-			// implicitly thus if the current one is bigger than
-			// lowest_start_time any subsequent ones are also bigger
-			break;
-		}
-	}
-	if (i > 0) {
-		// we garbage collected transactions: remove them from the list
-		recently_committed_transactions.erase(recently_committed_transactions.begin(),
-		                                      recently_committed_transactions.begin() + i);
-	}
-	// check if we can free the memory of any old transactions
-	i = active_transactions.empty() ? old_transactions.size() : 0;
-	for (; i < old_transactions.size(); i++) {
-		D_ASSERT(old_transactions[i]);
-		D_ASSERT(old_transactions[i]->highest_active_query > 0);
-		if (old_transactions[i]->highest_active_query >= lowest_active_query) {
-			// there is still a query running that could be using
-			// this transactions' data
-			break;
-		}
-	}
-	if (i > 0) {
-		// we garbage collected transactions: remove them from the list
-		old_transactions.erase(old_transactions.begin(), old_transactions.begin() + i);
-	}
-}
-
 } // namespace duckdb

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

@@ -3,7 +3,7 @@
 namespace duckdb {
 
 CopiedStatementVerifier::CopiedStatementVerifier(unique_ptr<SQLStatement> statement_p)
-    : StatementVerifier(VerificationType::COPIED, "Copied", move(statement_p)) {
+    : StatementVerifier(VerificationType::COPIED, "Copied", std::move(statement_p)) {
 }
 
 unique_ptr<StatementVerifier> CopiedStatementVerifier::Create(const SQLStatement &statement) {

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

@@ -5,7 +5,7 @@
 namespace duckdb {
 
 DeserializedStatementVerifier::DeserializedStatementVerifier(unique_ptr<SQLStatement> statement_p)
-    : StatementVerifier(VerificationType::DESERIALIZED, "Deserialized", move(statement_p)) {
+    : StatementVerifier(VerificationType::DESERIALIZED, "Deserialized", std::move(statement_p)) {
 }
 
 unique_ptr<StatementVerifier> DeserializedStatementVerifier::Create(const SQLStatement &statement) {

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

@@ -3,7 +3,7 @@
 namespace duckdb {
 
 ExternalStatementVerifier::ExternalStatementVerifier(unique_ptr<SQLStatement> statement_p)
-    : StatementVerifier(VerificationType::EXTERNAL, "External", move(statement_p)) {
+    : StatementVerifier(VerificationType::EXTERNAL, "External", std::move(statement_p)) {
 }
 
 unique_ptr<StatementVerifier> ExternalStatementVerifier::Create(const SQLStatement &statement) {

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

@@ -5,7 +5,7 @@
 namespace duckdb {
 
 ParsedStatementVerifier::ParsedStatementVerifier(unique_ptr<SQLStatement> statement_p)
-    : StatementVerifier(VerificationType::PARSED, "Parsed", move(statement_p)) {
+    : StatementVerifier(VerificationType::PARSED, "Parsed", std::move(statement_p)) {
 }
 
 unique_ptr<StatementVerifier> ParsedStatementVerifier::Create(const SQLStatement &statement) {
@@ -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>(move(parser.statements[0]));
+	return make_unique<ParsedStatementVerifier>(std::move(parser.statements[0]));
 }
 
 } // namespace duckdb

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

@@ -10,7 +10,7 @@
 namespace duckdb {
 
 PreparedStatementVerifier::PreparedStatementVerifier(unique_ptr<SQLStatement> statement_p)
-    : StatementVerifier(VerificationType::PREPARED, "Prepared", move(statement_p)) {
+    : StatementVerifier(VerificationType::PREPARED, "Prepared", std::move(statement_p)) {
 }
 
 unique_ptr<StatementVerifier> PreparedStatementVerifier::Create(const SQLStatement &statement) {
@@ -27,19 +27,19 @@ void PreparedStatementVerifier::Extract() {
 	string name = "__duckdb_verification_prepared_statement";
 	auto prepare = make_unique<PrepareStatement>();
 	prepare->name = name;
-	prepare->statement = move(statement);
+	prepare->statement = std::move(statement);
 
 	auto execute = make_unique<ExecuteStatement>();
 	execute->name = name;
-	execute->values = move(values);
+	execute->values = std::move(values);
 
 	auto dealloc = make_unique<DropStatement>();
 	dealloc->info->type = CatalogType::PREPARED_STATEMENT;
 	dealloc->info->name = string(name);
 
-	prepare_statement = move(prepare);
-	execute_statement = move(execute);
-	dealloc_statement = move(dealloc);
+	prepare_statement = std::move(prepare);
+	execute_statement = std::move(execute);
+	dealloc_statement = std::move(dealloc);
 }
 
 void PreparedStatementVerifier::ConvertConstants(unique_ptr<ParsedExpression> &child) {
@@ -57,13 +57,13 @@ void PreparedStatementVerifier::ConvertConstants(unique_ptr<ParsedExpression> &c
 			}
 		}
 		if (index == values.size()) {
-			values.push_back(move(child));
+			values.push_back(std::move(child));
 		}
 		// replace it with an expression
 		auto parameter = make_unique<ParameterExpression>();
 		parameter->parameter_nr = index + 1;
 		parameter->alias = alias;
-		child = move(parameter);
+		child = std::move(parameter);
 		return;
 	}
 	ParsedExpressionIterator::EnumerateChildren(*child,
@@ -79,15 +79,15 @@ bool PreparedStatementVerifier::Run(
 	Extract();
 	// execute the prepared statements
 	try {
-		auto prepare_result = run(string(), move(prepare_statement));
+		auto prepare_result = run(string(), std::move(prepare_statement));
 		if (prepare_result->HasError()) {
 			prepare_result->ThrowError("Failed prepare during verify: ");
 		}
-		auto execute_result = run(string(), move(execute_statement));
+		auto execute_result = run(string(), std::move(execute_statement));
 		if (execute_result->HasError()) {
 			execute_result->ThrowError("Failed execute during verify: ");
 		}
-		materialized_result = unique_ptr_cast<QueryResult, MaterializedQueryResult>(move(execute_result));
+		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));
@@ -97,7 +97,7 @@ bool PreparedStatementVerifier::Run(
 		materialized_result = make_unique<MaterializedQueryResult>(PreservedError(ex));
 		failed = true;
 	}
-	run(string(), move(dealloc_statement));
+	run(string(), std::move(dealloc_statement));
 	context.interrupted = false;
 
 	return failed;

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

@@ -13,12 +13,13 @@
 namespace duckdb {
 
 StatementVerifier::StatementVerifier(VerificationType type, string name, unique_ptr<SQLStatement> statement_p)
-    : type(type), name(move(name)), statement(unique_ptr_cast<SQLStatement, SelectStatement>(move(statement_p))),
+    : type(type), name(std::move(name)),
+      statement(unique_ptr_cast<SQLStatement, SelectStatement>(std::move(statement_p))),
       select_list(statement->node->GetSelectList()) {
 }
 
 StatementVerifier::StatementVerifier(unique_ptr<SQLStatement> statement_p)
-    : StatementVerifier(VerificationType::ORIGINAL, "Original", move(statement_p)) {
+    : StatementVerifier(VerificationType::ORIGINAL, "Original", std::move(statement_p)) {
 }
 
 StatementVerifier::~StatementVerifier() noexcept {
@@ -105,11 +106,11 @@ bool StatementVerifier::Run(
 	context.config.enable_optimizer = !DisableOptimizer();
 	context.config.force_external = ForceExternal();
 	try {
-		auto result = run(query, move(statement));
+		auto result = run(query, std::move(statement));
 		if (result->HasError()) {
 			failed = true;
 		}
-		materialized_result = unique_ptr_cast<QueryResult, MaterializedQueryResult>(move(result));
+		materialized_result = unique_ptr_cast<QueryResult, MaterializedQueryResult>(std::move(result));
 	} catch (const Exception &ex) {
 		failed = true;
 		materialized_result = make_unique<MaterializedQueryResult>(PreservedError(ex));

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

@@ -3,7 +3,7 @@
 namespace duckdb {
 
 UnoptimizedStatementVerifier::UnoptimizedStatementVerifier(unique_ptr<SQLStatement> statement_p)
-    : StatementVerifier(VerificationType::UNOPTIMIZED, "Unoptimized", move(statement_p)) {
+    : StatementVerifier(VerificationType::UNOPTIMIZED, "Unoptimized", std::move(statement_p)) {
 }
 
 unique_ptr<StatementVerifier> UnoptimizedStatementVerifier::Create(const SQLStatement &statement_p) {

package/src/duckdb/third_party/fast_float/fast_float/fast_float.h

@@ -75,7 +75,9 @@ struct from_chars_result {
  */
 template<typename T>
 from_chars_result from_chars(const char *first, const char *last,
-                             T &value, chars_format fmt = chars_format::general)  noexcept;
+                             T &value,
+                             const char decimal_separator = '.',
+                             chars_format fmt = chars_format::general)  noexcept;
 
 }
 #endif // FASTFLOAT_FAST_FLOAT_H
@@ -500,7 +502,7 @@ struct parsed_number_string {
 // Assuming that you use no more than 19 digits, this will
 // parse an ASCII string.
 fastfloat_really_inline
-parsed_number_string parse_number_string(const char *p, const char *pend, chars_format fmt) noexcept {
+parsed_number_string parse_number_string(const char *p, const char *pend, const char decimal_separator, chars_format fmt) noexcept {
   parsed_number_string answer;
   answer.valid = false;
   answer.too_many_digits = false;
@@ -510,7 +512,7 @@ parsed_number_string parse_number_string(const char *p, const char *pend, chars_
     if (p == pend) {
       return answer;
     }
-    if (!is_integer(*p) && (*p != '.')) { // a  sign must be followed by an integer or the dot
+    if (!is_integer(*p) && (*p != decimal_separator)) { // a  sign must be followed by an integer or the dot
       return answer;
     }
   }
@@ -528,7 +530,7 @@ parsed_number_string parse_number_string(const char *p, const char *pend, chars_
   const char *const end_of_integer_part = p;
   int64_t digit_count = int64_t(end_of_integer_part - start_digits);
   int64_t exponent = 0;
-  if ((p != pend) && (*p == '.')) {
+  if ((p != pend) && (*p == decimal_separator)) {
     ++p;
   // Fast approach only tested under little endian systems
   if ((p + 8 <= pend) && is_made_of_eight_digits_fast(p)) {
@@ -598,7 +600,7 @@ parsed_number_string parse_number_string(const char *p, const char *pend, chars_
     // We need to be mindful of the case where we only have zeroes...
     // E.g., 0.000000000...000.
     const char *start = start_digits;
-    while ((start != pend) && (*start == '0' || *start == '.')) {
+    while ((start != pend) && (*start == '0' || *start == decimal_separator)) {
       if(*start == '0') { digit_count --; }
       start++;
     }
@@ -615,7 +617,7 @@ parsed_number_string parse_number_string(const char *p, const char *pend, chars_
       if (i >= minimal_nineteen_digit_integer) { // We have a big integers
         exponent = end_of_integer_part - p + exp_number;
       } else { // We have a value with a fractional component.
-          p++; // skip the '.'
+          p++; // skip the decimal_separator
           const char *first_after_period = p;
           while((i < minimal_nineteen_digit_integer) && (p != pend) && is_integer(*p)) {
             i = i * 10 + uint64_t(*p - '0');
@@ -636,7 +638,7 @@ parsed_number_string parse_number_string(const char *p, const char *pend, chars_
 // This function could be optimized. In particular, we could stop after 19 digits
 // and try to bail out. Furthermore, we should be able to recover the computed
 // exponent from the pass in parse_number_string.
-fastfloat_really_inline decimal parse_decimal(const char *p, const char *pend) noexcept {
+fastfloat_really_inline decimal parse_decimal(const char *p, const char *pend, const char decimal_separator = '.') noexcept {
   decimal answer;
   answer.num_digits = 0;
   answer.decimal_point = 0;
@@ -656,7 +658,7 @@ fastfloat_really_inline decimal parse_decimal(const char *p, const char *pend) n
     answer.num_digits++;
     ++p;
   }
-  if ((p != pend) && (*p == '.')) {
+  if ((p != pend) && (*p == decimal_separator)) {
     ++p;
     const char *first_after_period = p;
     // if we have not yet encountered a zero, we have to skip it as well
@@ -695,7 +697,7 @@ fastfloat_really_inline decimal parse_decimal(const char *p, const char *pend) n
     // we have at least one non-zero digit.
     const char *preverse = p - 1;
     int32_t trailing_zeros = 0;
-    while ((*preverse == '0') || (*preverse == '.')) {
+    while ((*preverse == '0') || (*preverse == decimal_separator)) {
       if(*preverse == '0') { trailing_zeros++; };
       --preverse;
     }
@@ -1691,7 +1693,7 @@ struct parsed_number_string {
 // Assuming that you use no more than 19 digits, this will
 // parse an ASCII string.
 fastfloat_really_inline
-parsed_number_string parse_number_string(const char *p, const char *pend, chars_format fmt) noexcept {
+parsed_number_string parse_number_string(const char *p, const char *pend, const char decimal_separator, chars_format fmt) noexcept {
   parsed_number_string answer;
   answer.valid = false;
   answer.too_many_digits = false;
@@ -1701,7 +1703,7 @@ parsed_number_string parse_number_string(const char *p, const char *pend, chars_
     if (p == pend) {
       return answer;
     }
-    if (!is_integer(*p) && (*p != '.')) { // a  sign must be followed by an integer or the dot
+    if (!is_integer(*p) && (*p != decimal_separator)) { // a  sign must be followed by an integer or the dot
       return answer;
     }
   }
@@ -1719,7 +1721,7 @@ parsed_number_string parse_number_string(const char *p, const char *pend, chars_
   const char *const end_of_integer_part = p;
   int64_t digit_count = int64_t(end_of_integer_part - start_digits);
   int64_t exponent = 0;
-  if ((p != pend) && (*p == '.')) {
+  if ((p != pend) && (*p == decimal_separator)) {
     ++p;
   // Fast approach only tested under little endian systems
   if ((p + 8 <= pend) && is_made_of_eight_digits_fast(p)) {
@@ -1789,7 +1791,7 @@ parsed_number_string parse_number_string(const char *p, const char *pend, chars_
     // We need to be mindful of the case where we only have zeroes...
     // E.g., 0.000000000...000.
     const char *start = start_digits;
-    while ((start != pend) && (*start == '0' || *start == '.')) {
+    while ((start != pend) && (*start == '0' || *start == decimal_separator)) {
       if(*start == '0') { digit_count --; }
       start++;
     }
@@ -1806,7 +1808,7 @@ parsed_number_string parse_number_string(const char *p, const char *pend, chars_
       if (i >= minimal_nineteen_digit_integer) { // We have a big integers
         exponent = end_of_integer_part - p + exp_number;
       } else { // We have a value with a fractional component.
-          p++; // skip the '.'
+          p++; // skip the decimal_separator
           const char *first_after_period = p;
           while((i < minimal_nineteen_digit_integer) && (p != pend) && is_integer(*p)) {
             i = i * 10 + uint64_t(*p - '0');
@@ -1827,7 +1829,7 @@ parsed_number_string parse_number_string(const char *p, const char *pend, chars_
 // This function could be optimized. In particular, we could stop after 19 digits
 // and try to bail out. Furthermore, we should be able to recover the computed
 // exponent from the pass in parse_number_string.
-fastfloat_really_inline decimal parse_decimal(const char *p, const char *pend) noexcept {
+fastfloat_really_inline decimal parse_decimal(const char *p, const char *pend, const char decimal_separator) noexcept {
   decimal answer;
   answer.num_digits = 0;
   answer.decimal_point = 0;
@@ -1847,7 +1849,7 @@ fastfloat_really_inline decimal parse_decimal(const char *p, const char *pend) n
     answer.num_digits++;
     ++p;
   }
-  if ((p != pend) && (*p == '.')) {
+  if ((p != pend) && (*p == decimal_separator)) {
     ++p;
     const char *first_after_period = p;
     // if we have not yet encountered a zero, we have to skip it as well
@@ -1886,7 +1888,7 @@ fastfloat_really_inline decimal parse_decimal(const char *p, const char *pend) n
     // we have at least one non-zero digit.
     const char *preverse = p - 1;
     int32_t trailing_zeros = 0;
-    while ((*preverse == '0') || (*preverse == '.')) {
+    while ((*preverse == '0') || (*preverse == decimal_separator)) {
       if(*preverse == '0') { trailing_zeros++; };
       --preverse;
     }
@@ -2370,7 +2372,8 @@ fastfloat_really_inline void to_float(bool negative, adjusted_mantissa am, T &va
 
 template<typename T>
 from_chars_result from_chars(const char *first, const char *last,
-                             T &value, chars_format fmt /*= chars_format::general*/)  noexcept  {
+                             T &value, const char decimal_separator, chars_format fmt
+                              /*= chars_format::general*/)  noexcept  {
   static_assert (std::is_same<T, double>::value || std::is_same<T, float>::value, "only float and double are supported");
 
 
@@ -2380,7 +2383,7 @@ from_chars_result from_chars(const char *first, const char *last,
     answer.ptr = first;
     return answer;
   }
-  parsed_number_string pns = parse_number_string(first, last, fmt);
+  parsed_number_string pns = parse_number_string(first, last, decimal_separator, fmt);
   if (!pns.valid) {
     return detail::parse_infnan(first, last, value);
   }