Translated comments and by the way made code better [#CLICKHOUSE-2].

dbms/src/Functions/FunctionsEmbeddedDictionaries.h

@@ -141,10 +141,10 @@ struct SEHierarchyImpl
   */
 struct RegionsHierarchyGetter
 {
-    using Src = RegionsHierarchies;
-    using Dst = RegionsHierarchy;
+    using Src = const RegionsHierarchies;
+    using Dst = const RegionsHierarchy;
 
-    static const Dst & get(const Src & src, const std::string & key)
+    static Dst & get(Src & src, const std::string & key)
     {
         return src.get(key);
     }
@@ -155,10 +155,10 @@ struct RegionsHierarchyGetter
 template <typename Dict>
 struct IdentityDictionaryGetter
 {
-    using Src = Dict;
-    using Dst = Dict;
+    using Src = const Dict;
+    using Dst = const Dict;
 
-    static const Dst & get(const Src & src, const std::string & key)
+    static Dst & get(Src & src, const std::string & key)
     {
         if (key.empty())
             return src;
@@ -670,10 +670,10 @@ public:
     }
 
 private:
-    const std::shared_ptr<RegionsNames> owned_dict;
+    const MultiVersion<RegionsNames>::Version owned_dict;
 
 public:
-    FunctionRegionToName(const std::shared_ptr<RegionsNames> & owned_dict_)
+    FunctionRegionToName(const MultiVersion<RegionsNames>::Version & owned_dict_)
         : owned_dict(owned_dict_)
     {
         if (!owned_dict)

libs/libcommon/include/common/MultiVersion.h

@@ -4,39 +4,39 @@
 #include <memory>
 
 
-/** Позволяет хранить некоторый объект, использовать его read-only в разных потоках,
-  *  и заменять его на другой в других потоках.
-  * Замена производится атомарно, при этом, читающие потоки могут работать с разными версиями объекта.
+/** Allow to store and read-only usage of an object in several threads,
+  *  and to atomically replace an object in another thread.
+  * The replacement is atomic and reading threads can work with different versions of an object.
   *
-  * Использование:
-  *        MultiVersion<T> x;
-  * - при обновлении данных:
-  *        x.set(new value);
-  * - при использовании данных для чтения в разных потоках:
-  *    {
-  *        MultiVersion<T>::Version current_version = x.get();
-  *        // используем для чего-нибудь *current_version
-  * }    // здесь перестаём владеть версией; если версия устарела, и её никто больше не использует - она будет уничтожена
+  * Usage:
+  *  MultiVersion<T> x;
+  * - on data update:
+  *  x.set(new value);
+  * - on read-only usage:
+  * {
+  *     MultiVersion<T>::Version current_version = x.get();
+  *     // use *current_version
+  * }   // now we finish own current version; if the version is outdated and no one else is using it - it will be destroyed.
   *
-  * Все методы thread-safe.
+  * All methods are thread-safe.
   */
-template <typename T, typename Ptr = std::shared_ptr<T>>
+template <typename T>
 class MultiVersion
 {
 public:
-    /// Конкретная версия объекта для использования. shared_ptr определяет время жизни версии.
-    using Version = Ptr;
+    /// Version of object for usage. shared_ptr manage lifetime of version.
+    using Version = std::shared_ptr<const T>;
 
-    /// Инициализация по-умолчанию (NULL-ом).
+    /// Default initialization - by nullptr.
     MultiVersion() = default;
 
-    /// Инициализация первой версией.
+    /// Initialization with first version.
     MultiVersion(const Version & value)
     {
         set(value);
     }
 
-    /// Захватить владение первой версией.
+    /// Take an ownership of first version.
     MultiVersion(T * value)
     {
         set(value);
@@ -52,22 +52,22 @@ public:
         set(std::move(value));
     }
 
-    /// Получить текущую версию для использования. Возвращает shared_ptr, который определяет время жизни версии.
+    /// Obtain current version for read-only usage. Returns shared_ptr, that manages lifetime of version.
     const Version get() const
     {
-        /// TODO: можно ли заменять shared_ptr lock-free? (Можно, если сделать свою реализацию с использованием cmpxchg16b.)
-        std::lock_guard<std::mutex> lock(mutex);
+        /// NOTE: is it possible to lock-free replace of shared_ptr?
+        std::lock_guard lock(mutex);
         return current_version;
     }
 
-    /// Обновить объект новой версией.
+    /// Update an object with new version.
     void set(Version value)
     {
-        std::lock_guard<std::mutex> lock(mutex);
+        std::lock_guard lock(mutex);
         current_version = value;
     }
 
-    /// Обновить объект новой версией и захватить владение.
+    /// Update an object with new version and take an ownership of it.
     void set(T * value)
     {
         set(Version(value));