Use SettingSeconds only in Settings, use std::chrono::seconds in other places.

src/Core/SettingsCollection.h

@@ -106,7 +106,13 @@ struct SettingTimespan
     SettingTimespan(UInt64 x = 0) : value(x * microseconds_per_io_unit) {}
 
     operator Poco::Timespan() const { return value; }
-    SettingTimespan & operator= (const Poco::Timespan & x) { set(x); return *this; }
+    SettingTimespan & operator=(const Poco::Timespan & x) { set(x); return *this; }
+
+    template <class Rep, class Period = std::ratio<1>>
+    operator std::chrono::duration<Rep, Period>() const { return std::chrono::duration_cast<std::chrono::duration<Rep, Period>>(std::chrono::microseconds(value.totalMicroseconds())); }
+
+    template <class Rep, class Period = std::ratio<1>>
+    SettingTimespan & operator=(const std::chrono::duration<Rep, Period> & x) { set(x); return *this; }
 
     Poco::Timespan::TimeDiff totalSeconds() const { return value.totalSeconds(); }
     Poco::Timespan::TimeDiff totalMilliseconds() const { return value.totalMilliseconds(); }
@@ -116,6 +122,9 @@ struct SettingTimespan
 
     void set(const Poco::Timespan & x);
 
+    template <class Rep, class Period = std::ratio<1>>
+    void set(const std::chrono::duration<Rep, Period> & duration) { set(static_cast<UInt64>(std::chrono::duration_cast<std::chrono::microseconds>(duration).count())); }
+
     void set(UInt64 x);
     void set(const Field & x);
     void set(const String & x);

src/Databases/DatabaseMySQL.cpp

@@ -4,7 +4,6 @@
 
 #if USE_MYSQL
 #    include <string>
-#    include <Core/SettingsCollection.h>
 #    include <DataTypes/DataTypeDateTime.h>
 #    include <DataTypes/DataTypeNullable.h>
 #    include <DataTypes/DataTypeString.h>
@@ -42,7 +41,7 @@ namespace ErrorCodes
 
 constexpr static const auto suffix = ".remove_flag";
 static constexpr const std::chrono::seconds cleaner_sleep_time{30};
-static const SettingSeconds lock_acquire_timeout{10};
+static const std::chrono::seconds lock_acquire_timeout{10};
 
 static String toQueryStringWithQuote(const std::vector<String> & quote_list)
 {

src/Storages/IStorage.cpp

@@ -31,22 +31,22 @@ bool IStorage::isVirtualColumn(const String & column_name, const StorageMetadata
 }
 
 RWLockImpl::LockHolder IStorage::tryLockTimed(
-        const RWLock & rwlock, RWLockImpl::Type type, const String & query_id, const SettingSeconds & acquire_timeout) const
+        const RWLock & rwlock, RWLockImpl::Type type, const String & query_id, const std::chrono::milliseconds & acquire_timeout) const
 {
-    auto lock_holder = rwlock->getLock(type, query_id, std::chrono::milliseconds(acquire_timeout.totalMilliseconds()));
+    auto lock_holder = rwlock->getLock(type, query_id, acquire_timeout);
     if (!lock_holder)
     {
         const String type_str = type == RWLockImpl::Type::Read ? "READ" : "WRITE";
         throw Exception(
                 type_str + " locking attempt on \"" + getStorageID().getFullTableName() +
-                "\" has timed out! (" + toString(acquire_timeout.totalMilliseconds()) + "ms) "
+                "\" has timed out! (" + std::to_string(acquire_timeout.count()) + "ms) "
                 "Possible deadlock avoided. Client should retry.",
                 ErrorCodes::DEADLOCK_AVOIDED);
     }
     return lock_holder;
 }
 
-TableLockHolder IStorage::lockForShare(const String & query_id, const SettingSeconds & acquire_timeout)
+TableLockHolder IStorage::lockForShare(const String & query_id, const std::chrono::milliseconds & acquire_timeout)
 {
     TableLockHolder result = tryLockTimed(drop_lock, RWLockImpl::Read, query_id, acquire_timeout);
 
@@ -56,7 +56,7 @@ TableLockHolder IStorage::lockForShare(const String & query_id, const SettingSec
     return result;
 }
 
-TableLockHolder IStorage::lockForAlter(const String & query_id, const SettingSeconds & acquire_timeout)
+TableLockHolder IStorage::lockForAlter(const String & query_id, const std::chrono::milliseconds & acquire_timeout)
 {
     TableLockHolder result = tryLockTimed(alter_lock, RWLockImpl::Write, query_id, acquire_timeout);
 
@@ -67,7 +67,7 @@ TableLockHolder IStorage::lockForAlter(const String & query_id, const SettingSec
 }
 
 
-TableExclusiveLockHolder IStorage::lockExclusively(const String & query_id, const SettingSeconds & acquire_timeout)
+TableExclusiveLockHolder IStorage::lockExclusively(const String & query_id, const std::chrono::milliseconds & acquire_timeout)
 {
     TableExclusiveLockHolder result;
     result.alter_lock = tryLockTimed(alter_lock, RWLockImpl::Write, query_id, acquire_timeout);

src/Storages/IStorage.h

@@ -185,18 +185,18 @@ private:
     MultiVersionStorageMetadataPtr metadata;
 private:
     RWLockImpl::LockHolder tryLockTimed(
-        const RWLock & rwlock, RWLockImpl::Type type, const String & query_id, const SettingSeconds & acquire_timeout) const;
+        const RWLock & rwlock, RWLockImpl::Type type, const String & query_id, const std::chrono::milliseconds & acquire_timeout) const;
 
 public:
     /// Lock table for share. This lock must be acuqired if you want to be sure,
     /// that table will be not dropped while you holding this lock. It's used in
     /// variety of cases starting from SELECT queries to background merges in
     /// MergeTree.
-    TableLockHolder lockForShare(const String & query_id, const SettingSeconds & acquire_timeout);
+    TableLockHolder lockForShare(const String & query_id, const std::chrono::milliseconds & acquire_timeout);
 
     /// Lock table for alter. This lock must be acuqired in ALTER queries to be
     /// sure, that we execute only one simultaneous alter. Doesn't affect share lock.
-    TableLockHolder lockForAlter(const String & query_id, const SettingSeconds & acquire_timeout);
+    TableLockHolder lockForAlter(const String & query_id, const std::chrono::milliseconds & acquire_timeout);
 
     /// Lock table exclusively. This lock must be acuired if you want to be
     /// sure, that no other thread (SELECT, merge, ALTER, etc.) doing something
@@ -205,7 +205,7 @@ public:
     ///
     /// NOTE: You have to be 100% sure that you need this lock. It's extremely
     /// heavyweight and makes table irresponsive.
-    TableExclusiveLockHolder lockExclusively(const String & query_id, const SettingSeconds & acquire_timeout);
+    TableExclusiveLockHolder lockExclusively(const String & query_id, const std::chrono::milliseconds & acquire_timeout);
 
     /** Returns stage to which query is going to be processed in read() function.
       * (Normally, the function only reads the columns from the list, but in other cases,

src/Storages/System/StorageSystemColumns.cpp

@@ -236,7 +236,7 @@ private:
     size_t total_tables;
     std::shared_ptr<const ContextAccess> access;
     String query_id;
-    SettingSeconds lock_acquire_timeout;
+    std::chrono::milliseconds lock_acquire_timeout;
 };