Merge branch 'master' into update-openssl

.clang-format

@@ -52,12 +52,12 @@ IncludeCategories:
 ReflowComments: false
 AlignEscapedNewlinesLeft: false
 AlignEscapedNewlines: DontAlign
+AlignTrailingComments: true
 
 # Not changed:
 AccessModifierOffset: -4
 AlignConsecutiveAssignments: false
 AlignOperands: false
-AlignTrailingComments: false
 AllowAllParametersOfDeclarationOnNextLine: true
 AllowShortBlocksOnASingleLine: false
 AllowShortCaseLabelsOnASingleLine: false

.gitignore

@@ -15,6 +15,7 @@
 /docs/build
 /docs/publish
 /docs/edit
+/docs/website
 /docs/tools/venv/
 /docs/en/single.md
 /docs/ru/single.md

.gitmodules

@@ -104,6 +104,10 @@
 [submodule "contrib/sparsehash-c11"]
 	path = contrib/sparsehash-c11
 	url = https://github.com/sparsehash/sparsehash-c11.git
+[submodule "contrib/grpc"]
+	path = contrib/grpc
+	url = https://github.com/ClickHouse-Extras/grpc.git
+	branch = v1.25.0
 [submodule "contrib/aws"]
 	path = contrib/aws
 	url = https://github.com/aws/aws-sdk-cpp.git

CMakeLists.txt

@@ -226,9 +226,15 @@ else ()
     set(NOT_UNBUNDLED 1)
 endif ()
 
-# Using system libs can cause a lot of warnings in includes (on macro expansion).
 if (UNBUNDLED OR NOT (OS_LINUX OR OS_DARWIN) OR ARCH_32)
-    option (NO_WERROR "Disable -Werror compiler option" ON)
+    # Using system libs can cause a lot of warnings in includes (on macro expansion).
+    option (WERROR "Enable -Werror compiler option" OFF)
+else ()
+    option (WERROR "Enable -Werror compiler option" ON)
+endif ()
+
+if (WERROR)
+    add_warning(error)
 endif ()
 
 # Make this extra-checks for correct library dependencies.
@@ -326,7 +332,6 @@ include (cmake/find/poco.cmake)
 include (cmake/find/lz4.cmake)
 include (cmake/find/xxhash.cmake)
 include (cmake/find/sparsehash.cmake)
-include (cmake/find/rt.cmake)
 include (cmake/find/execinfo.cmake)
 include (cmake/find/re2.cmake)
 include (cmake/find/libgsasl.cmake)
@@ -341,6 +346,7 @@ endif()
 include (cmake/find/libxml2.cmake)
 include (cmake/find/brotli.cmake)
 include (cmake/find/protobuf.cmake)
+include (cmake/find/grpc.cmake)
 include (cmake/find/pdqsort.cmake)
 include (cmake/find/hdfs3.cmake) # uses protobuf
 include (cmake/find/s3.cmake)
@@ -364,9 +370,9 @@ if (ENABLE_TESTS)
 endif ()
 
 # Need to process before "contrib" dir:
-include (libs/libcommon/cmake/find_jemalloc.cmake)
-include (libs/libcommon/cmake/find_cctz.cmake)
-include (libs/libmysqlxx/cmake/find_mysqlclient.cmake)
+include (cmake/find/jemalloc.cmake)
+include (cmake/find/cctz.cmake)
+include (cmake/find/mysqlclient.cmake)
 
 # When testing for memory leaks with Valgrind, don't link tcmalloc or jemalloc.
 
@@ -398,7 +404,7 @@ macro (add_executable target)
     endif()
 endmacro()
 
-add_subdirectory (libs)
+add_subdirectory (base)
 add_subdirectory (utils)
 add_subdirectory (dbms)
 

README.md

@@ -1,18 +1,17 @@
-[![ClickHouse — open source distributed column-oriented DBMS](https://github.com/ClickHouse/ClickHouse/raw/master/website/images/logo-400x240.png)](https://clickhouse.yandex)
+[![ClickHouse — open source distributed column-oriented DBMS](https://github.com/ClickHouse/ClickHouse/raw/master/website/images/logo-400x240.png)](https://clickhouse.tech)
 
 ClickHouse is an open-source column-oriented database management system that allows generating analytical data reports in real time.
 
 ## Useful Links
 
-* [Official website](https://clickhouse.yandex/) has quick high-level overview of ClickHouse on main page.
-* [Tutorial](https://clickhouse.yandex/tutorial.html) shows how to set up and query small ClickHouse cluster.
-* [Documentation](https://clickhouse.yandex/docs/en/) provides more in-depth information.
+* [Official website](https://clickhouse.tech/) has quick high-level overview of ClickHouse on main page.
+* [Tutorial](https://clickhouse.tech/docs/en/getting_started/tutorial/) shows how to set up and query small ClickHouse cluster.
+* [Documentation](https://clickhouse.tech/docs/en/) provides more in-depth information.
 * [YouTube channel](https://www.youtube.com/c/ClickHouseDB) has a lot of content about ClickHouse in video format.
 * [Blog](https://clickhouse.yandex/blog/en/) contains various ClickHouse-related articles, as well as announces and reports about events.
-* [Contacts](https://clickhouse.yandex/#contacts) can help to get your questions answered if there are any.
+* [Contacts](https://clickhouse.tech/#contacts) can help to get your questions answered if there are any.
 * You can also [fill this form](https://forms.yandex.com/surveys/meet-yandex-clickhouse-team/) to meet Yandex ClickHouse team in person.
 
-## Upcoming Events		
+## Upcoming Events				
 
-* [ClickHouse Meetup in San Francisco](https://www.eventbrite.com/e/clickhouse-february-meetup-registration-88496227599) on February 5.
-* [ClickHouse Meetup in New York](https://www.meetup.com/Uber-Engineering-Events-New-York/events/268328663/) on February 11.
+* [ClickHouse Meetup in Athens](https://www.meetup.com/Athens-Big-Data/events/268379195/) on March 5.

SECURITY.md

@@ -9,7 +9,8 @@ currently being supported with security updates:
 | ------- | ------------------ |
 | 1.x   | :x: |
 | 18.x   | :x:                |
-| 19.x   | :white_check_mark: |
+| 19.14   | :white_check_mark: |
+| 20.x   | :white_check_mark: |
 
 ## Reporting a Vulnerability
 

base/CMakeLists.txt

@@ -0,0 +1,17 @@
+add_subdirectory (common)
+add_subdirectory (loggers)
+add_subdirectory (daemon)
+
+if (USE_INTERNAL_MEMCPY)
+    add_subdirectory (memcpy)
+endif()
+
+if (USE_MYSQL)
+    add_subdirectory (mysqlxx)
+endif ()
+
+if (USE_INTERNAL_CONSISTENT_HASHING_LIBRARY)
+    add_subdirectory (consistent-hashing)
+endif ()
+add_subdirectory (consistent-hashing-sumbur)
+add_subdirectory (widechar_width)

base/common/CMakeLists.txt

@@ -0,0 +1,65 @@
+configure_file (config_common.h.in config_common.h)
+
+set (SRCS
+    argsToConfig.cpp
+    coverage.cpp
+    DateLUT.cpp
+    DateLUTImpl.cpp
+    demangle.cpp
+    getMemoryAmount.cpp
+    getThreadId.cpp
+    JSON.cpp
+    LineReader.cpp
+    mremap.cpp
+    phdr_cache.cpp
+    preciseExp10.c
+    setTerminalEcho.cpp
+    shift10.cpp
+    sleep.cpp
+    terminalColors.cpp
+)
+
+if (ENABLE_REPLXX)
+    set (SRCS ${SRCS}
+        ReplxxLineReader.cpp
+        ReplxxLineReader.h
+    )
+endif ()
+
+add_library (common ${SRCS})
+
+target_include_directories(common PUBLIC .. ${CMAKE_CURRENT_BINARY_DIR}/..)
+
+if (USE_INTERNAL_MEMCPY)
+    target_link_libraries (common PRIVATE memcpy)
+endif ()
+
+if(CCTZ_INCLUDE_DIR)
+    target_include_directories(common BEFORE PRIVATE ${CCTZ_INCLUDE_DIR})
+endif()
+
+if (NOT USE_INTERNAL_BOOST_LIBRARY)
+    target_include_directories (common SYSTEM BEFORE PUBLIC ${Boost_INCLUDE_DIRS})
+endif ()
+
+if(NOT USE_INTERNAL_POCO_LIBRARY)
+    target_include_directories (common SYSTEM BEFORE PUBLIC ${Poco_Foundation_INCLUDE_DIR})
+endif()
+
+if(CCTZ_LIBRARY)
+    target_link_libraries(common PRIVATE ${CCTZ_LIBRARY})
+endif()
+
+target_link_libraries(common PUBLIC replxx)
+
+target_link_libraries (common
+    PUBLIC
+        ${Poco_Util_LIBRARY}
+        ${Poco_Foundation_LIBRARY}
+        ${CITYHASH_LIBRARIES}
+        ${Boost_SYSTEM_LIBRARY}
+)
+
+if (ENABLE_TESTS)
+    add_subdirectory (tests)
+endif ()

base/common/DateLUTImpl.h

@@ -391,9 +391,9 @@ public:
 
     /*
       The bits in week_mode has the following meaning:
-       WeekModeFlag::MONDAY_FIRST (0)  If not set	Sunday is first day of week
-                      If set	Monday is first day of week
-       WeekModeFlag::YEAR (1)	  If not set	Week is in range 0-53
+       WeekModeFlag::MONDAY_FIRST (0)  If not set Sunday is first day of week
+                      If set Monday is first day of week
+       WeekModeFlag::YEAR (1) If not set Week is in range 0-53
 
         Week 0 is returned for the the last week of the previous year (for
         a date at start of january) In this case one can get 53 for the
@@ -401,19 +401,19 @@ public:
         relevant for the given year. Note that this flag is only
         releveant if WeekModeFlag::JANUARY is not set.
 
-                  If set	 Week is in range 1-53.
+                  If set Week is in range 1-53.
 
         In this case one may get week 53 for a date in January (when
         the week is that last week of previous year) and week 1 for a
         date in December.
 
-      WeekModeFlag::FIRST_WEEKDAY (2)  If not set	Weeks are numbered according
+      WeekModeFlag::FIRST_WEEKDAY (2) If not set Weeks are numbered according
                         to ISO 8601:1988
-                  If set	The week that contains the first
+                  If set The week that contains the first
                         'first-day-of-week' is week 1.
 
-      WeekModeFlag::NEWYEAR_DAY (3)   If not set  no meaning
-                  If set	The week that contains the January 1 is week 1.
+      WeekModeFlag::NEWYEAR_DAY (3) If not set no meaning
+                  If set The week that contains the January 1 is week 1.
                             Week is in range 1-53.
                             And ignore WeekModeFlag::YEAR, WeekModeFlag::FIRST_WEEKDAY
 

base/common/JSON.cpp

@@ -399,7 +399,7 @@ JSON::Pos JSON::skipElement() const
 
     ElementType type = getType();
 
-    switch(type)
+    switch (type)
     {
         case TYPE_NULL:
             return skipNull();
@@ -587,7 +587,7 @@ std::string JSON::getString() const
                 ++s;
                 checkPos(s);
 
-                switch(*s)
+                switch (*s)
                 {
                     case '"':
                         buf += '"';
@@ -665,7 +665,7 @@ StringRef JSON::getRawString() const
     if (*s != '"')
         throw JSONException(std::string("JSON: expected \", got ") + *s);
     while (++s != ptr_end && *s != '"');
-    if (s != ptr_end )
+    if (s != ptr_end)
         return StringRef(ptr_begin + 1, s - ptr_begin - 1);
     throw JSONException("JSON: incorrect syntax (expected end of string, found end of JSON).");
 }

base/common/LineReader.cpp

@@ -3,8 +3,8 @@
 #include <iostream>
 #include <string_view>
 
-#include <port/unistd.h>
 #include <string.h>
+#include <unistd.h>
 
 #ifdef OS_LINUX
 /// We can detect if code is linked with one or another readline variants or open the library dynamically.
@@ -81,7 +81,12 @@ String LineReader::readLine(const String & first_prompt, const String & second_p
         }
 
         if (input.empty())
-            continue;
+        {
+            if (!line.empty() && !delimiter && !hasInputData())
+                break;
+            else
+                continue;
+        }
 
         is_multiline = (input.back() == extender) || (delimiter && input.back() != delimiter) || hasInputData();
 
@@ -96,18 +101,16 @@ String LineReader::readLine(const String & first_prompt, const String & second_p
         line += (line.empty() ? "" : " ") + input;
 
         if (!is_multiline)
-        {
-            if (line != prev_line)
-            {
-                addToHistory(line);
-                prev_line = line;
-            }
-
-            return line;
-        }
+            break;
     }
 
-    return {};
+    if (!line.empty() && line != prev_line)
+    {
+        addToHistory(line);
+        prev_line = line;
+    }
+
+    return line;
 }
 
 LineReader::InputStatus LineReader::readOneLine(const String & prompt)

base/common/ReplxxLineReader.cpp

@@ -1,8 +1,8 @@
 #include <common/ReplxxLineReader.h>
 
 #include <errno.h>
-#include <port/unistd.h>
 #include <string.h>
+#include <unistd.h>
 
 namespace
 {

base/common/StringRef.h

@@ -26,8 +26,9 @@ struct StringRef
     const char * data = nullptr;
     size_t size = 0;
 
-    StringRef(const char * data_, size_t size_) : data(data_), size(size_) {}
-    StringRef(const unsigned char * data_, size_t size_) : data(reinterpret_cast<const char *>(data_)), size(size_) {}
+    template <typename CharT, typename = std::enable_if_t<sizeof(CharT) == 1>>
+    StringRef(const CharT * data_, size_t size_) : data(reinterpret_cast<const char *>(data_)), size(size_) {}
+
     StringRef(const std::string & s) : data(s.data()), size(s.size()) {}
     StringRef(const std::string_view & s) : data(s.data()), size(s.size()) {}
     explicit StringRef(const char * data_) : data(data_), size(strlen(data_)) {}

base/common/Types.h

@@ -11,7 +11,7 @@ using Int16 = int16_t;
 using Int32 = int32_t;
 using Int64 = int64_t;
 
-using UInt8 = uint8_t;
+using UInt8 = char8_t;
 using UInt16 = uint16_t;
 using UInt32 = uint32_t;
 using UInt64 = uint64_t;

base/common/demangle.cpp

@@ -10,6 +10,11 @@
 
 #if _MSC_VER || MEMORY_SANITIZER
 
+DemangleResult tryDemangle(const char * name)
+{
+    return DemangleResult{};
+}
+
 std::string demangle(const char * name, int & status)
 {
     status = 0;
@@ -21,28 +26,27 @@ std::string demangle(const char * name, int & status)
 #include <stdlib.h>
 #include <cxxabi.h>
 
-std::string demangle(const char * name, int & status)
+static DemangleResult tryDemangle(const char * name, int & status)
 {
-    std::string res;
-
-    char * demangled_str = abi::__cxa_demangle(name, 0, 0, &status);
-    if (demangled_str)
-    {
-        try
-        {
-            res = demangled_str;
-        }
-        catch (...)
-        {
-            free(demangled_str);
-            throw;
-        }
-        free(demangled_str);
-    }
-    else
-        res = name;
-
-    return res;
+    return DemangleResult(abi::__cxa_demangle(name, nullptr, nullptr, &status));
 }
 
+DemangleResult tryDemangle(const char * name)
+{
+    int status = 0;
+    return tryDemangle(name, status);
+}
+
+std::string demangle(const char * name, int & status)
+{
+    auto result = tryDemangle(name, status);
+    if (result)
+    {
+        return std::string(result.get());
+    }
+
+    return name;
+}
+
+
 #endif

base/common/demangle.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <memory>
 #include <string>
 
 
@@ -14,3 +15,18 @@ inline std::string demangle(const char * name)
     int status = 0;
     return demangle(name, status);
 }
+
+// abi::__cxa_demangle returns a C string of known size that should be deleted
+// with free().
+struct FreeingDeleter
+{
+    template <typename PointerType>
+    void operator() (PointerType ptr)
+    {
+        std::free(ptr);
+    }
+};
+
+typedef std::unique_ptr<char, FreeingDeleter> DemangleResult;
+
+DemangleResult tryDemangle(const char * name);

base/common/getMemoryAmount.cpp

@@ -33,7 +33,7 @@ uint64_t getMemoryAmountOrZero()
     /* New 64-bit MEMORYSTATUSEX isn't available.  Use old 32.bit */
     MEMORYSTATUS status;
     status.dwLength = sizeof(status);
-    GlobalMemoryStatus( &status );
+    GlobalMemoryStatus(&status);
     return status.dwTotalPhys;
 
 #elif defined(WIN32) || defined(_WIN32)
@@ -41,7 +41,7 @@ uint64_t getMemoryAmountOrZero()
     /* Use new 64-bit MEMORYSTATUSEX, not old 32-bit MEMORYSTATUS */
     MEMORYSTATUSEX status;
     status.dwLength = sizeof(status);
-    GlobalMemoryStatusEx( &status );
+    GlobalMemoryStatusEx(&status);
     return status.ullTotalPhys;
 
 #else
@@ -58,24 +58,24 @@ uint64_t getMemoryAmountOrZero()
 #endif
     uint64_t size = 0; /* 64-bit */
     size_t len = sizeof(size);
-    if ( sysctl( mib, 2, &size, &len, NULL, 0 ) == 0 ) {
+    if (sysctl(mib, 2, &size, &len, NULL, 0) == 0)
         return size;
-    }
+
     return 0; /* Failed? */
 
 #elif defined(_SC_AIX_REALMEM)
     /* AIX. ----------------------------------------------------- */
-    return sysconf( _SC_AIX_REALMEM ) * 1024;
+    return sysconf(_SC_AIX_REALMEM) * 1024;
 
 #elif defined(_SC_PHYS_PAGES) && defined(_SC_PAGESIZE)
     /* FreeBSD, Linux, OpenBSD, and Solaris. -------------------- */
-    return (uint64_t)sysconf( _SC_PHYS_PAGES )
-           * (uint64_t)sysconf( _SC_PAGESIZE );
+    return (uint64_t)sysconf(_SC_PHYS_PAGES)
+           * (uint64_t)sysconf(_SC_PAGESIZE);
 
 #elif defined(_SC_PHYS_PAGES) && defined(_SC_PAGE_SIZE)
     /* Legacy. -------------------------------------------------- */
-    return (uint64_t)sysconf( _SC_PHYS_PAGES )
-           * (uint64_t)sysconf( _SC_PAGE_SIZE );
+    return (uint64_t)sysconf(_SC_PHYS_PAGES)
+           * (uint64_t)sysconf(_SC_PAGE_SIZE);
 
 #elif defined(CTL_HW) && (defined(HW_PHYSMEM) || defined(HW_REALMEM))
     /* DragonFly BSD, FreeBSD, NetBSD, OpenBSD, and OSX. -------- */
@@ -87,10 +87,10 @@ uint64_t getMemoryAmountOrZero()
     mib[1] = HW_PHYSMEM; /* Others. ------------------ */
 #endif
     unsigned int size = 0; /* 32-bit */
-    size_t len = sizeof( size );
-    if ( sysctl( mib, 2, &size, &len, NULL, 0 ) == 0 ) {
+    size_t len = sizeof(size);
+    if (sysctl(mib, 2, &size, &len, NULL, 0) == 0)
         return size;
-    }
+
     return 0; /* Failed? */
 #endif /* sysctl and sysconf variants */
 

base/common/getThreadId.cpp

@@ -0,0 +1,26 @@
+#include <common/getThreadId.h>
+
+#if OS_LINUX
+    #include <unistd.h>
+    #include <syscall.h>
+#else
+    #include <pthread.h>
+    #include <stdexcept>
+#endif
+
+
+static thread_local uint64_t current_tid = 0;
+uint64_t getThreadId()
+{
+    if (!current_tid)
+    {
+#if OS_LINUX
+        current_tid = syscall(SYS_gettid); /// This call is always successful. - man gettid
+#else
+        if (0 != pthread_threadid_np(nullptr, &current_tid))
+            throw std::logic_error("pthread_threadid_np returned error");
+#endif
+    }
+
+    return current_tid;
+}

base/common/getThreadId.h

@@ -0,0 +1,5 @@
+#pragma once
+#include <cstdint>
+
+/// Obtain thread id from OS. The value is cached in thread local variable.
+uint64_t getThreadId();

base/common/iostream_debug_helpers.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include "demangle.h"
-#include "getThreadNumber.h"
+#include "getThreadId.h"
 #include <type_traits>
 #include <tuple>
 #include <iomanip>
@@ -141,7 +141,7 @@ Out & dump(Out & out, const char * name, T && x)
 #endif
 
 #define DUMPVAR(VAR) ::dump(std::cerr, #VAR, (VAR)); std::cerr << "; ";
-#define DUMPHEAD std::cerr << __FILE__ << ':' << __LINE__ << " [ " << getThreadNumber() << " ] ";
+#define DUMPHEAD std::cerr << __FILE__ << ':' << __LINE__ << " [ " << getThreadId() << " ] ";
 #define DUMPTAIL std::cerr << '\n';
 
 #define DUMP1(V1) do { DUMPHEAD DUMPVAR(V1) DUMPTAIL } while(0)

base/common/itoa.h

@@ -397,6 +397,12 @@ char * itoa(I i, char * p)
     return impl::convert::itoa(i, p);
 }
 
+template <>
+inline char * itoa(char8_t i, char * p)
+{
+    return impl::convert::itoa(uint8_t(i), p);
+}
+
 template <>
 inline char * itoa<uint128_t>(uint128_t i, char * p)
 {

base/common/shift10.cpp

@@ -1,7 +1,8 @@
 #include <common/shift10.h>
+
 #include <common/likely.h>
+
 #include <limits>
-#include <port/ssize_t.h>
 
 
 template <typename T>

base/common/terminalColors.cpp

@@ -0,0 +1,49 @@
+#include <string>
+#include <common/terminalColors.h>
+
+
+std::string setColor(UInt64 hash)
+{
+    /// Make a random RGB color that has constant brightness.
+    /// https://en.wikipedia.org/wiki/YCbCr
+
+    /// Note that this is darker than the middle relative luminance, see "Gamma_correction" and "Luma_(video)".
+    /// It still looks awesome.
+    UInt8 y = 128;
+
+    UInt8 cb = hash % 256;
+    UInt8 cr = hash / 256 % 256;
+
+    UInt8 r = std::max(0.0, std::min(255.0, y + 1.402 * (cr - 128)));
+    UInt8 g = std::max(0.0, std::min(255.0, y - 0.344136 * (cb - 128) - 0.714136 * (cr - 128)));
+    UInt8 b = std::max(0.0, std::min(255.0, y + 1.772 * (cb - 128)));
+
+    /// ANSI escape sequence to set 24-bit foreground font color in terminal.
+    return "\033[38;2;" + std::to_string(r) + ";" + std::to_string(g) + ";" + std::to_string(b) + "m";
+}
+
+const char * setColorForLogPriority(int priority)
+{
+    if (priority < 1 || priority > 8)
+        return "";
+
+    static const char * colors[] =
+    {
+        "",
+        "\033[1;41m",   /// Fatal
+        "\033[7;31m",   /// Critical
+        "\033[1;31m",   /// Error
+        "\033[0;31m",   /// Warning
+        "\033[0;33m",   /// Notice
+        "\033[1m",      /// Information
+        "",             /// Debug
+        "\033[2m",      /// Trace
+    };
+
+    return colors[priority];
+}
+
+const char * resetColor()
+{
+    return "\033[0m";
+}

base/common/terminalColors.h

@@ -0,0 +1,15 @@
+#include <string>
+#include <common/Types.h>
+
+
+/** Set color in terminal based on 64-bit hash value.
+  * It can be used to choose some random color deterministically based on some other value.
+  * Hash value should be uniformly distributed.
+  */
+std::string setColor(UInt64 hash);
+
+/** Set color for logger priority value. */
+const char * setColorForLogPriority(int priority);
+
+/** Undo changes made by the functions above. */
+const char * resetColor();

base/common/time.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include <time.h>
+
+#if defined (OS_DARWIN)
+#    define CLOCK_MONOTONIC_COARSE CLOCK_MONOTONIC
+#endif

base/daemon/include/daemon/BaseDaemon.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <sys/types.h>
-#include <port/unistd.h>
+#include <unistd.h>
 #include <iostream>
 #include <memory>
 #include <functional>
@@ -19,7 +19,7 @@
 #include <Poco/Version.h>
 #include <common/Types.h>
 #include <common/logger_useful.h>
-#include <common/getThreadNumber.h>
+#include <common/getThreadId.h>
 #include <daemon/GraphiteWriter.h>
 #include <Common/Config/ConfigProcessor.h>
 #include <loggers/Loggers.h>

base/daemon/src/BaseDaemon.cpp

@@ -37,7 +37,7 @@
 #include <common/logger_useful.h>
 #include <common/ErrorHandlers.h>
 #include <common/argsToConfig.h>
-#include <common/getThreadNumber.h>
+#include <common/getThreadId.h>
 #include <common/coverage.h>
 
 #include <IO/WriteBufferFromFile.h>
@@ -123,7 +123,7 @@ static void signalHandler(int sig, siginfo_t * info, void * context)
     DB::writePODBinary(*info, out);
     DB::writePODBinary(signal_context, out);
     DB::writePODBinary(stack_trace, out);
-    DB::writeBinary(UInt32(getThreadNumber()), out);
+    DB::writeBinary(UInt32(getThreadId()), out);
     DB::writeStringBinary(query_id, out);
 
     out.next();
@@ -301,7 +301,7 @@ static void terminate_handler()
     DB::WriteBufferFromFileDescriptor out(signal_pipe.fds_rw[1], buf_size, buf);
 
     DB::writeBinary(static_cast<int>(SignalListener::StdTerminate), out);
-    DB::writeBinary(UInt32(getThreadNumber()), out);
+    DB::writeBinary(UInt32(getThreadId()), out);
     DB::writeBinary(log_message, out);
     out.next();
 
@@ -382,7 +382,7 @@ enum class InstructionFail
 
 static std::string instructionFailToString(InstructionFail fail)
 {
-    switch(fail)
+    switch (fail)
     {
         case InstructionFail::NONE:
             return "NONE";

base/ext/singleton.h

@@ -0,0 +1,44 @@
+#pragma once
+
+#include <memory>
+
+namespace ext
+{
+
+/** Thread-unsafe singleton. It works simply like a global variable.
+  * Supports deinitialization.
+  *
+  * In most of the cases, you don't need this class.
+  * Use "Meyers Singleton" instead: static T & instance() { static T x; return x; }
+  */
+
+template <class T>
+class Singleton
+{
+public:
+    Singleton()
+    {
+        if (!instance)
+            instance = std::make_unique<T>();
+    }
+
+    T * operator->()
+    {
+        return instance.get();
+    }
+
+    static bool isInitialized()
+    {
+        return !!instance;
+    }
+
+    static void reset()
+    {
+        instance.reset();
+    }
+
+private:
+    inline static std::unique_ptr<T> instance{};
+};
+
+}