diff --git a/.clang-tidy b/.clang-tidy
index d7380a9a89b..3c222fbf8da 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -57,6 +57,7 @@ Checks: '-*,
     readability-simplify-subscript-expr,
     readability-simplify-boolean-expr,
     readability-inconsistent-declaration-parameter-name,
+    readability-identifier-naming,
     
     bugprone-undelegated-constructor,
     bugprone-argument-comment,
@@ -162,3 +163,43 @@ Checks: '-*,
     boost-use-to-string,
 '
 WarningsAsErrors: '*'
+
+CheckOptions:
+  - key: readability-identifier-naming.ClassCase
+    value: CamelCase
+  - key: readability-identifier-naming.EnumCase
+    value: CamelCase
+  - key: readability-identifier-naming.LocalVariableCase
+    value: lower_case
+  - key: readability-identifier-naming.StaticConstantCase
+    value: aNy_CasE
+  - key: readability-identifier-naming.MemberCase
+    value: lower_case
+  - key: readability-identifier-naming.PrivateMemberPrefix
+    value: ''
+  - key: readability-identifier-naming.ProtectedMemberPrefix
+    value: ''
+  - key: readability-identifier-naming.PublicMemberCase
+    value: lower_case
+  - key: readability-identifier-naming.MethodCase
+    value: camelBack
+  - key: readability-identifier-naming.PrivateMethodPrefix
+    value: ''
+  - key: readability-identifier-naming.ProtectedMethodPrefix
+    value: ''
+  - key: readability-identifier-naming.ParameterPackCase
+    value: lower_case
+  - key: readability-identifier-naming.StructCase
+    value: CamelCase
+  - key: readability-identifier-naming.TemplateTemplateParameterCase
+    value: CamelCase
+  - key: readability-identifier-naming.TemplateUsingCase
+    value: lower_case
+  - key: readability-identifier-naming.TypeTemplateParameterCase
+    value: CamelCase
+  - key: readability-identifier-naming.TypedefCase
+    value: CamelCase
+  - key: readability-identifier-naming.UnionCase
+    value: CamelCase
+  - key: readability-identifier-naming.UsingCase
+    value: CamelCase
diff --git a/base/common/shift10.cpp b/base/common/shift10.cpp
index 341ced6aa81..b7b39182145 100644
--- a/base/common/shift10.cpp
+++ b/base/common/shift10.cpp
@@ -8,8 +8,8 @@
 template <typename T>
 static T shift10Impl(T x, int exponent)
 {
-    static constexpr ssize_t MIN_EXPONENT = -323;
-    static constexpr ssize_t MAX_EXPONENT = 308;
+    static constexpr ssize_t min_exponent = -323;
+    static constexpr ssize_t max_exponent = 308;
 
     static const long double powers10[] =
     {
@@ -47,12 +47,12 @@ static T shift10Impl(T x, int exponent)
         1e291L,1e292L,1e293L,1e294L,1e295L,1e296L,1e297L,1e298L,1e299L,1e300L,1e301L,1e302L,1e303L,1e304L,1e305L,1e306L,1e307L,1e308L
     };
 
-    if (unlikely(exponent < MIN_EXPONENT))  /// Note: there are some values below MIN_EXPONENT that is greater than zero.
+    if (unlikely(exponent < min_exponent))  /// Note: there are some values below MIN_EXPONENT that is greater than zero.
         x *= 0;     /// Multiplying to keep the sign of zero.
-    else if (unlikely(exponent > MAX_EXPONENT))
+    else if (unlikely(exponent > max_exponent))
         x *= std::numeric_limits<T>::infinity();  /// Multiplying to keep the sign of infinity.
     else
-        x *= powers10[exponent - MIN_EXPONENT];
+        x *= powers10[exponent - min_exponent];
 
     return x;
 }
diff --git a/base/common/tests/date_lut4.cpp b/base/common/tests/date_lut4.cpp
index a82ec25f183..86a4708dc79 100644
--- a/base/common/tests/date_lut4.cpp
+++ b/base/common/tests/date_lut4.cpp
@@ -5,12 +5,12 @@
 int main(int, char **)
 {
     /** В DateLUT был глюк - для времён из дня 1970-01-01, возвращался номер часа больше 23. */
-    static const time_t TIME = 66130;
+    static const time_t time = 66130;
 
     const auto & date_lut = DateLUT::instance();
 
-    std::cerr << date_lut.toHour(TIME) << std::endl;
-    std::cerr << date_lut.toDayNum(TIME) << std::endl;
+    std::cerr << date_lut.toHour(time) << std::endl;
+    std::cerr << date_lut.toDayNum(time) << std::endl;
 
     const auto * values = reinterpret_cast<const DateLUTImpl::Values *>(&date_lut);
 
diff --git a/base/mysqlxx/Pool.cpp b/base/mysqlxx/Pool.cpp
index b8216c254e6..99815363a56 100644
--- a/base/mysqlxx/Pool.cpp
+++ b/base/mysqlxx/Pool.cpp
@@ -119,7 +119,7 @@ Pool::~Pool()
 }
 
 
-Pool::Entry Pool::Get()
+Pool::Entry Pool::get()
 {
     std::unique_lock<std::mutex> lock(mutex);
 
diff --git a/base/mysqlxx/Pool.h b/base/mysqlxx/Pool.h
index b5e0c71a5cc..bf9365a064a 100644
--- a/base/mysqlxx/Pool.h
+++ b/base/mysqlxx/Pool.h
@@ -185,7 +185,7 @@ public:
     ~Pool();
 
     /// Allocates connection.
-    Entry Get();
+    Entry get();
 
     /// Allocates connection.
     /// If database is not accessible, returns empty Entry object.
diff --git a/base/mysqlxx/PoolFactory.cpp b/base/mysqlxx/PoolFactory.cpp
index d9c1ec1519d..f0a5543d723 100644
--- a/base/mysqlxx/PoolFactory.cpp
+++ b/base/mysqlxx/PoolFactory.cpp
@@ -17,10 +17,10 @@ struct PoolFactory::Impl
     std::mutex mutex;
 };
 
-PoolWithFailover PoolFactory::Get(const std::string & config_name, unsigned default_connections,
+PoolWithFailover PoolFactory::get(const std::string & config_name, unsigned default_connections,
     unsigned max_connections, size_t max_tries)
 {
-    return Get(Poco::Util::Application::instance().config(), config_name, default_connections, max_connections, max_tries);
+    return get(Poco::Util::Application::instance().config(), config_name, default_connections, max_connections, max_tries);
 }
 
 /// Duplicate of code from StringUtils.h. Copied here for less dependencies.
@@ -72,7 +72,7 @@ static std::string getPoolEntryName(const Poco::Util::AbstractConfiguration & co
     return entry_name;
 }
 
-PoolWithFailover PoolFactory::Get(const Poco::Util::AbstractConfiguration & config,
+PoolWithFailover PoolFactory::get(const Poco::Util::AbstractConfiguration & config,
         const std::string & config_name, unsigned default_connections, unsigned max_connections, size_t max_tries)
 {
 
diff --git a/base/mysqlxx/PoolFactory.h b/base/mysqlxx/PoolFactory.h
index a21c2baca2f..a7bb97cd0c6 100644
--- a/base/mysqlxx/PoolFactory.h
+++ b/base/mysqlxx/PoolFactory.h
@@ -27,13 +27,13 @@ public:
     PoolFactory(const PoolFactory &) = delete;
 
     /** Allocates a PoolWithFailover to connect to MySQL. */
-    PoolWithFailover Get(const std::string & config_name,
+    PoolWithFailover get(const std::string & config_name,
         unsigned default_connections = MYSQLXX_POOL_WITH_FAILOVER_DEFAULT_START_CONNECTIONS,
         unsigned max_connections = MYSQLXX_POOL_WITH_FAILOVER_DEFAULT_MAX_CONNECTIONS,
         size_t max_tries = MYSQLXX_POOL_WITH_FAILOVER_DEFAULT_MAX_TRIES);
 
     /** Allocates a PoolWithFailover to connect to MySQL. */
-    PoolWithFailover Get(const Poco::Util::AbstractConfiguration & config,
+    PoolWithFailover get(const Poco::Util::AbstractConfiguration & config,
         const std::string & config_name,
         unsigned default_connections = MYSQLXX_POOL_WITH_FAILOVER_DEFAULT_START_CONNECTIONS,
         unsigned max_connections = MYSQLXX_POOL_WITH_FAILOVER_DEFAULT_MAX_CONNECTIONS,
diff --git a/base/mysqlxx/PoolWithFailover.cpp b/base/mysqlxx/PoolWithFailover.cpp
index 2beb50d3da8..a763988331b 100644
--- a/base/mysqlxx/PoolWithFailover.cpp
+++ b/base/mysqlxx/PoolWithFailover.cpp
@@ -68,7 +68,7 @@ PoolWithFailover::PoolWithFailover(const PoolWithFailover & other)
     }
 }
 
-PoolWithFailover::Entry PoolWithFailover::Get()
+PoolWithFailover::Entry PoolWithFailover::get()
 {
     Poco::Util::Application & app = Poco::Util::Application::instance();
     std::lock_guard<std::mutex> locker(mutex);
@@ -89,7 +89,7 @@ PoolWithFailover::Entry PoolWithFailover::Get()
 
                 try
                 {
-                    Entry entry = shareable ? pool->Get() : pool->tryGet();
+                    Entry entry = shareable ? pool->get() : pool->tryGet();
 
                     if (!entry.isNull())
                     {
@@ -121,7 +121,7 @@ PoolWithFailover::Entry PoolWithFailover::Get()
     if (full_pool)
     {
         app.logger().error("All connections failed, trying to wait on a full pool " + (*full_pool)->getDescription());
-        return (*full_pool)->Get();
+        return (*full_pool)->get();
     }
 
     std::stringstream message;
diff --git a/base/mysqlxx/PoolWithFailover.h b/base/mysqlxx/PoolWithFailover.h
index fe151240fa5..9db29db5efa 100644
--- a/base/mysqlxx/PoolWithFailover.h
+++ b/base/mysqlxx/PoolWithFailover.h
@@ -105,6 +105,6 @@ namespace mysqlxx
         PoolWithFailover(const PoolWithFailover & other);
 
         /** Allocates a connection to use. */
-        Entry Get();
+        Entry get();
     };
 }
diff --git a/base/mysqlxx/Value.cpp b/base/mysqlxx/Value.cpp
index 4fed33c5da9..ed66167e8ea 100644
--- a/base/mysqlxx/Value.cpp
+++ b/base/mysqlxx/Value.cpp
@@ -154,7 +154,7 @@ double Value::readFloatText(const char * buf, size_t length) const
 
 void Value::throwException(const char * text) const
 {
-    static constexpr size_t MYSQLXX_QUERY_PREVIEW_LENGTH = 1000;
+    static constexpr size_t preview_length = 1000;
 
     std::stringstream info;
     info << text;
@@ -166,7 +166,7 @@ void Value::throwException(const char * text) const
     }
 
     if (res && res->getQuery())
-        info << ", query: " << res->getQuery()->str().substr(0, MYSQLXX_QUERY_PREVIEW_LENGTH);
+        info << ", query: " << res->getQuery()->str().substr(0, preview_length);
 
     throw CannotParseValue(info.str());
 }
diff --git a/dbms/programs/client/Client.cpp b/dbms/programs/client/Client.cpp
index 21768911beb..42a06925c7d 100644
--- a/dbms/programs/client/Client.cpp
+++ b/dbms/programs/client/Client.cpp
@@ -1122,7 +1122,7 @@ private:
                 /// to avoid losing sync.
                 if (!cancelled)
                 {
-                    auto cancelQuery = [&] {
+                    auto cancel_query = [&] {
                         connection->sendCancel();
                         cancelled = true;
                         if (is_interactive)
@@ -1134,7 +1134,7 @@ private:
 
                     if (interrupt_listener.check())
                     {
-                        cancelQuery();
+                        cancel_query();
                     }
                     else
                     {
@@ -1145,7 +1145,7 @@ private:
                                       << " Waited for " << static_cast<size_t>(elapsed) << " seconds,"
                                       << " timeout is " << receive_timeout.totalSeconds() << " seconds." << std::endl;
 
-                            cancelQuery();
+                            cancel_query();
                         }
                     }
                 }
diff --git a/dbms/programs/copier/ClusterCopierApp.cpp b/dbms/programs/copier/ClusterCopierApp.cpp
index c70e79313b9..e49c0d8eca4 100644
--- a/dbms/programs/copier/ClusterCopierApp.cpp
+++ b/dbms/programs/copier/ClusterCopierApp.cpp
@@ -43,11 +43,11 @@ void ClusterCopierApp::initialize(Poco::Util::Application & self)
 
 void ClusterCopierApp::handleHelp(const std::string &, const std::string &)
 {
-    Poco::Util::HelpFormatter helpFormatter(options());
-    helpFormatter.setCommand(commandName());
-    helpFormatter.setHeader("Copies tables from one cluster to another");
-    helpFormatter.setUsage("--config-file <config-file> --task-path <task-path>");
-    helpFormatter.format(std::cerr);
+    Poco::Util::HelpFormatter help_formatter(options());
+    help_formatter.setCommand(commandName());
+    help_formatter.setHeader("Copies tables from one cluster to another");
+    help_formatter.setUsage("--config-file <config-file> --task-path <task-path>");
+    help_formatter.format(std::cerr);
 
     stopOptionsProcessing();
 }
diff --git a/dbms/programs/odbc-bridge/ODBCBridge.cpp b/dbms/programs/odbc-bridge/ODBCBridge.cpp
index 9e1e8400cc1..e7e8aca7147 100644
--- a/dbms/programs/odbc-bridge/ODBCBridge.cpp
+++ b/dbms/programs/odbc-bridge/ODBCBridge.cpp
@@ -79,11 +79,11 @@ namespace
 
 void ODBCBridge::handleHelp(const std::string &, const std::string &)
 {
-    Poco::Util::HelpFormatter helpFormatter(options());
-    helpFormatter.setCommand(commandName());
-    helpFormatter.setHeader("HTTP-proxy for odbc requests");
-    helpFormatter.setUsage("--http-port <port>");
-    helpFormatter.format(std::cerr);
+    Poco::Util::HelpFormatter help_formatter(options());
+    help_formatter.setCommand(commandName());
+    help_formatter.setHeader("HTTP-proxy for odbc requests");
+    help_formatter.setUsage("--http-port <port>");
+    help_formatter.format(std::cerr);
 
     stopOptionsProcessing();
 }
diff --git a/dbms/programs/server/HTTPHandler.cpp b/dbms/programs/server/HTTPHandler.cpp
index 65b605c993d..ec890c0a96d 100644
--- a/dbms/programs/server/HTTPHandler.cpp
+++ b/dbms/programs/server/HTTPHandler.cpp
@@ -546,7 +546,7 @@ void HTTPHandler::processQuery(
     client_info.http_method = http_method;
     client_info.http_user_agent = request.get("User-Agent", "");
 
-    auto appendCallback = [&context] (ProgressCallback callback)
+    auto append_callback = [&context] (ProgressCallback callback)
     {
         auto prev = context.getProgressCallback();
 
@@ -561,13 +561,13 @@ void HTTPHandler::processQuery(
 
     /// While still no data has been sent, we will report about query execution progress by sending HTTP headers.
     if (settings.send_progress_in_http_headers)
-        appendCallback([&used_output] (const Progress & progress) { used_output.out->onProgress(progress); });
+        append_callback([&used_output] (const Progress & progress) { used_output.out->onProgress(progress); });
 
     if (settings.readonly > 0 && settings.cancel_http_readonly_queries_on_client_close)
     {
         Poco::Net::StreamSocket & socket = dynamic_cast<Poco::Net::HTTPServerRequestImpl &>(request).socket();
 
-        appendCallback([&context, &socket](const Progress &)
+        append_callback([&context, &socket](const Progress &)
         {
             /// Assume that at the point this method is called no one is reading data from the socket any more.
             /// True for read-only queries.
diff --git a/dbms/programs/server/HTTPHandlerFactory.cpp b/dbms/programs/server/HTTPHandlerFactory.cpp
index ab8fb4f7336..7a1bcaf4fc6 100644
--- a/dbms/programs/server/HTTPHandlerFactory.cpp
+++ b/dbms/programs/server/HTTPHandlerFactory.cpp
@@ -23,9 +23,9 @@ Poco::Net::HTTPRequestHandler * HTTPRequestHandlerFactoryMain::createRequestHand
         << ", Content Type: " << request.getContentType()
         << ", Transfer Encoding: " << request.getTransferEncoding());
 
-    for (auto & handlerFactory: child_handler_factories)
+    for (auto & handler_factory : child_handler_factories)
     {
-        auto handler = handlerFactory->createRequestHandler(request);
+        auto handler = handler_factory->createRequestHandler(request);
         if (handler != nullptr)
             return handler;
     }
diff --git a/dbms/programs/server/MySQLHandler.cpp b/dbms/programs/server/MySQLHandler.cpp
index aaa8cec90b2..3e1432dbfce 100644
--- a/dbms/programs/server/MySQLHandler.cpp
+++ b/dbms/programs/server/MySQLHandler.cpp
@@ -252,8 +252,8 @@ void MySQLHandler::comFieldList(ReadBuffer & payload)
     ComFieldList packet;
     packet.readPayload(payload);
     String database = connection_context.getCurrentDatabase();
-    StoragePtr tablePtr = DatabaseCatalog::instance().getTable({database, packet.table});
-    for (const NameAndTypePair & column: tablePtr->getColumns().getAll())
+    StoragePtr table_ptr = DatabaseCatalog::instance().getTable({database, packet.table});
+    for (const NameAndTypePair & column: table_ptr->getColumns().getAll())
     {
         ColumnDefinition column_definition(
             database, packet.table, packet.table, column.name, column.name, CharacterSet::binary, 100, ColumnType::MYSQL_TYPE_STRING, 0, 0
diff --git a/dbms/programs/server/MySQLHandlerFactory.cpp b/dbms/programs/server/MySQLHandlerFactory.cpp
index dceb3d2293e..925a1e0af5f 100644
--- a/dbms/programs/server/MySQLHandlerFactory.cpp
+++ b/dbms/programs/server/MySQLHandlerFactory.cpp
@@ -56,26 +56,26 @@ MySQLHandlerFactory::MySQLHandlerFactory(IServer & server_)
 void MySQLHandlerFactory::readRSAKeys()
 {
     const Poco::Util::LayeredConfiguration & config = Poco::Util::Application::instance().config();
-    String certificateFileProperty = "openSSL.server.certificateFile";
-    String privateKeyFileProperty = "openSSL.server.privateKeyFile";
+    String certificate_file_property = "openSSL.server.certificateFile";
+    String private_key_file_property = "openSSL.server.privateKeyFile";
 
-    if (!config.has(certificateFileProperty))
+    if (!config.has(certificate_file_property))
         throw Exception("Certificate file is not set.", ErrorCodes::NO_ELEMENTS_IN_CONFIG);
 
-    if (!config.has(privateKeyFileProperty))
+    if (!config.has(private_key_file_property))
         throw Exception("Private key file is not set.", ErrorCodes::NO_ELEMENTS_IN_CONFIG);
 
     {
-        String certificateFile = config.getString(certificateFileProperty);
-        FILE * fp = fopen(certificateFile.data(), "r");
+        String certificate_file = config.getString(certificate_file_property);
+        FILE * fp = fopen(certificate_file.data(), "r");
         if (fp == nullptr)
-            throw Exception("Cannot open certificate file: " + certificateFile + ".", ErrorCodes::CANNOT_OPEN_FILE);
+            throw Exception("Cannot open certificate file: " + certificate_file + ".", ErrorCodes::CANNOT_OPEN_FILE);
         SCOPE_EXIT(fclose(fp));
 
         X509 * x509 = PEM_read_X509(fp, nullptr, nullptr, nullptr);
         SCOPE_EXIT(X509_free(x509));
         if (x509 == nullptr)
-            throw Exception("Failed to read PEM certificate from " + certificateFile + ". Error: " + getOpenSSLErrors(), ErrorCodes::OPENSSL_ERROR);
+            throw Exception("Failed to read PEM certificate from " + certificate_file + ". Error: " + getOpenSSLErrors(), ErrorCodes::OPENSSL_ERROR);
 
         EVP_PKEY * p = X509_get_pubkey(x509);
         if (p == nullptr)
@@ -88,16 +88,16 @@ void MySQLHandlerFactory::readRSAKeys()
     }
 
     {
-        String privateKeyFile = config.getString(privateKeyFileProperty);
+        String private_key_file = config.getString(private_key_file_property);
 
-        FILE * fp = fopen(privateKeyFile.data(), "r");
+        FILE * fp = fopen(private_key_file.data(), "r");
         if (fp == nullptr)
-            throw Exception ("Cannot open private key file " + privateKeyFile + ".", ErrorCodes::CANNOT_OPEN_FILE);
+            throw Exception ("Cannot open private key file " + private_key_file + ".", ErrorCodes::CANNOT_OPEN_FILE);
         SCOPE_EXIT(fclose(fp));
 
         private_key.reset(PEM_read_RSAPrivateKey(fp, nullptr, nullptr, nullptr));
         if (!private_key)
-            throw Exception("Failed to read RSA private key from " + privateKeyFile + ". Error: " + getOpenSSLErrors(), ErrorCodes::OPENSSL_ERROR);
+            throw Exception("Failed to read RSA private key from " + private_key_file + ". Error: " + getOpenSSLErrors(), ErrorCodes::OPENSSL_ERROR);
     }
 }
 
diff --git a/dbms/programs/server/Server.cpp b/dbms/programs/server/Server.cpp
index 96ba2883480..5322514e7c2 100644
--- a/dbms/programs/server/Server.cpp
+++ b/dbms/programs/server/Server.cpp
@@ -162,12 +162,12 @@ int Server::run()
 {
     if (config().hasOption("help"))
     {
-        Poco::Util::HelpFormatter helpFormatter(Server::options());
+        Poco::Util::HelpFormatter help_formatter(Server::options());
         std::stringstream header;
         header << commandName() << " [OPTION] [-- [ARG]...]\n";
         header << "positional arguments can be used to rewrite config.xml properties, for example, --http_port=8010";
-        helpFormatter.setHeader(header.str());
-        helpFormatter.format(std::cout);
+        help_formatter.setHeader(header.str());
+        help_formatter.format(std::cout);
         return 0;
     }
     if (config().hasOption("version"))
diff --git a/dbms/src/Access/QuotaCache.cpp b/dbms/src/Access/QuotaCache.cpp
index cdf298d0e57..6db3eb66c5d 100644
--- a/dbms/src/Access/QuotaCache.cpp
+++ b/dbms/src/Access/QuotaCache.cpp
@@ -101,7 +101,7 @@ boost::shared_ptr<const EnabledQuota::Intervals> QuotaCache::QuotaInfo::rebuildI
     new_intervals->quota_key = key;
     auto & intervals = new_intervals->intervals;
     intervals.reserve(quota->all_limits.size());
-    constexpr size_t MAX_RESOURCE_TYPE = Quota::MAX_RESOURCE_TYPE;
+    static constexpr size_t MAX_RESOURCE_TYPE = Quota::MAX_RESOURCE_TYPE;
     for (const auto & limits : quota->all_limits)
     {
         intervals.emplace_back();
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionGroupArrayMoving.cpp b/dbms/src/AggregateFunctions/AggregateFunctionGroupArrayMoving.cpp
index 52fe70a30b5..31a921c3b2c 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionGroupArrayMoving.cpp
+++ b/dbms/src/AggregateFunctions/AggregateFunctionGroupArrayMoving.cpp
@@ -20,32 +20,32 @@ namespace ErrorCodes
 namespace
 {
 
-template <typename T, typename Tlimit_num_elems>
+template <typename T, typename LimitNumberOfElements>
 struct MovingSum
 {
     using DataType = MovingSumData<T>;
-    using Function = MovingImpl<T, Tlimit_num_elems, DataType>;
+    using Function = MovingImpl<T, LimitNumberOfElements, DataType>;
 };
 
-template <typename T, typename Tlimit_num_elems>
+template <typename T, typename LimitNumberOfElements>
 struct MovingAvg
 {
     using DataType = MovingAvgData<T>;
-    using Function = MovingImpl<T, Tlimit_num_elems, DataType>;
+    using Function = MovingImpl<T, LimitNumberOfElements, DataType>;
 };
 
-template <typename T, typename Tlimit_num_elems> using MovingSumTemplate = typename MovingSum<T, Tlimit_num_elems>::Function;
-template <typename T, typename Tlimit_num_elems> using MovingAvgTemplate = typename MovingAvg<T, Tlimit_num_elems>::Function;
+template <typename T, typename LimitNumberOfElements> using MovingSumTemplate = typename MovingSum<T, LimitNumberOfElements>::Function;
+template <typename T, typename LimitNumberOfElements> using MovingAvgTemplate = typename MovingAvg<T, LimitNumberOfElements>::Function;
 
-template <template <typename, typename> class Function, typename has_limit, typename ... TArgs>
+template <template <typename, typename> class Function, typename HasLimit, typename ... TArgs>
 inline AggregateFunctionPtr createAggregateFunctionMovingImpl(const std::string & name, const DataTypePtr & argument_type, TArgs ... args)
 {
     AggregateFunctionPtr res;
 
     if (isDecimal(argument_type))
-        res.reset(createWithDecimalType<Function, has_limit>(*argument_type, argument_type, std::forward<TArgs>(args)...));
+        res.reset(createWithDecimalType<Function, HasLimit>(*argument_type, argument_type, std::forward<TArgs>(args)...));
     else
-        res.reset(createWithNumericType<Function, has_limit>(*argument_type, argument_type, std::forward<TArgs>(args)...));
+        res.reset(createWithNumericType<Function, HasLimit>(*argument_type, argument_type, std::forward<TArgs>(args)...));
 
     if (!res)
         throw Exception("Illegal type " + argument_type->getName() + " of argument for aggregate function " + name,
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionGroupUniqArray.cpp b/dbms/src/AggregateFunctions/AggregateFunctionGroupUniqArray.cpp
index 64a8200aa52..552089bb58d 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionGroupUniqArray.cpp
+++ b/dbms/src/AggregateFunctions/AggregateFunctionGroupUniqArray.cpp
@@ -21,48 +21,48 @@ namespace
 {
 
 /// Substitute return type for Date and DateTime
-template <typename has_limit>
-class AggregateFunctionGroupUniqArrayDate : public AggregateFunctionGroupUniqArray<DataTypeDate::FieldType, has_limit>
+template <typename HasLimit>
+class AggregateFunctionGroupUniqArrayDate : public AggregateFunctionGroupUniqArray<DataTypeDate::FieldType, HasLimit>
 {
 public:
     explicit AggregateFunctionGroupUniqArrayDate(const DataTypePtr & argument_type, UInt64 max_elems_ = std::numeric_limits<UInt64>::max())
-        : AggregateFunctionGroupUniqArray<DataTypeDate::FieldType, has_limit>(argument_type, max_elems_) {}
+        : AggregateFunctionGroupUniqArray<DataTypeDate::FieldType, HasLimit>(argument_type, max_elems_) {}
     DataTypePtr getReturnType() const override { return std::make_shared<DataTypeArray>(std::make_shared<DataTypeDate>()); }
 };
 
-template <typename has_limit>
-class AggregateFunctionGroupUniqArrayDateTime : public AggregateFunctionGroupUniqArray<DataTypeDateTime::FieldType, has_limit>
+template <typename HasLimit>
+class AggregateFunctionGroupUniqArrayDateTime : public AggregateFunctionGroupUniqArray<DataTypeDateTime::FieldType, HasLimit>
 {
 public:
     explicit AggregateFunctionGroupUniqArrayDateTime(const DataTypePtr & argument_type, UInt64 max_elems_ = std::numeric_limits<UInt64>::max())
-        : AggregateFunctionGroupUniqArray<DataTypeDateTime::FieldType, has_limit>(argument_type, max_elems_) {}
+        : AggregateFunctionGroupUniqArray<DataTypeDateTime::FieldType, HasLimit>(argument_type, max_elems_) {}
     DataTypePtr getReturnType() const override { return std::make_shared<DataTypeArray>(std::make_shared<DataTypeDateTime>()); }
 };
 
-template <typename has_limit, typename ... TArgs>
+template <typename HasLimit, typename ... TArgs>
 static IAggregateFunction * createWithExtraTypes(const DataTypePtr & argument_type, TArgs && ... args)
 {
     WhichDataType which(argument_type);
-    if (which.idx == TypeIndex::Date) return new AggregateFunctionGroupUniqArrayDate<has_limit>(argument_type, std::forward<TArgs>(args)...);
-    else if (which.idx == TypeIndex::DateTime) return new AggregateFunctionGroupUniqArrayDateTime<has_limit>(argument_type, std::forward<TArgs>(args)...);
+    if (which.idx == TypeIndex::Date) return new AggregateFunctionGroupUniqArrayDate<HasLimit>(argument_type, std::forward<TArgs>(args)...);
+    else if (which.idx == TypeIndex::DateTime) return new AggregateFunctionGroupUniqArrayDateTime<HasLimit>(argument_type, std::forward<TArgs>(args)...);
     else
     {
         /// Check that we can use plain version of AggregateFunctionGroupUniqArrayGeneric
         if (argument_type->isValueUnambiguouslyRepresentedInContiguousMemoryRegion())
-            return new AggregateFunctionGroupUniqArrayGeneric<true, has_limit>(argument_type, std::forward<TArgs>(args)...);
+            return new AggregateFunctionGroupUniqArrayGeneric<true, HasLimit>(argument_type, std::forward<TArgs>(args)...);
         else
-            return new AggregateFunctionGroupUniqArrayGeneric<false, has_limit>(argument_type, std::forward<TArgs>(args)...);
+            return new AggregateFunctionGroupUniqArrayGeneric<false, HasLimit>(argument_type, std::forward<TArgs>(args)...);
     }
 }
 
-template <typename has_limit, typename ... TArgs>
+template <typename HasLimit, typename ... TArgs>
 inline AggregateFunctionPtr createAggregateFunctionGroupUniqArrayImpl(const std::string & name, const DataTypePtr & argument_type, TArgs ... args)
 {
 
-    AggregateFunctionPtr res(createWithNumericType<AggregateFunctionGroupUniqArray, has_limit, const DataTypePtr &, TArgs...>(*argument_type, argument_type, std::forward<TArgs>(args)...));
+    AggregateFunctionPtr res(createWithNumericType<AggregateFunctionGroupUniqArray, HasLimit, const DataTypePtr &, TArgs...>(*argument_type, argument_type, std::forward<TArgs>(args)...));
 
     if (!res)
-        res = AggregateFunctionPtr(createWithExtraTypes<has_limit>(argument_type, std::forward<TArgs>(args)...));
+        res = AggregateFunctionPtr(createWithExtraTypes<HasLimit>(argument_type, std::forward<TArgs>(args)...));
 
     if (!res)
         throw Exception("Illegal type " + argument_type->getName() +
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionMLMethod.cpp b/dbms/src/AggregateFunctions/AggregateFunctionMLMethod.cpp
index 8ddbaa906fb..e028e585d5c 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionMLMethod.cpp
+++ b/dbms/src/AggregateFunctions/AggregateFunctionMLMethod.cpp
@@ -130,7 +130,7 @@ LinearModelData::LinearModelData(
     gradient_batch.resize(param_num_ + 1, Float64{0.0});
 }
 
-void LinearModelData::update_state()
+void LinearModelData::updateState()
 {
     if (batch_size == 0)
         return;
@@ -197,7 +197,7 @@ void LinearModelData::merge(const DB::LinearModelData & rhs)
     if (iter_num == 0 && rhs.iter_num == 0)
         return;
 
-    update_state();
+    updateState();
     /// can't update rhs state because it's constant
 
     /// squared mean is more stable (in sence of quality of prediction) when two states with quietly different number of learning steps are merged
@@ -219,13 +219,13 @@ void LinearModelData::add(const IColumn ** columns, size_t row_num)
     Float64 target = (*columns[0]).getFloat64(row_num);
 
     /// Here we have columns + 1 as first column corresponds to target value, and others - to features
-    weights_updater->add_to_batch(
+    weights_updater->addToBatch(
         gradient_batch, *gradient_computer, weights, bias, l2_reg_coef, target, columns + 1, row_num);
 
     ++batch_size;
     if (batch_size == batch_capacity)
     {
-        update_state();
+        updateState();
     }
 }
 
@@ -300,7 +300,7 @@ void Adam::update(UInt64 batch_size, std::vector<Float64> & weights, Float64 & b
     beta2_powered_ *= beta2_;
 }
 
-void Adam::add_to_batch(
+void Adam::addToBatch(
         std::vector<Float64> & batch_gradient,
         IGradientComputer & gradient_computer,
         const std::vector<Float64> & weights,
@@ -358,7 +358,7 @@ void Nesterov::update(UInt64 batch_size, std::vector<Float64> & weights, Float64
     bias += accumulated_gradient[weights.size()];
 }
 
-void Nesterov::add_to_batch(
+void Nesterov::addToBatch(
     std::vector<Float64> & batch_gradient,
     IGradientComputer & gradient_computer,
     const std::vector<Float64> & weights,
@@ -432,7 +432,7 @@ void StochasticGradientDescent::update(
     bias += (learning_rate * batch_gradient[weights.size()]) / batch_size;
 }
 
-void IWeightsUpdater::add_to_batch(
+void IWeightsUpdater::addToBatch(
     std::vector<Float64> & batch_gradient,
     IGradientComputer & gradient_computer,
     const std::vector<Float64> & weights,
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionMLMethod.h b/dbms/src/AggregateFunctions/AggregateFunctionMLMethod.h
index 64c40bc0583..bb241074a1e 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionMLMethod.h
+++ b/dbms/src/AggregateFunctions/AggregateFunctionMLMethod.h
@@ -112,7 +112,7 @@ public:
     virtual ~IWeightsUpdater() = default;
 
     /// Calls GradientComputer to update current mini-batch
-    virtual void add_to_batch(
+    virtual void addToBatch(
         std::vector<Float64> & batch_gradient,
         IGradientComputer & gradient_computer,
         const std::vector<Float64> & weights,
@@ -176,7 +176,7 @@ public:
 
     Nesterov(Float64 alpha) : alpha_(alpha) {}
 
-    void add_to_batch(
+    void addToBatch(
         std::vector<Float64> & batch_gradient,
         IGradientComputer & gradient_computer,
         const std::vector<Float64> & weights,
@@ -209,7 +209,7 @@ public:
         beta2_powered_ = beta2_;
     }
 
-    void add_to_batch(
+    void addToBatch(
             std::vector<Float64> & batch_gradient,
             IGradientComputer & gradient_computer,
             const std::vector<Float64> & weights,
@@ -289,7 +289,7 @@ private:
 
     /** The function is called when we want to flush current batch and update our weights
       */
-    void update_state();
+    void updateState();
 };
 
 
diff --git a/dbms/src/Columns/ColumnAggregateFunction.cpp b/dbms/src/Columns/ColumnAggregateFunction.cpp
index ce07acd1c0d..21d90830a96 100644
--- a/dbms/src/Columns/ColumnAggregateFunction.cpp
+++ b/dbms/src/Columns/ColumnAggregateFunction.cpp
@@ -91,13 +91,13 @@ MutableColumnPtr ColumnAggregateFunction::predictValues(Block & block, const Col
     MutableColumnPtr res = func->getReturnTypeToPredict()->createColumn();
     res->reserve(data.size());
 
-    auto ML_function = func.get();
-    if (ML_function)
+    auto machine_learning_function = func.get();
+    if (machine_learning_function)
     {
         if (data.size() == 1)
         {
             /// Case for const column. Predict using single model.
-            ML_function->predictValues(data[0], *res, block, 0, block.rows(), arguments, context);
+            machine_learning_function->predictValues(data[0], *res, block, 0, block.rows(), arguments, context);
         }
         else
         {
@@ -105,7 +105,7 @@ MutableColumnPtr ColumnAggregateFunction::predictValues(Block & block, const Col
             size_t row_num = 0;
             for (auto val : data)
             {
-                ML_function->predictValues(val, *res, block, row_num, 1, arguments, context);
+                machine_learning_function->predictValues(val, *res, block, row_num, 1, arguments, context);
                 ++row_num;
             }
         }
diff --git a/dbms/src/Columns/ColumnArray.cpp b/dbms/src/Columns/ColumnArray.cpp
index 2c98e873cb6..0d3ae76bad2 100644
--- a/dbms/src/Columns/ColumnArray.cpp
+++ b/dbms/src/Columns/ColumnArray.cpp
@@ -152,16 +152,15 @@ void ColumnArray::insertData(const char * pos, size_t length)
 {
     /** Similarly - only for arrays of fixed length values.
       */
-    IColumn * data_ = &getData();
-    if (!data_->isFixedAndContiguous())
+    if (!data->isFixedAndContiguous())
         throw Exception("Method insertData is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);
 
-    size_t field_size = data_->sizeOfValueIfFixed();
+    size_t field_size = data->sizeOfValueIfFixed();
 
     const char * end = pos + length;
     size_t elems = 0;
     for (; pos + field_size <= end; pos += field_size, ++elems)
-        data_->insertData(pos, field_size);
+        data->insertData(pos, field_size);
 
     if (pos != end)
         throw Exception("Incorrect length argument for method ColumnArray::insertData", ErrorCodes::BAD_ARGUMENTS);
@@ -278,12 +277,12 @@ int ColumnArray::compareAt(size_t n, size_t m, const IColumn & rhs_, int nan_dir
 namespace
 {
     template <bool positive>
-    struct less
+    struct Less
     {
         const ColumnArray & parent;
         int nan_direction_hint;
 
-        less(const ColumnArray & parent_, int nan_direction_hint_)
+        Less(const ColumnArray & parent_, int nan_direction_hint_)
             : parent(parent_), nan_direction_hint(nan_direction_hint_) {}
 
         bool operator()(size_t lhs, size_t rhs) const
@@ -300,7 +299,7 @@ namespace
 void ColumnArray::reserve(size_t n)
 {
     getOffsets().reserve(n);
-    getData().reserve(n);        /// The average size of arrays is not taken into account here. Or it is considered to be no more than 1.
+    getData().reserve(n); /// The average size of arrays is not taken into account here. Or it is considered to be no more than 1.
 }
 
 
@@ -689,16 +688,16 @@ void ColumnArray::getPermutation(bool reverse, size_t limit, int nan_direction_h
     if (limit)
     {
         if (reverse)
-            std::partial_sort(res.begin(), res.begin() + limit, res.end(), less<false>(*this, nan_direction_hint));
+            std::partial_sort(res.begin(), res.begin() + limit, res.end(), Less<false>(*this, nan_direction_hint));
         else
-            std::partial_sort(res.begin(), res.begin() + limit, res.end(), less<true>(*this, nan_direction_hint));
+            std::partial_sort(res.begin(), res.begin() + limit, res.end(), Less<true>(*this, nan_direction_hint));
     }
     else
     {
         if (reverse)
-            std::sort(res.begin(), res.end(), less<false>(*this, nan_direction_hint));
+            std::sort(res.begin(), res.end(), Less<false>(*this, nan_direction_hint));
         else
-            std::sort(res.begin(), res.end(), less<true>(*this, nan_direction_hint));
+            std::sort(res.begin(), res.end(), Less<true>(*this, nan_direction_hint));
     }
 }
 
@@ -738,13 +737,13 @@ ColumnPtr ColumnArray::replicateNumber(const Offsets & replicate_offsets) const
     if (0 == col_size)
         return res;
 
-    ColumnArray & res_ = typeid_cast<ColumnArray &>(*res);
+    ColumnArray & res_arr = typeid_cast<ColumnArray &>(*res);
 
     const typename ColumnVector<T>::Container & src_data = typeid_cast<const ColumnVector<T> &>(*data).getData();
     const Offsets & src_offsets = getOffsets();
 
-    typename ColumnVector<T>::Container & res_data = typeid_cast<ColumnVector<T> &>(res_.getData()).getData();
-    Offsets & res_offsets = res_.getOffsets();
+    typename ColumnVector<T>::Container & res_data = typeid_cast<ColumnVector<T> &>(res_arr.getData()).getData();
+    Offsets & res_offsets = res_arr.getOffsets();
 
     res_data.reserve(data->size() / col_size * replicate_offsets.back());
     res_offsets.reserve(replicate_offsets.back());
@@ -789,16 +788,16 @@ ColumnPtr ColumnArray::replicateString(const Offsets & replicate_offsets) const
     if (0 == col_size)
         return res;
 
-    ColumnArray & res_ = assert_cast<ColumnArray &>(*res);
+    ColumnArray & res_arr = assert_cast<ColumnArray &>(*res);
 
     const ColumnString & src_string = typeid_cast<const ColumnString &>(*data);
     const ColumnString::Chars & src_chars = src_string.getChars();
     const Offsets & src_string_offsets = src_string.getOffsets();
     const Offsets & src_offsets = getOffsets();
 
-    ColumnString::Chars & res_chars = typeid_cast<ColumnString &>(res_.getData()).getChars();
-    Offsets & res_string_offsets = typeid_cast<ColumnString &>(res_.getData()).getOffsets();
-    Offsets & res_offsets = res_.getOffsets();
+    ColumnString::Chars & res_chars = typeid_cast<ColumnString &>(res_arr.getData()).getChars();
+    Offsets & res_string_offsets = typeid_cast<ColumnString &>(res_arr.getData()).getOffsets();
+    Offsets & res_offsets = res_arr.getOffsets();
 
     res_chars.reserve(src_chars.size() / col_size * replicate_offsets.back());
     res_string_offsets.reserve(src_string_offsets.size() / col_size * replicate_offsets.back());
diff --git a/dbms/src/Columns/ColumnFunction.cpp b/dbms/src/Columns/ColumnFunction.cpp
index 1585078b80b..aec9067efaa 100644
--- a/dbms/src/Columns/ColumnFunction.cpp
+++ b/dbms/src/Columns/ColumnFunction.cpp
@@ -124,8 +124,8 @@ std::vector<MutableColumnPtr> ColumnFunction::scatter(IColumn::ColumnIndex num_c
     for (IColumn::ColumnIndex part = 0; part < num_columns; ++part)
     {
         auto & capture = captures[part];
-        size_t size__ = capture.empty() ? counts[part] : capture.front().column->size();
-        columns.emplace_back(ColumnFunction::create(size__, function, std::move(capture)));
+        size_t capture_size = capture.empty() ? counts[part] : capture.front().column->size();
+        columns.emplace_back(ColumnFunction::create(capture_size, function, std::move(capture)));
     }
 
     return columns;
diff --git a/dbms/src/Columns/ColumnLowCardinality.cpp b/dbms/src/Columns/ColumnLowCardinality.cpp
index aaec56f37cc..7b8b176b37d 100644
--- a/dbms/src/Columns/ColumnLowCardinality.cpp
+++ b/dbms/src/Columns/ColumnLowCardinality.cpp
@@ -401,25 +401,25 @@ void ColumnLowCardinality::Index::callForType(Callback && callback, size_t size_
 
 size_t ColumnLowCardinality::Index::getSizeOfIndexType(const IColumn & column, size_t hint)
 {
-    auto checkFor = [&](auto type) { return typeid_cast<const ColumnVector<decltype(type)> *>(&column) != nullptr; };
-    auto tryGetSizeFor = [&](auto type) -> size_t { return checkFor(type) ? sizeof(decltype(type)) : 0; };
+    auto check_for = [&](auto type) { return typeid_cast<const ColumnVector<decltype(type)> *>(&column) != nullptr; };
+    auto try_get_size_for = [&](auto type) -> size_t { return check_for(type) ? sizeof(decltype(type)) : 0; };
 
     if (hint)
     {
         size_t size = 0;
-        callForType([&](auto type) { size = tryGetSizeFor(type); }, hint);
+        callForType([&](auto type) { size = try_get_size_for(type); }, hint);
 
         if (size)
             return size;
     }
 
-    if (auto size = tryGetSizeFor(UInt8()))
+    if (auto size = try_get_size_for(UInt8()))
         return size;
-    if (auto size = tryGetSizeFor(UInt16()))
+    if (auto size = try_get_size_for(UInt16()))
         return size;
-    if (auto size = tryGetSizeFor(UInt32()))
+    if (auto size = try_get_size_for(UInt32()))
         return size;
-    if (auto size = tryGetSizeFor(UInt64()))
+    if (auto size = try_get_size_for(UInt64()))
         return size;
 
     throw Exception("Unexpected indexes type for ColumnLowCardinality. Expected UInt, got " + column.getName(),
@@ -515,13 +515,13 @@ UInt64 ColumnLowCardinality::Index::getMaxPositionForCurrentType() const
 size_t ColumnLowCardinality::Index::getPositionAt(size_t row) const
 {
     size_t pos;
-    auto getPosition = [&](auto type)
+    auto get_position = [&](auto type)
     {
         using CurIndexType = decltype(type);
         pos = getPositionsData<CurIndexType>()[row];
     };
 
-    callForType(std::move(getPosition), size_of_type);
+    callForType(std::move(get_position), size_of_type);
     return pos;
 }
 
@@ -536,7 +536,7 @@ void ColumnLowCardinality::Index::insertPosition(UInt64 position)
 
 void ColumnLowCardinality::Index::insertPositionsRange(const IColumn & column, UInt64 offset, UInt64 limit)
 {
-    auto insertForType = [&](auto type)
+    auto insert_for_type = [&](auto type)
     {
         using ColumnType = decltype(type);
         const auto * column_ptr = typeid_cast<const ColumnVector<ColumnType> *>(&column);
@@ -570,10 +570,10 @@ void ColumnLowCardinality::Index::insertPositionsRange(const IColumn & column, U
         return true;
     };
 
-    if (!insertForType(UInt8()) &&
-        !insertForType(UInt16()) &&
-        !insertForType(UInt32()) &&
-        !insertForType(UInt64()))
+    if (!insert_for_type(UInt8()) &&
+        !insert_for_type(UInt16()) &&
+        !insert_for_type(UInt32()) &&
+        !insert_for_type(UInt64()))
         throw Exception("Invalid column for ColumnLowCardinality index. Expected UInt, got " + column.getName(),
                         ErrorCodes::ILLEGAL_COLUMN);
 
diff --git a/dbms/src/Common/Dwarf.cpp b/dbms/src/Common/Dwarf.cpp
index 1a73d7866c2..6d3d8fdf0ee 100644
--- a/dbms/src/Common/Dwarf.cpp
+++ b/dbms/src/Common/Dwarf.cpp
@@ -223,24 +223,24 @@ Dwarf::Path::Path(std::string_view baseDir, std::string_view subDir, std::string
 size_t Dwarf::Path::size() const
 {
     size_t size = 0;
-    bool needsSlash = false;
+    bool needs_slash = false;
 
     if (!baseDir_.empty())
     {
         size += baseDir_.size();
-        needsSlash = baseDir_.back() != '/';
+        needs_slash = baseDir_.back() != '/';
     }
 
     if (!subDir_.empty())
     {
-        size += needsSlash;
+        size += needs_slash;
         size += subDir_.size();
-        needsSlash = subDir_.back() != '/';
+        needs_slash = subDir_.back() != '/';
     }
 
     if (!file_.empty())
     {
-        size += needsSlash;
+        size += needs_slash;
         size += file_.size();
     }
 
@@ -249,38 +249,38 @@ size_t Dwarf::Path::size() const
 
 size_t Dwarf::Path::toBuffer(char * buf, size_t bufSize) const
 {
-    size_t totalSize = 0;
-    bool needsSlash = false;
+    size_t total_size = 0;
+    bool needs_slash = false;
 
     auto append = [&](std::string_view sp)
     {
         if (bufSize >= 2)
         {
-            size_t toCopy = std::min(sp.size(), bufSize - 1);
-            memcpy(buf, sp.data(), toCopy);
-            buf += toCopy;
-            bufSize -= toCopy;
+            size_t to_copy = std::min(sp.size(), bufSize - 1);
+            memcpy(buf, sp.data(), to_copy);
+            buf += to_copy;
+            bufSize -= to_copy;
         }
-        totalSize += sp.size();
+        total_size += sp.size();
     };
 
     if (!baseDir_.empty())
     {
         append(baseDir_);
-        needsSlash = baseDir_.back() != '/';
+        needs_slash = baseDir_.back() != '/';
     }
     if (!subDir_.empty())
     {
-        if (needsSlash)
+        if (needs_slash)
         {
             append("/");
         }
         append(subDir_);
-        needsSlash = subDir_.back() != '/';
+        needs_slash = subDir_.back() != '/';
     }
     if (!file_.empty())
     {
-        if (needsSlash)
+        if (needs_slash)
         {
             append("/");
         }
@@ -291,14 +291,14 @@ size_t Dwarf::Path::toBuffer(char * buf, size_t bufSize) const
         *buf = '\0';
     }
 
-    SAFE_CHECK(totalSize == size(), "Size mismatch");
-    return totalSize;
+    SAFE_CHECK(total_size == size(), "Size mismatch");
+    return total_size;
 }
 
 void Dwarf::Path::toString(std::string & dest) const
 {
-    size_t initialSize = dest.size();
-    dest.reserve(initialSize + size());
+    size_t initial_size = dest.size();
+    dest.reserve(initial_size + size());
     if (!baseDir_.empty())
     {
         dest.append(baseDir_.begin(), baseDir_.end());
@@ -319,7 +319,7 @@ void Dwarf::Path::toString(std::string & dest) const
         }
         dest.append(file_.begin(), file_.end());
     }
-    SAFE_CHECK(dest.size() == initialSize + size(), "Size mismatch");
+    SAFE_CHECK(dest.size() == initial_size + size(), "Size mismatch");
 }
 
 // Next chunk in section
@@ -332,9 +332,9 @@ bool Dwarf::Section::next(std::string_view & chunk)
     // Initial length is a uint32_t value for a 32-bit section, and
     // a 96-bit value (0xffffffff followed by the 64-bit length) for a 64-bit
     // section.
-    auto initialLength = read<uint32_t>(chunk);
-    is64Bit_ = (initialLength == uint32_t(-1));
-    auto length = is64Bit_ ? read<uint64_t>(chunk) : initialLength;
+    auto initial_length = read<uint32_t>(chunk);
+    is64Bit_ = (initial_length == uint32_t(-1));
+    auto length = is64Bit_ ? read<uint64_t>(chunk) : initial_length;
     SAFE_CHECK(length <= chunk.size(), "invalid DWARF section");
     chunk = std::string_view(chunk.data(), length);
     data_ = std::string_view(chunk.end(), data_.end() - chunk.end());
@@ -387,7 +387,7 @@ bool Dwarf::readAbbreviation(std::string_view & section, DIEAbbreviation & abbr)
     abbr.hasChildren = (read<uint8_t>(section) != DW_CHILDREN_no);
 
     // attributes
-    const char * attributeBegin = section.data();
+    const char * attribute_begin = section.data();
     for (;;)
     {
         SAFE_CHECK(!section.empty(), "invalid attribute section");
@@ -396,7 +396,7 @@ bool Dwarf::readAbbreviation(std::string_view & section, DIEAbbreviation & abbr)
             break;
     }
 
-    abbr.attributes = std::string_view(attributeBegin, section.data() - attributeBegin);
+    abbr.attributes = std::string_view(attribute_begin, section.data() - attribute_begin);
     return true;
 }
 
@@ -483,18 +483,18 @@ std::string_view Dwarf::getStringFromStringSection(uint64_t offset) const
  */
 bool Dwarf::findDebugInfoOffset(uintptr_t address, std::string_view aranges, uint64_t & offset)
 {
-    Section arangesSection(aranges);
+    Section aranges_section(aranges);
     std::string_view chunk;
-    while (arangesSection.next(chunk))
+    while (aranges_section.next(chunk))
     {
         auto version = read<uint16_t>(chunk);
         SAFE_CHECK(version == 2, "invalid aranges version");
 
-        offset = readOffset(chunk, arangesSection.is64Bit());
-        auto addressSize = read<uint8_t>(chunk);
-        SAFE_CHECK(addressSize == sizeof(uintptr_t), "invalid address size");
-        auto segmentSize = read<uint8_t>(chunk);
-        SAFE_CHECK(segmentSize == 0, "segmented architecture not supported");
+        offset = readOffset(chunk, aranges_section.is64Bit());
+        auto address_size = read<uint8_t>(chunk);
+        SAFE_CHECK(address_size == sizeof(uintptr_t), "invalid address size");
+        auto segment_size = read<uint8_t>(chunk);
+        SAFE_CHECK(segment_size == 0, "segmented architecture not supported");
 
         // Padded to a multiple of 2 addresses.
         // Strangely enough, this is the only place in the DWARF spec that requires
@@ -537,15 +537,15 @@ bool Dwarf::findLocation(uintptr_t address, std::string_view & infoEntry, Locati
     //  3. debug_abbrev_offset (4B or 8B): offset into the .debug_abbrev section
     //  4. address_size (1B)
 
-    Section debugInfoSection(infoEntry);
+    Section debug_info_section(infoEntry);
     std::string_view chunk;
-    SAFE_CHECK(debugInfoSection.next(chunk), "invalid debug info");
+    SAFE_CHECK(debug_info_section.next(chunk), "invalid debug info");
 
     auto version = read<uint16_t>(chunk);
     SAFE_CHECK(version >= 2 && version <= 4, "invalid info version");
-    uint64_t abbrevOffset = readOffset(chunk, debugInfoSection.is64Bit());
-    auto addressSize = read<uint8_t>(chunk);
-    SAFE_CHECK(addressSize == sizeof(uintptr_t), "invalid address size");
+    uint64_t abbrev_offset = readOffset(chunk, debug_info_section.is64Bit());
+    auto address_size = read<uint8_t>(chunk);
+    SAFE_CHECK(address_size == sizeof(uintptr_t), "invalid address size");
 
     // We survived so far. The first (and only) DIE should be DW_TAG_compile_unit
     // NOTE: - binutils <= 2.25 does not issue DW_TAG_partial_unit.
@@ -553,16 +553,16 @@ bool Dwarf::findLocation(uintptr_t address, std::string_view & infoEntry, Locati
     // TODO(tudorb): Handle DW_TAG_partial_unit?
     auto code = readULEB(chunk);
     SAFE_CHECK(code != 0, "invalid code");
-    auto abbr = getAbbreviation(code, abbrevOffset);
+    auto abbr = getAbbreviation(code, abbrev_offset);
     SAFE_CHECK(abbr.tag == DW_TAG_compile_unit, "expecting compile unit entry");
     // Skip children entries, remove_prefix to the next compilation unit entry.
     infoEntry.remove_prefix(chunk.end() - infoEntry.begin());
 
     // Read attributes, extracting the few we care about
-    bool foundLineOffset = false;
-    uint64_t lineOffset = 0;
-    std::string_view compilationDirectory;
-    std::string_view mainFileName;
+    bool found_line_offset = false;
+    uint64_t line_offset = 0;
+    std::string_view compilation_directory;
+    std::string_view main_file_name;
 
     DIEAbbreviation::Attribute attr;
     std::string_view attributes = abbr.attributes;
@@ -573,43 +573,43 @@ bool Dwarf::findLocation(uintptr_t address, std::string_view & infoEntry, Locati
         {
             break;
         }
-        auto val = readAttributeValue(chunk, attr.form, debugInfoSection.is64Bit());
+        auto val = readAttributeValue(chunk, attr.form, debug_info_section.is64Bit());
         switch (attr.name)
         {
             case DW_AT_stmt_list:
                 // Offset in .debug_line for the line number VM program for this
                 // compilation unit
-                lineOffset = std::get<uint64_t>(val);
-                foundLineOffset = true;
+                line_offset = std::get<uint64_t>(val);
+                found_line_offset = true;
                 break;
             case DW_AT_comp_dir:
                 // Compilation directory
-                compilationDirectory = std::get<std::string_view>(val);
+                compilation_directory = std::get<std::string_view>(val);
                 break;
             case DW_AT_name:
                 // File name of main file being compiled
-                mainFileName = std::get<std::string_view>(val);
+                main_file_name = std::get<std::string_view>(val);
                 break;
         }
     }
 
-    if (!mainFileName.empty())
+    if (!main_file_name.empty())
     {
         locationInfo.hasMainFile = true;
-        locationInfo.mainFile = Path(compilationDirectory, "", mainFileName);
+        locationInfo.mainFile = Path(compilation_directory, "", main_file_name);
     }
 
-    if (!foundLineOffset)
+    if (!found_line_offset)
     {
         return false;
     }
 
-    std::string_view lineSection(line_);
-    lineSection.remove_prefix(lineOffset);
-    LineNumberVM lineVM(lineSection, compilationDirectory);
+    std::string_view line_section(line_);
+    line_section.remove_prefix(line_offset);
+    LineNumberVM line_vm(line_section, compilation_directory);
 
     // Execute line number VM program to find file and line
-    locationInfo.hasFileAndLine = lineVM.findAddress(address, locationInfo.file, locationInfo.line);
+    locationInfo.hasFileAndLine = line_vm.findAddress(address, locationInfo.file, locationInfo.line);
     return locationInfo.hasFileAndLine;
 }
 
@@ -635,9 +635,9 @@ bool Dwarf::findAddress(uintptr_t address, LocationInfo & locationInfo, Location
         if (findDebugInfoOffset(address, aranges_, offset))
         {
             // Read compilation unit header from .debug_info
-            std::string_view infoEntry(info_);
-            infoEntry.remove_prefix(offset);
-            findLocation(address, infoEntry, locationInfo);
+            std::string_view info_entry(info_);
+            info_entry.remove_prefix(offset);
+            findLocation(address, info_entry, locationInfo);
             return locationInfo.hasFileAndLine;
         }
         else if (mode == LocationInfoMode::FAST)
@@ -657,9 +657,9 @@ bool Dwarf::findAddress(uintptr_t address, LocationInfo & locationInfo, Location
 
     // Slow path (linear scan): Iterate over all .debug_info entries
     // and look for the address in each compilation unit.
-    std::string_view infoEntry(info_);
-    while (!infoEntry.empty() && !locationInfo.hasFileAndLine)
-        findLocation(address, infoEntry, locationInfo);
+    std::string_view info_entry(info_);
+    while (!info_entry.empty() && !locationInfo.hasFileAndLine)
+        findLocation(address, info_entry, locationInfo);
 
     return locationInfo.hasFileAndLine;
 }
@@ -693,16 +693,16 @@ void Dwarf::LineNumberVM::init()
 {
     version_ = read<uint16_t>(data_);
     SAFE_CHECK(version_ >= 2 && version_ <= 4, "invalid version in line number VM");
-    uint64_t headerLength = readOffset(data_, is64Bit_);
-    SAFE_CHECK(headerLength <= data_.size(), "invalid line number VM header length");
-    std::string_view header(data_.data(), headerLength);
+    uint64_t header_length = readOffset(data_, is64Bit_);
+    SAFE_CHECK(header_length <= data_.size(), "invalid line number VM header length");
+    std::string_view header(data_.data(), header_length);
     data_ = std::string_view(header.end(), data_.end() - header.end());
 
     minLength_ = read<uint8_t>(header);
     if (version_ == 4)
     { // Version 2 and 3 records don't have this
-        uint8_t maxOpsPerInstruction = read<uint8_t>(header);
-        SAFE_CHECK(maxOpsPerInstruction == 1, "VLIW not supported");
+        uint8_t max_ops_per_instruction = read<uint8_t>(header);
+        SAFE_CHECK(max_ops_per_instruction == 1, "VLIW not supported");
     }
     defaultIsStmt_ = read<uint8_t>(header);
     lineBase_ = read<int8_t>(header); // yes, signed
@@ -752,10 +752,10 @@ Dwarf::LineNumberVM::FileName Dwarf::LineNumberVM::getFileName(uint64_t index) c
     FileName fn;
     if (index <= fileNameCount_)
     {
-        std::string_view fileNames = fileNames_;
+        std::string_view file_names = fileNames_;
         for (; index; --index)
         {
-            if (!readFileName(fileNames, fn))
+            if (!readFileName(file_names, fn))
             {
                 abort();
             }
@@ -783,11 +783,11 @@ std::string_view Dwarf::LineNumberVM::getIncludeDirectory(uint64_t index) const
 
     SAFE_CHECK(index <= includeDirectoryCount_, "invalid include directory");
 
-    std::string_view includeDirectories = includeDirectories_;
+    std::string_view include_directories = includeDirectories_;
     std::string_view dir;
     for (; index; --index)
     {
-        dir = readNullTerminated(includeDirectories);
+        dir = readNullTerminated(include_directories);
         if (dir.empty())
         {
             abort(); // BUG
@@ -825,8 +825,8 @@ bool Dwarf::LineNumberVM::nextDefineFile(std::string_view & program, FileName &
         if (opcode != 0)
         { // standard opcode
             // Skip, slurp the appropriate number of LEB arguments
-            uint8_t argCount = standardOpcodeLengths_[opcode - 1];
-            while (argCount--)
+            uint8_t arg_count = standardOpcodeLengths_[opcode - 1];
+            while (arg_count--)
             {
                 readULEB(program);
             }
@@ -858,11 +858,11 @@ Dwarf::LineNumberVM::StepResult Dwarf::LineNumberVM::step(std::string_view & pro
 
     if (opcode >= opcodeBase_)
     { // special opcode
-        uint8_t adjustedOpcode = opcode - opcodeBase_;
-        uint8_t opAdvance = adjustedOpcode / lineRange_;
+        uint8_t adjusted_opcode = opcode - opcodeBase_;
+        uint8_t op_advance = adjusted_opcode / lineRange_;
 
-        address_ += minLength_ * opAdvance;
-        line_ += lineBase_ + adjustedOpcode % lineRange_;
+        address_ += minLength_ * op_advance;
+        line_ += lineBase_ + adjusted_opcode % lineRange_;
 
         basicBlock_ = false;
         prologueEnd_ = false;
@@ -932,8 +932,8 @@ Dwarf::LineNumberVM::StepResult Dwarf::LineNumberVM::step(std::string_view & pro
 
         // Unrecognized standard opcode, slurp the appropriate number of LEB
         // arguments.
-        uint8_t argCount = standardOpcodeLengths_[opcode - 1];
-        while (argCount--)
+        uint8_t arg_count = standardOpcodeLengths_[opcode - 1];
+        while (arg_count--)
         {
             readULEB(program);
         }
@@ -944,10 +944,10 @@ Dwarf::LineNumberVM::StepResult Dwarf::LineNumberVM::step(std::string_view & pro
     auto length = readULEB(program);
     // the opcode itself should be included in the length, so length >= 1
     SAFE_CHECK(length != 0, "invalid extended opcode length");
-    auto extendedOpcode = read<uint8_t>(program);
+    auto extended_opcode = read<uint8_t>(program);
     --length;
 
-    switch (extendedOpcode)
+    switch (extended_opcode)
     {
         case DW_LNE_end_sequence:
             return END;
@@ -987,15 +987,15 @@ bool Dwarf::LineNumberVM::findAddress(uintptr_t target, Path & file, uint64_t &
     State state = START;
     reset();
 
-    uint64_t prevFile = 0;
-    uint64_t prevLine = 0;
+    uint64_t prev_file = 0;
+    uint64_t prev_line = 0;
     while (!program.empty())
     {
-        bool seqEnd = !next(program);
+        bool seq_end = !next(program);
 
         if (state == START)
         {
-            if (!seqEnd)
+            if (!seq_end)
             {
                 state = address_ <= target ? LOW_SEQ : HIGH_SEQ;
             }
@@ -1008,20 +1008,20 @@ bool Dwarf::LineNumberVM::findAddress(uintptr_t target, Path & file, uint64_t &
                 // Found it!  Note that ">" is indeed correct (not ">="), as each
                 // sequence is guaranteed to have one entry past-the-end (emitted by
                 // DW_LNE_end_sequence)
-                if (prevFile == 0)
+                if (prev_file == 0)
                 {
                     return false;
                 }
-                auto fn = getFileName(prevFile);
+                auto fn = getFileName(prev_file);
                 file = Path(compilationDirectory_, getIncludeDirectory(fn.directoryIndex), fn.relativeName);
-                line = prevLine;
+                line = prev_line;
                 return true;
             }
-            prevFile = file_;
-            prevLine = line_;
+            prev_file = file_;
+            prev_line = line_;
         }
 
-        if (seqEnd)
+        if (seq_end)
         {
             state = START;
             reset();
diff --git a/dbms/src/Common/PoolBase.h b/dbms/src/Common/PoolBase.h
index 306abb7d381..201f9ec1d00 100644
--- a/dbms/src/Common/PoolBase.h
+++ b/dbms/src/Common/PoolBase.h
@@ -74,7 +74,7 @@ public:
         /** The `Entry` object protects the resource from being used by another thread.
           * The following methods are forbidden for `rvalue`, so you can not write a similar to
           *
-          * auto q = pool.Get()->query("SELECT .."); // Oops, after this line Entry was destroyed
+          * auto q = pool.get()->query("SELECT .."); // Oops, after this line Entry was destroyed
           * q.execute (); // Someone else can use this Connection
           */
         Object * operator->() && = delete;
diff --git a/dbms/src/Common/RWLock.cpp b/dbms/src/Common/RWLock.cpp
index b17e5e32674..5dfc1b55c63 100644
--- a/dbms/src/Common/RWLock.cpp
+++ b/dbms/src/Common/RWLock.cpp
@@ -64,7 +64,7 @@ public:
 private:
     /// A separate method which binds the lock holder to the owned lock
     /// N.B. It is very important that this method produces no allocations
-    bool bind_with(RWLock && parent_, GroupsContainer::iterator it_group_) noexcept
+    bool bindWith(RWLock && parent_, GroupsContainer::iterator it_group_) noexcept
     {
         if (bound)
             return false;
@@ -170,7 +170,7 @@ RWLockImpl::LockHolder RWLockImpl::getLock(RWLockImpl::Type type, const String &
             /// N.B. Type is Read here, query_id is not empty and it_query is a valid iterator
             all_read_locks.add(query_id);                                     /// SM1: may throw on insertion (nothing to roll back)
             ++it_query->second;                                               /// SM2: nothrow
-            lock_holder->bind_with(shared_from_this(), current_owner_group);  /// SM3: nothrow
+            lock_holder->bindWith(shared_from_this(), current_owner_group);  /// SM3: nothrow
 
             finalize_metrics();
             return lock_holder;
@@ -244,7 +244,7 @@ RWLockImpl::LockHolder RWLockImpl::getLock(RWLockImpl::Type type, const String &
         }
     }
 
-    lock_holder->bind_with(shared_from_this(), it_group);  /// SM: nothrow
+    lock_holder->bindWith(shared_from_this(), it_group);  /// SM: nothrow
 
     finalize_metrics();
     return lock_holder;
diff --git a/dbms/src/Common/ThreadFuzzer.cpp b/dbms/src/Common/ThreadFuzzer.cpp
index 0176934cbe9..2c1bb3c2744 100644
--- a/dbms/src/Common/ThreadFuzzer.cpp
+++ b/dbms/src/Common/ThreadFuzzer.cpp
@@ -212,11 +212,11 @@ void ThreadFuzzer::setup()
     if (sigaction(SIGPROF, &sa, nullptr))
         throwFromErrno("Failed to setup signal handler for thread fuzzer", ErrorCodes::CANNOT_SET_SIGNAL_HANDLER);
 
-    static constexpr UInt32 TIMER_PRECISION = 1000000;
+    static constexpr UInt32 timer_precision = 1000000;
 
     struct timeval interval;
-    interval.tv_sec = cpu_time_period_us / TIMER_PRECISION;
-    interval.tv_usec = cpu_time_period_us % TIMER_PRECISION;
+    interval.tv_sec = cpu_time_period_us / timer_precision;
+    interval.tv_usec = cpu_time_period_us % timer_precision;
 
     struct itimerval timer = {.it_interval = interval, .it_value = interval};
 
diff --git a/dbms/src/Common/ZooKeeper/ZooKeeperImpl.cpp b/dbms/src/Common/ZooKeeper/ZooKeeperImpl.cpp
index c55a2738a2a..b8700a93e35 100644
--- a/dbms/src/Common/ZooKeeper/ZooKeeperImpl.cpp
+++ b/dbms/src/Common/ZooKeeper/ZooKeeperImpl.cpp
@@ -758,17 +758,17 @@ struct ZooKeeperMultiResponse final : MultiResponse, ZooKeeperResponse
         {
             ZooKeeper::OpNum op_num;
             bool done;
-            int32_t error_;
+            int32_t error_read;
 
             Coordination::read(op_num, in);
             Coordination::read(done, in);
-            Coordination::read(error_, in);
+            Coordination::read(error_read, in);
 
             if (!done)
                 throw Exception("Too many results received for multi transaction", ZMARSHALLINGERROR);
             if (op_num != -1)
                 throw Exception("Unexpected op_num received at the end of results for multi transaction", ZMARSHALLINGERROR);
-            if (error_ != -1)
+            if (error_read != -1)
                 throw Exception("Unexpected error value received at the end of results for multi transaction", ZMARSHALLINGERROR);
         }
     }
diff --git a/dbms/src/Common/tests/parallel_aggregation.cpp b/dbms/src/Common/tests/parallel_aggregation.cpp
index 5b70386fd9f..a4254f565e4 100644
--- a/dbms/src/Common/tests/parallel_aggregation.cpp
+++ b/dbms/src/Common/tests/parallel_aggregation.cpp
@@ -32,7 +32,7 @@ struct SmallLock
 {
     std::atomic<int> locked {false};
 
-    bool try_lock()
+    bool tryLock()
     {
         int expected = 0;
         return locked.compare_exchange_strong(expected, 1, std::memory_order_acquire);
diff --git a/dbms/src/Compression/CompressionCodecGorilla.cpp b/dbms/src/Compression/CompressionCodecGorilla.cpp
index ab1d9614d99..5782da791a1 100644
--- a/dbms/src/Compression/CompressionCodecGorilla.cpp
+++ b/dbms/src/Compression/CompressionCodecGorilla.cpp
@@ -61,7 +61,7 @@ UInt32 getCompressedDataSize(UInt8 data_bytes_size, UInt32 uncompressed_size)
     return (items_count * max_item_size_bits + 8) / 8;
 }
 
-struct binary_value_info
+struct BinaryValueInfo
 {
     UInt8 leading_zero_bits;
     UInt8 data_bits;
@@ -69,7 +69,7 @@ struct binary_value_info
 };
 
 template <typename T>
-binary_value_info getLeadingAndTrailingBits(const T & value)
+BinaryValueInfo getLeadingAndTrailingBits(const T & value)
 {
     constexpr UInt8 bit_size = sizeof(T) * 8;
 
@@ -77,7 +77,7 @@ binary_value_info getLeadingAndTrailingBits(const T & value)
     const UInt8 tz = getTrailingZeroBits(value);
     const UInt8 data_size = value == 0 ? 0 : static_cast<UInt8>(bit_size - lz - tz);
 
-    return binary_value_info{lz, data_size, tz};
+    return BinaryValueInfo{lz, data_size, tz};
 }
 
 template <typename T>
@@ -99,7 +99,7 @@ UInt32 compressDataForType(const char * source, UInt32 source_size, char * dest,
 
     T prev_value{};
     // That would cause first XORed value to be written in-full.
-    binary_value_info prev_xored_info{0, 0, 0};
+    BinaryValueInfo prev_xored_info{0, 0, 0};
 
     if (source < source_end)
     {
@@ -118,7 +118,7 @@ UInt32 compressDataForType(const char * source, UInt32 source_size, char * dest,
         source += sizeof(curr_value);
 
         const auto xored_data = curr_value ^ prev_value;
-        const binary_value_info curr_xored_info = getLeadingAndTrailingBits(xored_data);
+        const BinaryValueInfo curr_xored_info = getLeadingAndTrailingBits(xored_data);
 
         if (xored_data == 0)
         {
@@ -177,14 +177,14 @@ void decompressDataForType(const char * source, UInt32 source_size, char * dest)
 
     BitReader reader(source, source_size - sizeof(items_count) - sizeof(prev_value));
 
-    binary_value_info prev_xored_info{0, 0, 0};
+    BinaryValueInfo prev_xored_info{0, 0, 0};
 
     // since data is tightly packed, up to 1 bit per value, and last byte is padded with zeroes,
     // we have to keep track of items to avoid reading more that there is.
     for (UInt32 items_read = 1; items_read < items_count && !reader.eof(); ++items_read)
     {
         T curr_value = prev_value;
-        binary_value_info curr_xored_info = prev_xored_info;
+        BinaryValueInfo curr_xored_info = prev_xored_info;
         T xored_data{};
 
         if (reader.readBit() == 1)
diff --git a/dbms/src/Compression/tests/gtest_compressionCodec.cpp b/dbms/src/Compression/tests/gtest_compressionCodec.cpp
index df9471718d1..a6bfdaebb14 100644
--- a/dbms/src/Compression/tests/gtest_compressionCodec.cpp
+++ b/dbms/src/Compression/tests/gtest_compressionCodec.cpp
@@ -171,7 +171,7 @@ public:
         return current_value;
     }
 
-    size_t ItemsLeft() const
+    size_t itemsLeft() const
     {
         return reinterpret_cast<const char *>(data_end) - reinterpret_cast<const char *>(data);
     }
@@ -184,7 +184,7 @@ public:
 
     explicit operator bool() const
     {
-        return ItemsLeft() > 0;
+        return itemsLeft() > 0;
     }
 
 private:
@@ -230,7 +230,7 @@ template <typename T, typename ContainerLeft, typename ContainerRight>
     auto l = AsSequenceOf<T>(left);
     auto r = AsSequenceOf<T>(right);
 
-    const auto MAX_MISMATCHING_ITEMS = 5;
+    static constexpr auto MAX_MISMATCHING_ITEMS = 5;
     int mismatching_items = 0;
     size_t i = 0;
 
@@ -607,7 +607,7 @@ TEST_P(CodecTestPerformance, TranscodingWithDataType)
         }
     }
 
-    auto computeMeanAndStdDev = [](const auto & values)
+    auto compute_mean_and_stddev = [](const auto & values)
     {
         double mean{};
 
@@ -648,7 +648,7 @@ TEST_P(CodecTestPerformance, TranscodingWithDataType)
     for (const auto & k : {"encoding", "decoding"})
     {
         const auto & values = results[k];
-        const auto & [mean, std_dev] = computeMeanAndStdDev(values);
+        const auto & [mean, std_dev] = compute_mean_and_stddev(values);
         // Ensure that Coefficient of variation is reasonably low, otherwise these numbers are meaningless
         EXPECT_GT(0.05, std_dev / mean);
         std::cerr << "\t" << std::fixed << std::setprecision(1) << mean / 1000.0;
@@ -1128,7 +1128,7 @@ template <typename ValueType>
 auto DDCompatibilityTestSequence()
 {
     // Generates sequences with double delta in given range.
-    auto ddGenerator = [prev_delta = static_cast<Int64>(0), prev = static_cast<Int64>(0)](auto dd) mutable
+    auto dd_generator = [prev_delta = static_cast<Int64>(0), prev = static_cast<Int64>(0)](auto dd) mutable
     {
         const auto curr = dd + prev + prev_delta;
         prev = curr;
@@ -1150,7 +1150,7 @@ auto DDCompatibilityTestSequence()
 
         // - 4 is to allow DD value to settle before transitioning through important point,
         // since DD depends on 2 previous values of data, + 2 is arbitrary.
-        ret.append(generateSeq<ValueType>(G(ddGenerator), p - 4, p + 2));
+        ret.append(generateSeq<ValueType>(G(dd_generator), p - 4, p + 2));
     }
 
     return ret;
diff --git a/dbms/src/Core/DecimalComparison.h b/dbms/src/Core/DecimalComparison.h
index 151b4480818..a5f5d07c9b1 100644
--- a/dbms/src/Core/DecimalComparison.h
+++ b/dbms/src/Core/DecimalComparison.h
@@ -191,7 +191,7 @@ private:
                 const ColumnConst * c0_const = checkAndGetColumnConst<ColVecA>(c0.get());
                 A a = c0_const->template getValue<A>();
                 if (const ColVecB * c1_vec = checkAndGetColumn<ColVecB>(c1.get()))
-                    constant_vector<scale_left, scale_right>(a, c1_vec->getData(), vec_res, scale);
+                    constantVector<scale_left, scale_right>(a, c1_vec->getData(), vec_res, scale);
                 else
                     throw Exception("Wrong column in Decimal comparison", ErrorCodes::LOGICAL_ERROR);
             }
@@ -200,7 +200,7 @@ private:
                 const ColumnConst * c1_const = checkAndGetColumnConst<ColVecB>(c1.get());
                 B b = c1_const->template getValue<B>();
                 if (const ColVecA * c0_vec = checkAndGetColumn<ColVecA>(c0.get()))
-                    vector_constant<scale_left, scale_right>(c0_vec->getData(), b, vec_res, scale);
+                    vectorConstant<scale_left, scale_right>(c0_vec->getData(), b, vec_res, scale);
                 else
                     throw Exception("Wrong column in Decimal comparison", ErrorCodes::LOGICAL_ERROR);
             }
@@ -209,7 +209,7 @@ private:
                 if (const ColVecA * c0_vec = checkAndGetColumn<ColVecA>(c0.get()))
                 {
                     if (const ColVecB * c1_vec = checkAndGetColumn<ColVecB>(c1.get()))
-                        vector_vector<scale_left, scale_right>(c0_vec->getData(), c1_vec->getData(), vec_res, scale);
+                        vectorVector<scale_left, scale_right>(c0_vec->getData(), c1_vec->getData(), vec_res, scale);
                     else
                         throw Exception("Wrong column in Decimal comparison", ErrorCodes::LOGICAL_ERROR);
                 }
@@ -260,7 +260,7 @@ private:
     }
 
     template <bool scale_left, bool scale_right>
-    static void NO_INLINE vector_vector(const ArrayA & a, const ArrayB & b, PaddedPODArray<UInt8> & c,
+    static void NO_INLINE vectorVector(const ArrayA & a, const ArrayB & b, PaddedPODArray<UInt8> & c,
                                         CompareInt scale)
     {
         size_t size = a.size();
@@ -279,7 +279,7 @@ private:
     }
 
     template <bool scale_left, bool scale_right>
-    static void NO_INLINE vector_constant(const ArrayA & a, B b, PaddedPODArray<UInt8> & c, CompareInt scale)
+    static void NO_INLINE vectorConstant(const ArrayA & a, B b, PaddedPODArray<UInt8> & c, CompareInt scale)
     {
         size_t size = a.size();
         const A * a_pos = a.data();
@@ -295,7 +295,7 @@ private:
     }
 
     template <bool scale_left, bool scale_right>
-    static void NO_INLINE constant_vector(A a, const ArrayB & b, PaddedPODArray<UInt8> & c, CompareInt scale)
+    static void NO_INLINE constantVector(A a, const ArrayB & b, PaddedPODArray<UInt8> & c, CompareInt scale)
     {
         size_t size = b.size();
         const B * b_pos = b.data();
diff --git a/dbms/src/DataTypes/DataTypeDateTime64.cpp b/dbms/src/DataTypes/DataTypeDateTime64.cpp
index d790dd60ce4..8f4ef3f52e4 100644
--- a/dbms/src/DataTypes/DataTypeDateTime64.cpp
+++ b/dbms/src/DataTypes/DataTypeDateTime64.cpp
@@ -205,15 +205,15 @@ std::conditional_t<Kind == ArgumentKind::Optional, std::optional<T>, T>
 getArgument(const ASTPtr & arguments, size_t argument_index, const char * argument_name, const std::string context_data_type_name)
 {
     using NearestResultType = NearestFieldType<T>;
-    const auto fieldType = Field::TypeToEnum<NearestResultType>::value;
+    const auto field_type = Field::TypeToEnum<NearestResultType>::value;
     const ASTLiteral * argument = nullptr;
 
-    auto exceptionMessage = [=](const String & message)
+    auto exception_message = [=](const String & message)
     {
         return std::string("Parameter #") + std::to_string(argument_index) + " '"
                 + argument_name + "' for " + context_data_type_name
                 + message
-                + ", expected: " + Field::Types::toString(fieldType) + " literal.";
+                + ", expected: " + Field::Types::toString(field_type) + " literal.";
     };
 
     if (!arguments || arguments->children.size() <= argument_index
@@ -222,12 +222,12 @@ getArgument(const ASTPtr & arguments, size_t argument_index, const char * argume
         if constexpr (Kind == ArgumentKind::Optional)
             return {};
         else
-            throw Exception(exceptionMessage(" is missing"),
+            throw Exception(exception_message(" is missing"),
                             ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
     }
 
-    if (argument->value.getType() != fieldType)
-        throw Exception(exceptionMessage(String(" has wrong type: ") + argument->value.getTypeName()),
+    if (argument->value.getType() != field_type)
+        throw Exception(exception_message(String(" has wrong type: ") + argument->value.getTypeName()),
                         ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
     return argument->value.get<NearestResultType>();
diff --git a/dbms/src/DataTypes/DataTypeLowCardinality.cpp b/dbms/src/DataTypes/DataTypeLowCardinality.cpp
index ebec1571e9e..c271b06416b 100644
--- a/dbms/src/DataTypes/DataTypeLowCardinality.cpp
+++ b/dbms/src/DataTypes/DataTypeLowCardinality.cpp
@@ -604,7 +604,7 @@ void DataTypeLowCardinality::deserializeBinaryBulkWithMultipleStreams(
     auto * low_cardinality_state = checkAndGetLowCardinalityDeserializeState(state);
     KeysSerializationVersion::checkVersion(low_cardinality_state->key_version.value);
 
-    auto readDictionary = [this, low_cardinality_state, keys_stream]()
+    auto read_dictionary = [this, low_cardinality_state, keys_stream]()
     {
         UInt64 num_keys;
         readIntBinary(num_keys, *keys_stream);
@@ -617,7 +617,7 @@ void DataTypeLowCardinality::deserializeBinaryBulkWithMultipleStreams(
         low_cardinality_state->global_dictionary = std::move(column_unique);
     };
 
-    auto readAdditionalKeys = [this, low_cardinality_state, indexes_stream]()
+    auto read_additional_keys = [this, low_cardinality_state, indexes_stream]()
     {
         UInt64 num_keys;
         readIntBinary(num_keys, *indexes_stream);
@@ -636,7 +636,7 @@ void DataTypeLowCardinality::deserializeBinaryBulkWithMultipleStreams(
         }
     };
 
-    auto readIndexes = [this, low_cardinality_state, indexes_stream, &low_cardinality_column](UInt64 num_rows)
+    auto read_indexes = [this, low_cardinality_state, indexes_stream, &low_cardinality_column](UInt64 num_rows)
     {
         auto indexes_type = low_cardinality_state->index_type.getDataType();
         MutableColumnPtr indexes_column = indexes_type->createColumn();
@@ -715,12 +715,12 @@ void DataTypeLowCardinality::deserializeBinaryBulkWithMultipleStreams(
                 !global_dictionary || index_type.need_update_dictionary || low_cardinality_state->need_update_dictionary;
             if (index_type.need_global_dictionary && need_update_dictionary)
             {
-                readDictionary();
+                read_dictionary();
                 low_cardinality_state->need_update_dictionary = false;
             }
 
             if (low_cardinality_state->index_type.has_additional_keys)
-                readAdditionalKeys();
+                read_additional_keys();
             else
                 low_cardinality_state->additional_keys = nullptr;
 
@@ -728,7 +728,7 @@ void DataTypeLowCardinality::deserializeBinaryBulkWithMultipleStreams(
         }
 
         size_t num_rows_to_read = std::min<UInt64>(limit, low_cardinality_state->num_pending_rows);
-        readIndexes(num_rows_to_read);
+        read_indexes(num_rows_to_read);
         limit -= num_rows_to_read;
         low_cardinality_state->num_pending_rows -= num_rows_to_read;
     }
diff --git a/dbms/src/DataTypes/getMostSubtype.cpp b/dbms/src/DataTypes/getMostSubtype.cpp
index aebc0729088..54609219cf1 100644
--- a/dbms/src/DataTypes/getMostSubtype.cpp
+++ b/dbms/src/DataTypes/getMostSubtype.cpp
@@ -46,8 +46,7 @@ String getExceptionMessagePrefix(const DataTypes & types)
 
 DataTypePtr getMostSubtype(const DataTypes & types, bool throw_if_result_is_nothing, bool force_support_conversion)
 {
-
-    auto getNothingOrThrow = [throw_if_result_is_nothing, & types](const std::string & reason)
+    auto get_nothing_or_throw = [throw_if_result_is_nothing, & types](const std::string & reason)
     {
         if (throw_if_result_is_nothing)
             throw Exception(getExceptionMessagePrefix(types) + reason, ErrorCodes::NO_COMMON_TYPE);
@@ -92,7 +91,7 @@ DataTypePtr getMostSubtype(const DataTypes & types, bool throw_if_result_is_noth
     {
         for (const auto & type : types)
             if (typeid_cast<const DataTypeNothing *>(type.get()))
-                return getNothingOrThrow(" because some of them are Nothing");
+                return get_nothing_or_throw(" because some of them are Nothing");
     }
 
     /// For Arrays
@@ -117,7 +116,7 @@ DataTypePtr getMostSubtype(const DataTypes & types, bool throw_if_result_is_noth
         if (have_array)
         {
             if (!all_arrays)
-                return getNothingOrThrow(" because some of them are Array and some of them are not");
+                return get_nothing_or_throw(" because some of them are Array and some of them are not");
 
             return std::make_shared<DataTypeArray>(getMostSubtype(nested_types, false, force_support_conversion));
         }
@@ -143,7 +142,7 @@ DataTypePtr getMostSubtype(const DataTypes & types, bool throw_if_result_is_noth
                         nested_types[elem_idx].reserve(types.size());
                 }
                 else if (tuple_size != type_tuple->getElements().size())
-                    return getNothingOrThrow(" because Tuples have different sizes");
+                    return get_nothing_or_throw(" because Tuples have different sizes");
 
                 have_tuple = true;
 
@@ -157,7 +156,7 @@ DataTypePtr getMostSubtype(const DataTypes & types, bool throw_if_result_is_noth
         if (have_tuple)
         {
             if (!all_tuples)
-                return getNothingOrThrow(" because some of them are Tuple and some of them are not");
+                return get_nothing_or_throw(" because some of them are Tuple and some of them are not");
 
             DataTypes common_tuple_types(tuple_size);
             for (size_t elem_idx = 0; elem_idx < tuple_size; ++elem_idx)
@@ -218,7 +217,7 @@ DataTypePtr getMostSubtype(const DataTypes & types, bool throw_if_result_is_noth
                 if (!fixed_string_type)
                     fixed_string_type = type;
                 else if (!type->equals(*fixed_string_type))
-                    return getNothingOrThrow(" because some of them are FixedStrings with different length");
+                    return get_nothing_or_throw(" because some of them are FixedStrings with different length");
             }
             else if (isString(type))
                 have_string = true;
@@ -229,7 +228,7 @@ DataTypePtr getMostSubtype(const DataTypes & types, bool throw_if_result_is_noth
         if (have_string)
         {
             if (!all_strings)
-                return getNothingOrThrow(" because some of them are String/FixedString and some of them are not");
+                return get_nothing_or_throw(" because some of them are String/FixedString and some of them are not");
 
             return fixed_string_type ? fixed_string_type : std::make_shared<DataTypeString>();
         }
@@ -251,7 +250,7 @@ DataTypePtr getMostSubtype(const DataTypes & types, bool throw_if_result_is_noth
         if (have_date_or_datetime)
         {
             if (!all_date_or_datetime)
-                return getNothingOrThrow(" because some of them are Date/DateTime and some of them are not");
+                return get_nothing_or_throw(" because some of them are Date/DateTime and some of them are not");
 
             return std::make_shared<DataTypeDate>();
         }
@@ -300,7 +299,7 @@ DataTypePtr getMostSubtype(const DataTypes & types, bool throw_if_result_is_noth
         if (min_bits_of_signed_integer || min_bits_of_unsigned_integer || min_mantissa_bits_of_floating)
         {
             if (!all_numbers)
-                return getNothingOrThrow(" because some of them are numbers and some of them are not");
+                return get_nothing_or_throw(" because some of them are numbers and some of them are not");
 
             /// If the result must be floating.
             if (!min_bits_of_signed_integer && !min_bits_of_unsigned_integer)
@@ -349,7 +348,7 @@ DataTypePtr getMostSubtype(const DataTypes & types, bool throw_if_result_is_noth
     }
 
     /// All other data types (UUID, AggregateFunction, Enum...) are compatible only if they are the same (checked in trivial cases).
-    return getNothingOrThrow("");
+    return get_nothing_or_throw("");
 }
 
 }
diff --git a/dbms/src/Databases/DatabaseMySQL.cpp b/dbms/src/Databases/DatabaseMySQL.cpp
index b6cbe6d596d..959121585ea 100644
--- a/dbms/src/Databases/DatabaseMySQL.cpp
+++ b/dbms/src/Databases/DatabaseMySQL.cpp
@@ -260,7 +260,7 @@ std::map<String, UInt64> DatabaseMySQL::fetchTablesWithModificationTime() const
              " WHERE TABLE_SCHEMA = " << quote << database_name_in_mysql;
 
     std::map<String, UInt64> tables_with_modification_time;
-    MySQLBlockInputStream result(mysql_pool.Get(), query.str(), tables_status_sample_block, DEFAULT_BLOCK_SIZE);
+    MySQLBlockInputStream result(mysql_pool.get(), query.str(), tables_status_sample_block, DEFAULT_BLOCK_SIZE);
 
     while (Block block = result.read())
     {
@@ -305,7 +305,7 @@ std::map<String, NamesAndTypesList> DatabaseMySQL::fetchTablesColumnsList(const
           << " AND TABLE_NAME IN " << toQueryStringWithQuote(tables_name) << " ORDER BY ORDINAL_POSITION";
 
     const auto & external_table_functions_use_nulls = global_context.getSettings().external_table_functions_use_nulls;
-    MySQLBlockInputStream result(mysql_pool.Get(), query.str(), tables_columns_sample_block, DEFAULT_BLOCK_SIZE);
+    MySQLBlockInputStream result(mysql_pool.get(), query.str(), tables_columns_sample_block, DEFAULT_BLOCK_SIZE);
     while (Block block = result.read())
     {
         size_t rows = block.rows();
diff --git a/dbms/src/Databases/DatabaseOrdinary.cpp b/dbms/src/Databases/DatabaseOrdinary.cpp
index e8fcf19641d..a1f5ea1ae6f 100644
--- a/dbms/src/Databases/DatabaseOrdinary.cpp
+++ b/dbms/src/Databases/DatabaseOrdinary.cpp
@@ -198,7 +198,7 @@ void DatabaseOrdinary::startupTables(ThreadPool & thread_pool)
     AtomicStopwatch watch;
     std::atomic<size_t> tables_processed{0};
 
-    auto startupOneTable = [&](const StoragePtr & table)
+    auto startup_one_table = [&](const StoragePtr & table)
     {
         table->startup();
         logAboutProgress(log, ++tables_processed, total_tables, watch);
@@ -207,7 +207,7 @@ void DatabaseOrdinary::startupTables(ThreadPool & thread_pool)
     try
     {
         for (const auto & table : tables)
-            thread_pool.scheduleOrThrowOnError([&]() { startupOneTable(table.second); });
+            thread_pool.scheduleOrThrowOnError([&]() { startup_one_table(table.second); });
     }
     catch (...)
     {
diff --git a/dbms/src/Dictionaries/ClickHouseDictionarySource.cpp b/dbms/src/Dictionaries/ClickHouseDictionarySource.cpp
index e7f38173d8a..0894a655724 100644
--- a/dbms/src/Dictionaries/ClickHouseDictionarySource.cpp
+++ b/dbms/src/Dictionaries/ClickHouseDictionarySource.cpp
@@ -209,7 +209,7 @@ std::string ClickHouseDictionarySource::doInvalidateQuery(const std::string & re
 
 void registerDictionarySourceClickHouse(DictionarySourceFactory & factory)
 {
-    auto createTableSource = [=](const DictionaryStructure & dict_struct,
+    auto create_table_source = [=](const DictionaryStructure & dict_struct,
                                  const Poco::Util::AbstractConfiguration & config,
                                  const std::string & config_prefix,
                                  Block & sample_block,
@@ -218,7 +218,7 @@ void registerDictionarySourceClickHouse(DictionarySourceFactory & factory)
     {
         return std::make_unique<ClickHouseDictionarySource>(dict_struct, config, config_prefix + ".clickhouse", sample_block, context);
     };
-    factory.registerSource("clickhouse", createTableSource);
+    factory.registerSource("clickhouse", create_table_source);
 }
 
 }
diff --git a/dbms/src/Dictionaries/DictionaryFactory.cpp b/dbms/src/Dictionaries/DictionaryFactory.cpp
index 5dcd985aca4..1e985e81969 100644
--- a/dbms/src/Dictionaries/DictionaryFactory.cpp
+++ b/dbms/src/Dictionaries/DictionaryFactory.cpp
@@ -58,8 +58,8 @@ DictionaryPtr DictionaryFactory::create(
 
 DictionaryPtr DictionaryFactory::create(const std::string & name, const ASTCreateQuery & ast, const Context & context) const
 {
-    auto configurationFromAST = getDictionaryConfigurationFromAST(ast);
-    return DictionaryFactory::create(name, *configurationFromAST, "dictionary", context, true);
+    auto configuration = getDictionaryConfigurationFromAST(ast);
+    return DictionaryFactory::create(name, *configuration, "dictionary", context, true);
 }
 
 bool DictionaryFactory::isComplex(const std::string & layout_type) const
diff --git a/dbms/src/Dictionaries/ExecutableDictionarySource.cpp b/dbms/src/Dictionaries/ExecutableDictionarySource.cpp
index b978d00dc2d..d9903f759c0 100644
--- a/dbms/src/Dictionaries/ExecutableDictionarySource.cpp
+++ b/dbms/src/Dictionaries/ExecutableDictionarySource.cpp
@@ -216,7 +216,7 @@ std::string ExecutableDictionarySource::toString() const
 
 void registerDictionarySourceExecutable(DictionarySourceFactory & factory)
 {
-    auto createTableSource = [=](const DictionaryStructure & dict_struct,
+    auto create_table_source = [=](const DictionaryStructure & dict_struct,
                                  const Poco::Util::AbstractConfiguration & config,
                                  const std::string & config_prefix,
                                  Block & sample_block,
@@ -236,7 +236,7 @@ void registerDictionarySourceExecutable(DictionarySourceFactory & factory)
             dict_struct, config, config_prefix + ".executable",
             sample_block, context);
     };
-    factory.registerSource("executable", createTableSource);
+    factory.registerSource("executable", create_table_source);
 }
 
 }
diff --git a/dbms/src/Dictionaries/FileDictionarySource.cpp b/dbms/src/Dictionaries/FileDictionarySource.cpp
index 1de8cf6a057..5e7a784183c 100644
--- a/dbms/src/Dictionaries/FileDictionarySource.cpp
+++ b/dbms/src/Dictionaries/FileDictionarySource.cpp
@@ -70,7 +70,7 @@ Poco::Timestamp FileDictionarySource::getLastModification() const
 
 void registerDictionarySourceFile(DictionarySourceFactory & factory)
 {
-    auto createTableSource = [=](const DictionaryStructure & dict_struct,
+    auto create_table_source = [=](const DictionaryStructure & dict_struct,
                                  const Poco::Util::AbstractConfiguration & config,
                                  const std::string & config_prefix,
                                  Block & sample_block,
@@ -86,7 +86,7 @@ void registerDictionarySourceFile(DictionarySourceFactory & factory)
         return std::make_unique<FileDictionarySource>(filepath, format, sample_block, context, check_config);
     };
 
-    factory.registerSource("file", createTableSource);
+    factory.registerSource("file", create_table_source);
 }
 
 }
diff --git a/dbms/src/Dictionaries/HTTPDictionarySource.cpp b/dbms/src/Dictionaries/HTTPDictionarySource.cpp
index 0b7ce8d0af1..87d5381f30f 100644
--- a/dbms/src/Dictionaries/HTTPDictionarySource.cpp
+++ b/dbms/src/Dictionaries/HTTPDictionarySource.cpp
@@ -192,7 +192,7 @@ std::string HTTPDictionarySource::toString() const
 
 void registerDictionarySourceHTTP(DictionarySourceFactory & factory)
 {
-    auto createTableSource = [=](const DictionaryStructure & dict_struct,
+    auto create_table_source = [=](const DictionaryStructure & dict_struct,
                                  const Poco::Util::AbstractConfiguration & config,
                                  const std::string & config_prefix,
                                  Block & sample_block,
@@ -206,7 +206,7 @@ void registerDictionarySourceHTTP(DictionarySourceFactory & factory)
             dict_struct, config, config_prefix + ".http",
             sample_block, context, check_config);
     };
-    factory.registerSource("http", createTableSource);
+    factory.registerSource("http", create_table_source);
 }
 
 }
diff --git a/dbms/src/Dictionaries/LibraryDictionarySource.cpp b/dbms/src/Dictionaries/LibraryDictionarySource.cpp
index 10bbeda7a02..919411a28ea 100644
--- a/dbms/src/Dictionaries/LibraryDictionarySource.cpp
+++ b/dbms/src/Dictionaries/LibraryDictionarySource.cpp
@@ -151,9 +151,9 @@ LibraryDictionarySource::LibraryDictionarySource(
 #endif
     );
     settings = std::make_shared<CStringsHolder>(getLibSettings(config, config_prefix + lib_config_settings));
-    if (auto libNew = library->tryGet<decltype(lib_data) (*)(decltype(&settings->strings), decltype(&ClickHouseLibrary::log))>(
+    if (auto lib_new = library->tryGet<decltype(lib_data) (*)(decltype(&settings->strings), decltype(&ClickHouseLibrary::log))>(
             "ClickHouseDictionary_v3_libNew"))
-        lib_data = libNew(&settings->strings, ClickHouseLibrary::log);
+        lib_data = lib_new(&settings->strings, ClickHouseLibrary::log);
 }
 
 LibraryDictionarySource::LibraryDictionarySource(const LibraryDictionarySource & other)
@@ -166,18 +166,18 @@ LibraryDictionarySource::LibraryDictionarySource(const LibraryDictionarySource &
     , description{other.description}
     , settings{other.settings}
 {
-    if (auto libClone = library->tryGet<decltype(lib_data) (*)(decltype(other.lib_data))>("ClickHouseDictionary_v3_libClone"))
-        lib_data = libClone(other.lib_data);
+    if (auto lib_clone = library->tryGet<decltype(lib_data) (*)(decltype(other.lib_data))>("ClickHouseDictionary_v3_libClone"))
+        lib_data = lib_clone(other.lib_data);
     else if (
-        auto libNew = library->tryGet<decltype(lib_data) (*)(decltype(&settings->strings), decltype(&ClickHouseLibrary::log))>(
+        auto lib_new = library->tryGet<decltype(lib_data) (*)(decltype(&settings->strings), decltype(&ClickHouseLibrary::log))>(
             "ClickHouseDictionary_v3_libNew"))
-        lib_data = libNew(&settings->strings, ClickHouseLibrary::log);
+        lib_data = lib_new(&settings->strings, ClickHouseLibrary::log);
 }
 
 LibraryDictionarySource::~LibraryDictionarySource()
 {
-    if (auto libDelete = library->tryGet<void (*)(decltype(lib_data))>("ClickHouseDictionary_v3_libDelete"))
-        libDelete(lib_data);
+    if (auto lib_delete = library->tryGet<void (*)(decltype(lib_data))>("ClickHouseDictionary_v3_libDelete"))
+        lib_delete(lib_data);
 }
 
 BlockInputStreamPtr LibraryDictionarySource::loadAll()
@@ -196,10 +196,10 @@ BlockInputStreamPtr LibraryDictionarySource::loadAll()
     void * data_ptr = nullptr;
 
     /// Get function pointer before dataNew call because library->get may throw.
-    auto func_loadAll
+    auto func_load_all
         = library->get<void * (*)(decltype(data_ptr), decltype(&settings->strings), decltype(&columns))>("ClickHouseDictionary_v3_loadAll");
     data_ptr = library->get<decltype(data_ptr) (*)(decltype(lib_data))>("ClickHouseDictionary_v3_dataNew")(lib_data);
-    auto data = func_loadAll(data_ptr, &settings->strings, &columns);
+    auto data = func_load_all(data_ptr, &settings->strings, &columns);
     auto block = dataToBlock(description.sample_block, data);
     SCOPE_EXIT(library->get<void (*)(decltype(lib_data), decltype(data_ptr))>("ClickHouseDictionary_v3_dataDelete")(lib_data, data_ptr));
     return std::make_shared<OneBlockInputStream>(block);
@@ -222,11 +222,11 @@ BlockInputStreamPtr LibraryDictionarySource::loadIds(const std::vector<UInt64> &
     void * data_ptr = nullptr;
 
     /// Get function pointer before dataNew call because library->get may throw.
-    auto func_loadIds
+    auto func_load_ids
         = library->get<void * (*)(decltype(data_ptr), decltype(&settings->strings), decltype(&columns_pass), decltype(&ids_data))>(
             "ClickHouseDictionary_v3_loadIds");
     data_ptr = library->get<decltype(data_ptr) (*)(decltype(lib_data))>("ClickHouseDictionary_v3_dataNew")(lib_data);
-    auto data = func_loadIds(data_ptr, &settings->strings, &columns_pass, &ids_data);
+    auto data = func_load_ids(data_ptr, &settings->strings, &columns_pass, &ids_data);
     auto block = dataToBlock(description.sample_block, data);
     SCOPE_EXIT(library->get<void (*)(decltype(lib_data), decltype(data_ptr))>("ClickHouseDictionary_v3_dataDelete")(lib_data, data_ptr));
     return std::make_shared<OneBlockInputStream>(block);
@@ -256,10 +256,10 @@ BlockInputStreamPtr LibraryDictionarySource::loadKeys(const Columns & key_column
 
     void * data_ptr = nullptr;
     /// Get function pointer before dataNew call because library->get may throw.
-    auto func_loadKeys = library->get<void * (*)(decltype(data_ptr), decltype(&settings->strings), decltype(&request_cols))>(
+    auto func_load_keys = library->get<void * (*)(decltype(data_ptr), decltype(&settings->strings), decltype(&request_cols))>(
         "ClickHouseDictionary_v3_loadKeys");
     data_ptr = library->get<decltype(data_ptr) (*)(decltype(lib_data))>("ClickHouseDictionary_v3_dataNew")(lib_data);
-    auto data = func_loadKeys(data_ptr, &settings->strings, &request_cols);
+    auto data = func_load_keys(data_ptr, &settings->strings, &request_cols);
     auto block = dataToBlock(description.sample_block, data);
     SCOPE_EXIT(library->get<void (*)(decltype(lib_data), decltype(data_ptr))>("ClickHouseDictionary_v3_dataDelete")(lib_data, data_ptr));
     return std::make_shared<OneBlockInputStream>(block);
@@ -267,17 +267,17 @@ BlockInputStreamPtr LibraryDictionarySource::loadKeys(const Columns & key_column
 
 bool LibraryDictionarySource::isModified() const
 {
-    if (auto func_isModified
+    if (auto func_is_modified
         = library->tryGet<bool (*)(decltype(lib_data), decltype(&settings->strings))>("ClickHouseDictionary_v3_isModified"))
-        return func_isModified(lib_data, &settings->strings);
+        return func_is_modified(lib_data, &settings->strings);
     return true;
 }
 
 bool LibraryDictionarySource::supportsSelectiveLoad() const
 {
-    if (auto func_supportsSelectiveLoad
+    if (auto func_supports_selective_load
         = library->tryGet<bool (*)(decltype(lib_data), decltype(&settings->strings))>("ClickHouseDictionary_v3_supportsSelectiveLoad"))
-        return func_supportsSelectiveLoad(lib_data, &settings->strings);
+        return func_supports_selective_load(lib_data, &settings->strings);
     return true;
 }
 
@@ -293,7 +293,7 @@ std::string LibraryDictionarySource::toString() const
 
 void registerDictionarySourceLibrary(DictionarySourceFactory & factory)
 {
-    auto createTableSource = [=](const DictionaryStructure & dict_struct,
+    auto create_table_source = [=](const DictionaryStructure & dict_struct,
                                  const Poco::Util::AbstractConfiguration & config,
                                  const std::string & config_prefix,
                                  Block & sample_block,
@@ -302,7 +302,7 @@ void registerDictionarySourceLibrary(DictionarySourceFactory & factory)
     {
         return std::make_unique<LibraryDictionarySource>(dict_struct, config, config_prefix + ".library", sample_block, context, check_config);
     };
-    factory.registerSource("library", createTableSource);
+    factory.registerSource("library", create_table_source);
 }
 
 }
diff --git a/dbms/src/Dictionaries/MongoDBDictionarySource.cpp b/dbms/src/Dictionaries/MongoDBDictionarySource.cpp
index 14d902ba404..0484315aec0 100644
--- a/dbms/src/Dictionaries/MongoDBDictionarySource.cpp
+++ b/dbms/src/Dictionaries/MongoDBDictionarySource.cpp
@@ -12,7 +12,7 @@ namespace ErrorCodes
 
 void registerDictionarySourceMongoDB(DictionarySourceFactory & factory)
 {
-    auto createTableSource = [=](const DictionaryStructure & dict_struct,
+    auto create_table_source = [=](const DictionaryStructure & dict_struct,
                                  const Poco::Util::AbstractConfiguration & config,
                                  const std::string & config_prefix,
                                  Block & sample_block,
@@ -29,7 +29,7 @@ void registerDictionarySourceMongoDB(DictionarySourceFactory & factory)
                         ErrorCodes::SUPPORT_IS_DISABLED};
 #endif
     };
-    factory.registerSource("mongodb", createTableSource);
+    factory.registerSource("mongodb", create_table_source);
 }
 
 }
@@ -319,16 +319,16 @@ BlockInputStreamPtr MongoDBDictionarySource::loadKeys(const Columns & key_column
                     break;
 
                 case AttributeUnderlyingType::utString:
-                    String _str(get<String>((*key_columns[attr.first])[row_idx]));
+                    String loaded_str(get<String>((*key_columns[attr.first])[row_idx]));
                     /// Convert string to ObjectID
                     if (attr.second.is_object_id)
                     {
-                        Poco::MongoDB::ObjectId::Ptr _id(new Poco::MongoDB::ObjectId(_str));
-                        key.add(attr.second.name, _id);
+                        Poco::MongoDB::ObjectId::Ptr loaded_id(new Poco::MongoDB::ObjectId(loaded_str));
+                        key.add(attr.second.name, loaded_id);
                     }
                     else
                     {
-                        key.add(attr.second.name, _str);
+                        key.add(attr.second.name, loaded_str);
                     }
                     break;
             }
diff --git a/dbms/src/Dictionaries/MySQLDictionarySource.cpp b/dbms/src/Dictionaries/MySQLDictionarySource.cpp
index 95d41d8d35a..00527064d79 100644
--- a/dbms/src/Dictionaries/MySQLDictionarySource.cpp
+++ b/dbms/src/Dictionaries/MySQLDictionarySource.cpp
@@ -14,7 +14,7 @@ namespace ErrorCodes
 
 void registerDictionarySourceMysql(DictionarySourceFactory & factory)
 {
-    auto createTableSource = [=](const DictionaryStructure & dict_struct,
+    auto create_table_source = [=](const DictionaryStructure & dict_struct,
                                  const Poco::Util::AbstractConfiguration & config,
                                  const std::string & config_prefix,
                                  Block & sample_block,
@@ -31,7 +31,7 @@ void registerDictionarySourceMysql(DictionarySourceFactory & factory)
                         ErrorCodes::SUPPORT_IS_DISABLED};
 #endif
     };
-    factory.registerSource("mysql", createTableSource);
+    factory.registerSource("mysql", create_table_source);
 }
 
 }
@@ -67,7 +67,7 @@ MySQLDictionarySource::MySQLDictionarySource(
     , update_field{config.getString(config_prefix + ".update_field", "")}
     , dont_check_update_time{config.getBool(config_prefix + ".dont_check_update_time", false)}
     , sample_block{sample_block_}
-    , pool{mysqlxx::PoolFactory::instance().Get(config, config_prefix)}
+    , pool{mysqlxx::PoolFactory::instance().get(config, config_prefix)}
     , query_builder{dict_struct, db, table, where, IdentifierQuotingStyle::Backticks}
     , load_all_query{query_builder.composeLoadAllQuery()}
     , invalidate_query{config.getString(config_prefix + ".invalidate_query", "")}
@@ -115,7 +115,7 @@ std::string MySQLDictionarySource::getUpdateFieldAndDate()
 
 BlockInputStreamPtr MySQLDictionarySource::loadAll()
 {
-    auto connection = pool.Get();
+    auto connection = pool.get();
     last_modification = getLastModification(connection, false);
 
     LOG_TRACE(log, load_all_query);
@@ -124,7 +124,7 @@ BlockInputStreamPtr MySQLDictionarySource::loadAll()
 
 BlockInputStreamPtr MySQLDictionarySource::loadUpdatedAll()
 {
-    auto connection = pool.Get();
+    auto connection = pool.get();
     last_modification = getLastModification(connection, false);
 
     std::string load_update_query = getUpdateFieldAndDate();
@@ -137,7 +137,7 @@ BlockInputStreamPtr MySQLDictionarySource::loadIds(const std::vector<UInt64> & i
     /// We do not log in here and do not update the modification time, as the request can be large, and often called.
 
     const auto query = query_builder.composeLoadIdsQuery(ids);
-    return std::make_shared<MySQLBlockInputStream>(pool.Get(), query, sample_block, max_block_size, close_connection);
+    return std::make_shared<MySQLBlockInputStream>(pool.get(), query, sample_block, max_block_size, close_connection);
 }
 
 BlockInputStreamPtr MySQLDictionarySource::loadKeys(const Columns & key_columns, const std::vector<size_t> & requested_rows)
@@ -145,7 +145,7 @@ BlockInputStreamPtr MySQLDictionarySource::loadKeys(const Columns & key_columns,
     /// We do not log in here and do not update the modification time, as the request can be large, and often called.
 
     const auto query = query_builder.composeLoadKeysQuery(key_columns, requested_rows, ExternalQueryBuilder::AND_OR_CHAIN);
-    return std::make_shared<MySQLBlockInputStream>(pool.Get(), query, sample_block, max_block_size, close_connection);
+    return std::make_shared<MySQLBlockInputStream>(pool.get(), query, sample_block, max_block_size, close_connection);
 }
 
 bool MySQLDictionarySource::isModified() const
@@ -161,7 +161,7 @@ bool MySQLDictionarySource::isModified() const
 
     if (dont_check_update_time)
         return true;
-    auto connection = pool.Get();
+    auto connection = pool.get();
     return getLastModification(connection, true) > last_modification;
 }
 
@@ -221,7 +221,7 @@ LocalDateTime MySQLDictionarySource::getLastModification(mysqlxx::Pool::Entry &
         if (auto row = result.fetch())
         {
             ++fetched_rows;
-            const auto UPDATE_TIME_IDX = 12;
+            static const auto UPDATE_TIME_IDX = 12;
             const auto & update_time_value = row[UPDATE_TIME_IDX];
 
             if (!update_time_value.isNull())
@@ -259,7 +259,7 @@ std::string MySQLDictionarySource::doInvalidateQuery(const std::string & request
     Block invalidate_sample_block;
     ColumnPtr column(ColumnString::create());
     invalidate_sample_block.insert(ColumnWithTypeAndName(column, std::make_shared<DataTypeString>(), "Sample Block"));
-    MySQLBlockInputStream block_input_stream(pool.Get(), request, invalidate_sample_block, 1, close_connection);
+    MySQLBlockInputStream block_input_stream(pool.get(), request, invalidate_sample_block, 1, close_connection);
     return readInvalidateQuery(block_input_stream);
 }
 
diff --git a/dbms/src/Dictionaries/RedisBlockInputStream.cpp b/dbms/src/Dictionaries/RedisBlockInputStream.cpp
index 9b331269b23..7531d19ad83 100644
--- a/dbms/src/Dictionaries/RedisBlockInputStream.cpp
+++ b/dbms/src/Dictionaries/RedisBlockInputStream.cpp
@@ -124,7 +124,7 @@ namespace DB
         for (const auto i : ext::range(0, size))
             columns[i] = description.sample_block.getByPosition(i).column->cloneEmpty();
 
-        const auto insertValueByIdx = [this, &columns](size_t idx, const auto & value)
+        const auto insert_value_by_idx = [this, &columns](size_t idx, const auto & value)
         {
             if (description.types[idx].second)
             {
@@ -170,9 +170,9 @@ namespace DB
                     /// null string means 'no value for requested key'
                     if (!value.isNull())
                     {
-                        insertValueByIdx(0, primary_key);
-                        insertValueByIdx(1, secondary_key);
-                        insertValueByIdx(2, value);
+                        insert_value_by_idx(0, primary_key);
+                        insert_value_by_idx(1, secondary_key);
+                        insert_value_by_idx(2, value);
                         ++num_rows;
                     }
                 }
@@ -198,8 +198,8 @@ namespace DB
                 /// Null string means 'no value for requested key'
                 if (!value.isNull())
                 {
-                    insertValueByIdx(0, key);
-                    insertValueByIdx(1, value);
+                    insert_value_by_idx(0, key);
+                    insert_value_by_idx(1, value);
                 }
             }
             cursor += need_values;
diff --git a/dbms/src/Dictionaries/RedisDictionarySource.cpp b/dbms/src/Dictionaries/RedisDictionarySource.cpp
index 61b0227df65..51f5cdcafb5 100644
--- a/dbms/src/Dictionaries/RedisDictionarySource.cpp
+++ b/dbms/src/Dictionaries/RedisDictionarySource.cpp
@@ -12,7 +12,7 @@ namespace DB
 
     void registerDictionarySourceRedis(DictionarySourceFactory & factory)
     {
-        auto createTableSource = [=](const DictionaryStructure & dict_struct,
+        auto create_table_source = [=](const DictionaryStructure & dict_struct,
                                      const Poco::Util::AbstractConfiguration & config,
                                      const String & config_prefix,
                                      Block & sample_block,
@@ -29,7 +29,7 @@ namespace DB
                         ErrorCodes::SUPPORT_IS_DISABLED};
 #endif
         };
-        factory.registerSource("redis", createTableSource);
+        factory.registerSource("redis", create_table_source);
     }
 
 }
diff --git a/dbms/src/Dictionaries/TrieDictionary.cpp b/dbms/src/Dictionaries/TrieDictionary.cpp
index d5ab7dc31ce..83b52803325 100644
--- a/dbms/src/Dictionaries/TrieDictionary.cpp
+++ b/dbms/src/Dictionaries/TrieDictionary.cpp
@@ -688,7 +688,7 @@ static void trieTraverse(const btrie_t * trie, Getter && getter)
         node = node->left;
     }
 
-    auto getBit = [&high_bit](size_t size) { return size ? (high_bit >> (size - 1)) : 0; };
+    auto get_bit = [&high_bit](size_t size) { return size ? (high_bit >> (size - 1)) : 0; };
 
     while (!stack.empty())
     {
@@ -703,13 +703,13 @@ static void trieTraverse(const btrie_t * trie, Getter && getter)
         if (node && node->right)
         {
             stack.push(nullptr);
-            key |= getBit(stack.size());
+            key |= get_bit(stack.size());
             stack.push(node->right);
             while (stack.top()->left)
                 stack.push(stack.top()->left);
         }
         else
-            key &= ~getBit(stack.size());
+            key &= ~get_bit(stack.size());
     }
 }
 
@@ -740,13 +740,13 @@ BlockInputStreamPtr TrieDictionary::getBlockInputStream(const Names & column_nam
 {
     using BlockInputStreamType = DictionaryBlockInputStream<TrieDictionary, UInt64>;
 
-    auto getKeys = [](const Columns & columns, const std::vector<DictionaryAttribute> & dict_attributes)
+    auto get_keys = [](const Columns & columns, const std::vector<DictionaryAttribute> & dict_attributes)
     {
         const auto & attr = dict_attributes.front();
         return ColumnsWithTypeAndName(
             {ColumnWithTypeAndName(columns.front(), std::make_shared<DataTypeFixedString>(IPV6_BINARY_LENGTH), attr.name)});
     };
-    auto getView = [](const Columns & columns, const std::vector<DictionaryAttribute> & dict_attributes)
+    auto get_view = [](const Columns & columns, const std::vector<DictionaryAttribute> & dict_attributes)
     {
         auto column = ColumnString::create();
         const auto & ip_column = assert_cast<const ColumnFixedString &>(*columns.front());
@@ -765,7 +765,7 @@ BlockInputStreamPtr TrieDictionary::getBlockInputStream(const Names & column_nam
             ColumnWithTypeAndName(std::move(column), std::make_shared<DataTypeString>(), dict_attributes.front().name)};
     };
     return std::make_shared<BlockInputStreamType>(
-        shared_from_this(), max_block_size, getKeyColumns(), column_names, std::move(getKeys), std::move(getView));
+        shared_from_this(), max_block_size, getKeyColumns(), column_names, std::move(get_keys), std::move(get_view));
 }
 
 
diff --git a/dbms/src/Dictionaries/XDBCDictionarySource.cpp b/dbms/src/Dictionaries/XDBCDictionarySource.cpp
index 8121ab61e65..8647c8ccac5 100644
--- a/dbms/src/Dictionaries/XDBCDictionarySource.cpp
+++ b/dbms/src/Dictionaries/XDBCDictionarySource.cpp
@@ -236,7 +236,7 @@ void registerDictionarySourceXDBC(DictionarySourceFactory & factory)
     Poco::Data::ODBC::Connector::registerConnector();
 #endif
 
-    auto createTableSource = [=](const DictionaryStructure & dict_struct,
+    auto create_table_source = [=](const DictionaryStructure & dict_struct,
                                  const Poco::Util::AbstractConfiguration & config,
                                  const std::string & config_prefix,
                                  Block & sample_block,
@@ -256,12 +256,12 @@ void registerDictionarySourceXDBC(DictionarySourceFactory & factory)
                         ErrorCodes::SUPPORT_IS_DISABLED};
 #endif
     };
-    factory.registerSource("odbc", createTableSource);
+    factory.registerSource("odbc", create_table_source);
 }
 
 void registerDictionarySourceJDBC(DictionarySourceFactory & factory)
 {
-    auto createTableSource = [=](const DictionaryStructure & /* dict_struct */,
+    auto create_table_source = [=](const DictionaryStructure & /* dict_struct */,
                                  const Poco::Util::AbstractConfiguration & /* config */,
                                  const std::string & /* config_prefix */,
                                  Block & /* sample_block */,
@@ -272,7 +272,7 @@ void registerDictionarySourceJDBC(DictionarySourceFactory & factory)
         //        BridgeHelperPtr bridge = std::make_shared<XDBCBridgeHelper<JDBCBridgeMixin>>(config, context.getSettings().http_receive_timeout, config.getString(config_prefix + ".connection_string"));
         //        return std::make_unique<XDBCDictionarySource>(dict_struct, config, config_prefix + ".jdbc", sample_block, context, bridge);
     };
-    factory.registerSource("jdbc", createTableSource);
+    factory.registerSource("jdbc", create_table_source);
 }
 
 
diff --git a/dbms/src/Dictionaries/getDictionaryConfigurationFromAST.cpp b/dbms/src/Dictionaries/getDictionaryConfigurationFromAST.cpp
index 2a1f4933ba2..fe131b3d05a 100644
--- a/dbms/src/Dictionaries/getDictionaryConfigurationFromAST.cpp
+++ b/dbms/src/Dictionaries/getDictionaryConfigurationFromAST.cpp
@@ -115,7 +115,7 @@ void buildLayoutConfiguration(
 void buildRangeConfiguration(AutoPtr<Document> doc, AutoPtr<Element> root, const ASTDictionaryRange * range, const NamesToTypeNames & all_attrs)
 {
     // appends <key><name>value</name></key> to root
-    auto appendElem = [&doc, &root](const std::string & key, const std::string & name, const std::string & type)
+    auto append_element = [&doc, &root](const std::string & key, const std::string & name, const std::string & type)
     {
         AutoPtr<Element> element(doc->createElement(key));
         AutoPtr<Element> name_node(doc->createElement("name"));
@@ -131,8 +131,8 @@ void buildRangeConfiguration(AutoPtr<Document> doc, AutoPtr<Element> root, const
         root->appendChild(element);
     };
 
-    appendElem("range_min", range->min_attr_name, all_attrs.at(range->min_attr_name));
-    appendElem("range_max", range->max_attr_name, all_attrs.at(range->max_attr_name));
+    append_element("range_min", range->min_attr_name, all_attrs.at(range->min_attr_name));
+    append_element("range_max", range->max_attr_name, all_attrs.at(range->max_attr_name));
 }
 
 
diff --git a/dbms/src/Disks/DiskS3.cpp b/dbms/src/Disks/DiskS3.cpp
index 762056498c7..c11703ad07d 100644
--- a/dbms/src/Disks/DiskS3.cpp
+++ b/dbms/src/Disks/DiskS3.cpp
@@ -61,7 +61,7 @@ namespace
     struct Metadata
     {
         /// Metadata file version.
-        const UInt32 VERSION = 1;
+        static constexpr UInt32 VERSION = 1;
 
         using PathAndSize = std::pair<String, size_t>;
 
diff --git a/dbms/src/Disks/DiskSpaceMonitor.cpp b/dbms/src/Disks/DiskSpaceMonitor.cpp
index c602baccece..b7fe05b72ab 100644
--- a/dbms/src/Disks/DiskSpaceMonitor.cpp
+++ b/dbms/src/Disks/DiskSpaceMonitor.cpp
@@ -176,7 +176,7 @@ Volume::Volume(
                             << formatReadableSizeWithBinarySuffix(sizes[i]) << ") for containing part the size of max_data_part_size ("
                             << formatReadableSizeWithBinarySuffix(max_data_part_size) << ")");
     }
-    constexpr UInt64 MIN_PART_SIZE = 8u * 1024u * 1024u;
+    static constexpr UInt64 MIN_PART_SIZE = 8u * 1024u * 1024u;
     if (max_data_part_size != 0 && max_data_part_size < MIN_PART_SIZE)
         LOG_WARNING(
             logger,
diff --git a/dbms/src/Disks/tests/gtest_disk.cpp b/dbms/src/Disks/tests/gtest_disk.cpp
index 6f5ca506bf1..525b5e6ce38 100644
--- a/dbms/src/Disks/tests/gtest_disk.cpp
+++ b/dbms/src/Disks/tests/gtest_disk.cpp
@@ -50,14 +50,10 @@ template <typename T>
 class DiskTest : public testing::Test
 {
 public:
-    void SetUp() override { disk_ = createDisk<T>(); }
+    void SetUp() override { disk = createDisk<T>(); }
+    void TearDown() override { destroyDisk<T>(disk); }
 
-    void TearDown() override { destroyDisk<T>(disk_); }
-
-    const DB::DiskPtr & getDisk() { return disk_; }
-
-private:
-    DB::DiskPtr disk_;
+    DB::DiskPtr disk;
 };
 
 
@@ -67,49 +63,43 @@ TYPED_TEST_SUITE(DiskTest, DiskImplementations);
 
 TYPED_TEST(DiskTest, createDirectories)
 {
-    const auto & disk = this->getDisk();
+    this->disk->createDirectories("test_dir1/");
+    EXPECT_TRUE(this->disk->isDirectory("test_dir1/"));
 
-    disk->createDirectories("test_dir1/");
-    EXPECT_TRUE(disk->isDirectory("test_dir1/"));
-
-    disk->createDirectories("test_dir2/nested_dir/");
-    EXPECT_TRUE(disk->isDirectory("test_dir2/nested_dir/"));
+    this->disk->createDirectories("test_dir2/nested_dir/");
+    EXPECT_TRUE(this->disk->isDirectory("test_dir2/nested_dir/"));
 }
 
 
 TYPED_TEST(DiskTest, writeFile)
 {
-    const auto & disk = this->getDisk();
-
     {
-        std::unique_ptr<DB::WriteBuffer> out = disk->writeFile("test_file");
+        std::unique_ptr<DB::WriteBuffer> out = this->disk->writeFile("test_file");
         writeString("test data", *out);
     }
 
     DB::String data;
     {
-        std::unique_ptr<DB::ReadBuffer> in = disk->readFile("test_file");
+        std::unique_ptr<DB::ReadBuffer> in = this->disk->readFile("test_file");
         readString(data, *in);
     }
 
     EXPECT_EQ("test data", data);
-    EXPECT_EQ(data.size(), disk->getFileSize("test_file"));
+    EXPECT_EQ(data.size(), this->disk->getFileSize("test_file"));
 }
 
 
 TYPED_TEST(DiskTest, readFile)
 {
-    const auto & disk = this->getDisk();
-
     {
-        std::unique_ptr<DB::WriteBuffer> out = disk->writeFile("test_file");
+        std::unique_ptr<DB::WriteBuffer> out = this->disk->writeFile("test_file");
         writeString("test data", *out);
     }
 
     // Test SEEK_SET
     {
         String buf(4, '0');
-        std::unique_ptr<DB::SeekableReadBuffer> in = disk->readFile("test_file");
+        std::unique_ptr<DB::SeekableReadBuffer> in = this->disk->readFile("test_file");
 
         in->seek(5, SEEK_SET);
 
@@ -119,7 +109,7 @@ TYPED_TEST(DiskTest, readFile)
 
     // Test SEEK_CUR
     {
-        std::unique_ptr<DB::SeekableReadBuffer> in = disk->readFile("test_file");
+        std::unique_ptr<DB::SeekableReadBuffer> in = this->disk->readFile("test_file");
         String buf(4, '0');
 
         in->readStrict(buf.data(), 4);
@@ -136,12 +126,10 @@ TYPED_TEST(DiskTest, readFile)
 
 TYPED_TEST(DiskTest, iterateDirectory)
 {
-    const auto & disk = this->getDisk();
-
-    disk->createDirectories("test_dir/nested_dir/");
+    this->disk->createDirectories("test_dir/nested_dir/");
 
     {
-        auto iter = disk->iterateDirectory("");
+        auto iter = this->disk->iterateDirectory("");
         EXPECT_TRUE(iter->isValid());
         EXPECT_EQ("test_dir/", iter->path());
         iter->next();
@@ -149,7 +137,7 @@ TYPED_TEST(DiskTest, iterateDirectory)
     }
 
     {
-        auto iter = disk->iterateDirectory("test_dir/");
+        auto iter = this->disk->iterateDirectory("test_dir/");
         EXPECT_TRUE(iter->isValid());
         EXPECT_EQ("test_dir/nested_dir/", iter->path());
         iter->next();
diff --git a/dbms/src/Functions/CRC.cpp b/dbms/src/Functions/CRC.cpp
index e5730e6610f..96edf9a0d8e 100644
--- a/dbms/src/Functions/CRC.cpp
+++ b/dbms/src/Functions/CRC.cpp
@@ -28,7 +28,7 @@ struct CRCImpl
 {
     using ReturnType = T;
 
-    static T make_crc(const unsigned char *buf, size_t size)
+    static T makeCRC(const unsigned char *buf, size_t size)
     {
         static CRCBase<ReturnType> base(polynomial);
 
@@ -56,7 +56,7 @@ struct CRC32ZLIBImpl
     using ReturnType = UInt32;
     static constexpr auto name = "CRC32";
 
-    static UInt32 make_crc(const unsigned char *buf, size_t size)
+    static UInt32 makeCRC(const unsigned char *buf, size_t size)
     {
         return crc32_z(0L, buf, size);
     }
@@ -85,20 +85,20 @@ struct CRCFunctionWrapper
         ColumnString::Offset prev_offset = 0;
         for (size_t i = 0; i < size; ++i)
         {
-            res[i] = do_crc(data, prev_offset, offsets[i] - prev_offset - 1);
+            res[i] = doCRC(data, prev_offset, offsets[i] - prev_offset - 1);
             prev_offset = offsets[i];
         }
     }
 
-    static void vector_fixed_to_constant(const ColumnString::Chars & data, size_t n, ReturnType & res) { res = do_crc(data, 0, n); }
+    static void vectorFixedToConstant(const ColumnString::Chars & data, size_t n, ReturnType & res) { res = doCRC(data, 0, n); }
 
-    static void vector_fixed_to_vector(const ColumnString::Chars & data, size_t n, PaddedPODArray<ReturnType> & res)
+    static void vectorFixedToVector(const ColumnString::Chars & data, size_t n, PaddedPODArray<ReturnType> & res)
     {
         size_t size = data.size() / n;
 
         for (size_t i = 0; i < size; ++i)
         {
-            res[i] = do_crc(data, i * n, n);
+            res[i] = doCRC(data, i * n, n);
         }
     }
 
@@ -108,10 +108,10 @@ struct CRCFunctionWrapper
     }
 
 private:
-    static ReturnType do_crc(const ColumnString::Chars & buf, size_t offset, size_t size)
+    static ReturnType doCRC(const ColumnString::Chars & buf, size_t offset, size_t size)
     {
         const unsigned char * p = reinterpret_cast<const unsigned char *>(&buf[0]) + offset;
-        return Impl::make_crc(p, size);
+        return Impl::makeCRC(p, size);
     }
 };
 
diff --git a/dbms/src/Functions/EmptyImpl.h b/dbms/src/Functions/EmptyImpl.h
index 3b4d8f294a7..164441135bd 100644
--- a/dbms/src/Functions/EmptyImpl.h
+++ b/dbms/src/Functions/EmptyImpl.h
@@ -32,12 +32,12 @@ struct EmptyImpl
     }
 
     /// Only make sense if is_fixed_to_constant.
-    static void vector_fixed_to_constant(const ColumnString::Chars & /*data*/, size_t /*n*/, UInt8 & /*res*/)
+    static void vectorFixedToConstant(const ColumnString::Chars & /*data*/, size_t /*n*/, UInt8 & /*res*/)
     {
-        throw Exception("Logical error: 'vector_fixed_to_constant method' is called", ErrorCodes::LOGICAL_ERROR);
+        throw Exception("Logical error: 'vectorFixedToConstant method' is called", ErrorCodes::LOGICAL_ERROR);
     }
 
-    static void vector_fixed_to_vector(const ColumnString::Chars & data, size_t n, PaddedPODArray<UInt8> & res)
+    static void vectorFixedToVector(const ColumnString::Chars & data, size_t n, PaddedPODArray<UInt8> & res)
     {
         size_t size = data.size() / n;
         for (size_t i = 0; i < size; ++i)
diff --git a/dbms/src/Functions/FunctionBinaryArithmetic.h b/dbms/src/Functions/FunctionBinaryArithmetic.h
index 66eb7be01cb..2d5be04fa6e 100644
--- a/dbms/src/Functions/FunctionBinaryArithmetic.h
+++ b/dbms/src/Functions/FunctionBinaryArithmetic.h
@@ -62,25 +62,25 @@ struct BinaryOperationImplBase
     using ResultType = ResultType_;
     static const constexpr bool allow_fixed_string = false;
 
-    static void NO_INLINE vector_vector(const A * __restrict a, const B * __restrict b, ResultType * __restrict c, size_t size)
+    static void NO_INLINE vectorVector(const A * __restrict a, const B * __restrict b, ResultType * __restrict c, size_t size)
     {
         for (size_t i = 0; i < size; ++i)
             c[i] = Op::template apply<ResultType>(a[i], b[i]);
     }
 
-    static void NO_INLINE vector_constant(const A * __restrict a, B b, ResultType * __restrict c, size_t size)
+    static void NO_INLINE vectorConstant(const A * __restrict a, B b, ResultType * __restrict c, size_t size)
     {
         for (size_t i = 0; i < size; ++i)
             c[i] = Op::template apply<ResultType>(a[i], b);
     }
 
-    static void NO_INLINE constant_vector(A a, const B * __restrict b, ResultType * __restrict c, size_t size)
+    static void NO_INLINE constantVector(A a, const B * __restrict b, ResultType * __restrict c, size_t size)
     {
         for (size_t i = 0; i < size; ++i)
             c[i] = Op::template apply<ResultType>(a, b[i]);
     }
 
-    static ResultType constant_constant(A a, B b)
+    static ResultType constantConstant(A a, B b)
     {
         return Op::template apply<ResultType>(a, b);
     }
@@ -89,7 +89,7 @@ struct BinaryOperationImplBase
 template <typename Op>
 struct FixedStringOperationImpl
 {
-    static void NO_INLINE vector_vector(const UInt8 * __restrict a, const UInt8 * __restrict b, UInt8 * __restrict c, size_t size)
+    static void NO_INLINE vectorVector(const UInt8 * __restrict a, const UInt8 * __restrict b, UInt8 * __restrict c, size_t size)
     {
         for (size_t i = 0; i < size; ++i)
             c[i] = Op::template apply<UInt8>(a[i], b[i]);
@@ -146,12 +146,12 @@ struct FixedStringOperationImpl
         }
     }
 
-    static void vector_constant(const UInt8 * __restrict a, const UInt8 * __restrict b, UInt8 * __restrict c, size_t size, size_t N)
+    static void vectorConstant(const UInt8 * __restrict a, const UInt8 * __restrict b, UInt8 * __restrict c, size_t size, size_t N)
     {
         vector_constant_impl<false>(a, b, c, size, N);
     }
 
-    static void constant_vector(const UInt8 * __restrict a, const UInt8 * __restrict b, UInt8 * __restrict c, size_t size, size_t N)
+    static void constantVector(const UInt8 * __restrict a, const UInt8 * __restrict b, UInt8 * __restrict c, size_t size, size_t N)
     {
         vector_constant_impl<true>(b, a, c, size, N);
     }
@@ -206,39 +206,39 @@ struct DecimalBinaryOperation
     using ArrayC = typename ColumnDecimal<ResultType>::Container;
     using SelfNoOverflow = DecimalBinaryOperation<A, B, Operation, ResultType_, false>;
 
-    static void vector_vector(const ArrayA & a, const ArrayB & b, ArrayC & c, ResultType scale_a, ResultType scale_b, bool check_overflow)
+    static void vectorVector(const ArrayA & a, const ArrayB & b, ArrayC & c, ResultType scale_a, ResultType scale_b, bool check_overflow)
     {
         if (check_overflow)
-            vector_vector(a, b, c, scale_a, scale_b);
+            vectorVector(a, b, c, scale_a, scale_b);
         else
-            SelfNoOverflow::vector_vector(a, b, c, scale_a, scale_b);
+            SelfNoOverflow::vectorVector(a, b, c, scale_a, scale_b);
     }
 
-    static void vector_constant(const ArrayA & a, B b, ArrayC & c, ResultType scale_a, ResultType scale_b, bool check_overflow)
+    static void vectorConstant(const ArrayA & a, B b, ArrayC & c, ResultType scale_a, ResultType scale_b, bool check_overflow)
     {
         if (check_overflow)
-            vector_constant(a, b, c, scale_a, scale_b);
+            vectorConstant(a, b, c, scale_a, scale_b);
         else
-            SelfNoOverflow::vector_constant(a, b, c, scale_a, scale_b);
+            SelfNoOverflow::vectorConstant(a, b, c, scale_a, scale_b);
     }
 
-    static void constant_vector(A a, const ArrayB & b, ArrayC & c, ResultType scale_a, ResultType scale_b, bool check_overflow)
+    static void constantVector(A a, const ArrayB & b, ArrayC & c, ResultType scale_a, ResultType scale_b, bool check_overflow)
     {
         if (check_overflow)
-            constant_vector(a, b, c, scale_a, scale_b);
+            constantVector(a, b, c, scale_a, scale_b);
         else
-            SelfNoOverflow::constant_vector(a, b, c, scale_a, scale_b);
+            SelfNoOverflow::constantVector(a, b, c, scale_a, scale_b);
     }
 
-    static ResultType constant_constant(A a, B b, ResultType scale_a, ResultType scale_b, bool check_overflow)
+    static ResultType constantConstant(A a, B b, ResultType scale_a, ResultType scale_b, bool check_overflow)
     {
         if (check_overflow)
-            return constant_constant(a, b, scale_a, scale_b);
+            return constantConstant(a, b, scale_a, scale_b);
         else
-            return SelfNoOverflow::constant_constant(a, b, scale_a, scale_b);
+            return SelfNoOverflow::constantConstant(a, b, scale_a, scale_b);
     }
 
-    static void NO_INLINE vector_vector(const ArrayA & a, const ArrayB & b, ArrayC & c,
+    static void NO_INLINE vectorVector(const ArrayA & a, const ArrayB & b, ArrayC & c,
                                         ResultType scale_a [[maybe_unused]], ResultType scale_b [[maybe_unused]])
     {
         size_t size = a.size();
@@ -269,7 +269,7 @@ struct DecimalBinaryOperation
             c[i] = apply(a[i], b[i]);
     }
 
-    static void NO_INLINE vector_constant(const ArrayA & a, B b, ArrayC & c,
+    static void NO_INLINE vectorConstant(const ArrayA & a, B b, ArrayC & c,
                                         ResultType scale_a [[maybe_unused]], ResultType scale_b [[maybe_unused]])
     {
         size_t size = a.size();
@@ -300,7 +300,7 @@ struct DecimalBinaryOperation
             c[i] = apply(a[i], b);
     }
 
-    static void NO_INLINE constant_vector(A a, const ArrayB & b, ArrayC & c,
+    static void NO_INLINE constantVector(A a, const ArrayB & b, ArrayC & c,
                                         ResultType scale_a [[maybe_unused]], ResultType scale_b [[maybe_unused]])
     {
         size_t size = b.size();
@@ -331,7 +331,7 @@ struct DecimalBinaryOperation
             c[i] = apply(a, b[i]);
     }
 
-    static ResultType constant_constant(A a, B b, ResultType scale_a [[maybe_unused]], ResultType scale_b [[maybe_unused]])
+    static ResultType constantConstant(A a, B b, ResultType scale_a [[maybe_unused]], ResultType scale_b [[maybe_unused]])
     {
         if constexpr (is_plus_minus_compare)
         {
@@ -863,7 +863,7 @@ public:
                 auto col_res = ColumnFixedString::create(col_left->getN());
                 auto & out_chars = col_res->getChars();
                 out_chars.resize(col_left->getN());
-                OpImpl::vector_vector(col_left->getChars().data(),
+                OpImpl::vectorVector(col_left->getChars().data(),
                                       col_right->getChars().data(),
                                       out_chars.data(),
                                       out_chars.size());
@@ -893,7 +893,7 @@ public:
 
             if (!is_left_column_const && !is_right_column_const)
             {
-                OpImpl::vector_vector(
+                OpImpl::vectorVector(
                     col_left->getChars().data(),
                     col_right->getChars().data(),
                     out_chars.data(),
@@ -901,7 +901,7 @@ public:
             }
             else if (is_left_column_const)
             {
-                OpImpl::constant_vector(
+                OpImpl::constantVector(
                     col_left->getChars().data(),
                     col_right->getChars().data(),
                     out_chars.data(),
@@ -910,7 +910,7 @@ public:
             }
             else
             {
-                OpImpl::vector_constant(
+                OpImpl::vectorConstant(
                     col_left->getChars().data(),
                     col_right->getChars().data(),
                     out_chars.data(),
@@ -965,7 +965,7 @@ public:
                         if constexpr (IsDataTypeDecimal<RightDataType> && is_division)
                             scale_a = right.getScaleMultiplier();
 
-                        auto res = OpImpl::constant_constant(col_left->template getValue<T0>(), col_right->template getValue<T1>(),
+                        auto res = OpImpl::constantConstant(col_left->template getValue<T0>(), col_right->template getValue<T1>(),
                                                                 scale_a, scale_b, check_decimal_overflow);
                         block.getByPosition(result).column =
                             ResultDataType(type.getPrecision(), type.getScale()).createColumnConst(
@@ -974,7 +974,7 @@ public:
                     }
                     else
                     {
-                        auto res = OpImpl::constant_constant(col_left->template getValue<T0>(), col_right->template getValue<T1>());
+                        auto res = OpImpl::constantConstant(col_left->template getValue<T0>(), col_right->template getValue<T1>());
                         block.getByPosition(result).column = ResultDataType().createColumnConst(col_left->size(), toField(res));
                     }
                     return true;
@@ -1006,11 +1006,11 @@ public:
                         if constexpr (IsDataTypeDecimal<RightDataType> && is_division)
                             scale_a = right.getScaleMultiplier();
 
-                        OpImpl::constant_vector(col_left_const->template getValue<T0>(), col_right->getData(), vec_res,
+                        OpImpl::constantVector(col_left_const->template getValue<T0>(), col_right->getData(), vec_res,
                                                 scale_a, scale_b, check_decimal_overflow);
                     }
                     else
-                        OpImpl::constant_vector(col_left_const->template getValue<T0>(), col_right->getData().data(), vec_res.data(), vec_res.size());
+                        OpImpl::constantVector(col_left_const->template getValue<T0>(), col_right->getData().data(), vec_res.data(), vec_res.size());
                 }
                 else
                     return false;
@@ -1027,12 +1027,12 @@ public:
                         scale_a = right.getScaleMultiplier();
                     if (auto col_right = checkAndGetColumn<ColVecT1>(col_right_raw))
                     {
-                        OpImpl::vector_vector(col_left->getData(), col_right->getData(), vec_res, scale_a, scale_b,
+                        OpImpl::vectorVector(col_left->getData(), col_right->getData(), vec_res, scale_a, scale_b,
                                               check_decimal_overflow);
                     }
                     else if (auto col_right_const = checkAndGetColumnConst<ColVecT1>(col_right_raw))
                     {
-                        OpImpl::vector_constant(col_left->getData(), col_right_const->template getValue<T1>(), vec_res,
+                        OpImpl::vectorConstant(col_left->getData(), col_right_const->template getValue<T1>(), vec_res,
                                                 scale_a, scale_b, check_decimal_overflow);
                     }
                     else
@@ -1041,9 +1041,9 @@ public:
                 else
                 {
                     if (auto col_right = checkAndGetColumn<ColVecT1>(col_right_raw))
-                        OpImpl::vector_vector(col_left->getData().data(), col_right->getData().data(), vec_res.data(), vec_res.size());
+                        OpImpl::vectorVector(col_left->getData().data(), col_right->getData().data(), vec_res.data(), vec_res.size());
                     else if (auto col_right_const = checkAndGetColumnConst<ColVecT1>(col_right_raw))
-                        OpImpl::vector_constant(col_left->getData().data(), col_right_const->template getValue<T1>(), vec_res.data(), vec_res.size());
+                        OpImpl::vectorConstant(col_left->getData().data(), col_right_const->template getValue<T1>(), vec_res.data(), vec_res.size());
                     else
                         return false;
                 }
diff --git a/dbms/src/Functions/FunctionDateOrDateTimeAddInterval.h b/dbms/src/Functions/FunctionDateOrDateTimeAddInterval.h
index fe2a163fc8a..d63c4c2db55 100644
--- a/dbms/src/Functions/FunctionDateOrDateTimeAddInterval.h
+++ b/dbms/src/Functions/FunctionDateOrDateTimeAddInterval.h
@@ -249,7 +249,7 @@ struct Adder
     {}
 
     template <typename FromVectorType, typename ToVectorType>
-    void NO_INLINE vector_constant(const FromVectorType & vec_from, ToVectorType & vec_to, Int64 delta, const DateLUTImpl & time_zone) const
+    void NO_INLINE vectorConstant(const FromVectorType & vec_from, ToVectorType & vec_to, Int64 delta, const DateLUTImpl & time_zone) const
     {
         size_t size = vec_from.size();
         vec_to.resize(size);
@@ -259,7 +259,7 @@ struct Adder
     }
 
     template <typename FromVectorType, typename ToVectorType>
-    void vector_vector(const FromVectorType & vec_from, ToVectorType & vec_to, const IColumn & delta, const DateLUTImpl & time_zone) const
+    void vectorVector(const FromVectorType & vec_from, ToVectorType & vec_to, const IColumn & delta, const DateLUTImpl & time_zone) const
     {
         size_t size = vec_from.size();
         vec_to.resize(size);
@@ -268,11 +268,11 @@ struct Adder
             ColumnUInt8, ColumnUInt16, ColumnUInt32, ColumnUInt64,
             ColumnInt8, ColumnInt16, ColumnInt32, ColumnInt64,
             ColumnFloat32, ColumnFloat64>(
-            &delta, [&](const auto & column){ vector_vector(vec_from, vec_to, column, time_zone, size); return true; });
+            &delta, [&](const auto & column){ vectorVector(vec_from, vec_to, column, time_zone, size); return true; });
     }
 
     template <typename FromType, typename ToVectorType>
-    void constant_vector(const FromType & from, ToVectorType & vec_to, const IColumn & delta, const DateLUTImpl & time_zone) const
+    void constantVector(const FromType & from, ToVectorType & vec_to, const IColumn & delta, const DateLUTImpl & time_zone) const
     {
         size_t size = delta.size();
         vec_to.resize(size);
@@ -281,19 +281,19 @@ struct Adder
             ColumnUInt8, ColumnUInt16, ColumnUInt32, ColumnUInt64,
             ColumnInt8, ColumnInt16, ColumnInt32, ColumnInt64,
             ColumnFloat32, ColumnFloat64>(
-            &delta, [&](const auto & column){ constant_vector(from, vec_to, column, time_zone, size); return true; });
+            &delta, [&](const auto & column){ constantVector(from, vec_to, column, time_zone, size); return true; });
     }
 
 private:
     template <typename FromVectorType, typename ToVectorType, typename DeltaColumnType>
-    void NO_INLINE vector_vector(const FromVectorType & vec_from, ToVectorType & vec_to, const DeltaColumnType & delta, const DateLUTImpl & time_zone, size_t size) const
+    void NO_INLINE vectorVector(const FromVectorType & vec_from, ToVectorType & vec_to, const DeltaColumnType & delta, const DateLUTImpl & time_zone, size_t size) const
     {
         for (size_t i = 0; i < size; ++i)
             vec_to[i] = transform.execute(vec_from[i], delta.getData()[i], time_zone);
     }
 
     template <typename FromType, typename ToVectorType, typename DeltaColumnType>
-    void NO_INLINE constant_vector(const FromType & from, ToVectorType & vec_to, const DeltaColumnType & delta, const DateLUTImpl & time_zone, size_t size) const
+    void NO_INLINE constantVector(const FromType & from, ToVectorType & vec_to, const DeltaColumnType & delta, const DateLUTImpl & time_zone, size_t size) const
     {
         for (size_t i = 0; i < size; ++i)
             vec_to[i] = transform.execute(from, delta.getData()[i], time_zone);
@@ -324,13 +324,13 @@ struct DateTimeAddIntervalImpl
             const IColumn & delta_column = *block.getByPosition(arguments[1]).column;
 
             if (const auto * delta_const_column = typeid_cast<const ColumnConst *>(&delta_column))
-                op.vector_constant(sources->getData(), col_to->getData(), delta_const_column->getField().get<Int64>(), time_zone);
+                op.vectorConstant(sources->getData(), col_to->getData(), delta_const_column->getField().get<Int64>(), time_zone);
             else
-                op.vector_vector(sources->getData(), col_to->getData(), delta_column, time_zone);
+                op.vectorVector(sources->getData(), col_to->getData(), delta_column, time_zone);
         }
         else if (const auto * sources_const = checkAndGetColumnConst<FromColumnType>(source_col.get()))
         {
-            op.constant_vector(sources_const->template getValue<FromValueType>(), col_to->getData(), *block.getByPosition(arguments[1]).column, time_zone);
+            op.constantVector(sources_const->template getValue<FromValueType>(), col_to->getData(), *block.getByPosition(arguments[1]).column, time_zone);
         }
         else
         {
diff --git a/dbms/src/Functions/FunctionHelpers.cpp b/dbms/src/Functions/FunctionHelpers.cpp
index 2210be65b32..9e1bc22e6c7 100644
--- a/dbms/src/Functions/FunctionHelpers.cpp
+++ b/dbms/src/Functions/FunctionHelpers.cpp
@@ -137,13 +137,13 @@ void validateArgumentsImpl(const IFunction & func,
 
         const auto & arg = arguments[i + argument_offset];
         const auto descriptor = descriptors[i];
-        if (int errorCode = descriptor.isValid(arg.type, arg.column); errorCode != 0)
+        if (int error_code = descriptor.isValid(arg.type, arg.column); error_code != 0)
             throw Exception("Illegal type of argument #" + std::to_string(i)
                             + (descriptor.argument_name ? " '" + std::string(descriptor.argument_name) + "'" : String{})
                             + " of function " + func.getName()
                             + (descriptor.expected_type_description ? String(", expected ") + descriptor.expected_type_description : String{})
                             + (arg.type ? ", got " + arg.type->getName() : String{}),
-                            errorCode);
+                            error_code);
     }
 }
 
@@ -167,7 +167,7 @@ void validateFunctionArgumentTypes(const IFunction & func,
 {
     if (arguments.size() < mandatory_args.size() || arguments.size() > mandatory_args.size() + optional_args.size())
     {
-        auto joinArgumentTypes = [](const auto & args, const String sep = ", ")
+        auto join_argument_types = [](const auto & args, const String sep = ", ")
         {
             String result;
             for (const auto & a : args)
@@ -194,11 +194,11 @@ void validateFunctionArgumentTypes(const IFunction & func,
 
         throw Exception("Incorrect number of arguments for function " + func.getName()
                         + " provided " + std::to_string(arguments.size())
-                        + (!arguments.empty() ? " (" + joinArgumentTypes(arguments) + ")" : String{})
+                        + (!arguments.empty() ? " (" + join_argument_types(arguments) + ")" : String{})
                         + ", expected " + std::to_string(mandatory_args.size())
                         + (!optional_args.empty() ? " to " + std::to_string(mandatory_args.size() + optional_args.size()) : "")
-                        + " (" + joinArgumentTypes(mandatory_args)
-                        + (!optional_args.empty() ? ", [" + joinArgumentTypes(optional_args) + "]" : "")
+                        + " (" + join_argument_types(mandatory_args)
+                        + (!optional_args.empty() ? ", [" + join_argument_types(optional_args) + "]" : "")
                         + ")",
                         ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
     }
diff --git a/dbms/src/Functions/FunctionStringOrArrayToT.h b/dbms/src/Functions/FunctionStringOrArrayToT.h
index 3ce2cd1cf74..bdb2759e252 100644
--- a/dbms/src/Functions/FunctionStringOrArrayToT.h
+++ b/dbms/src/Functions/FunctionStringOrArrayToT.h
@@ -67,7 +67,7 @@ public:
             if (Impl::is_fixed_to_constant)
             {
                 ResultType res = 0;
-                Impl::vector_fixed_to_constant(col_fixed->getChars(), col_fixed->getN(), res);
+                Impl::vectorFixedToConstant(col_fixed->getChars(), col_fixed->getN(), res);
 
                 block.getByPosition(result).column = block.getByPosition(result).type->createColumnConst(col_fixed->size(), toField(res));
             }
@@ -77,7 +77,7 @@ public:
 
                 typename ColumnVector<ResultType>::Container & vec_res = col_res->getData();
                 vec_res.resize(col_fixed->size());
-                Impl::vector_fixed_to_vector(col_fixed->getChars(), col_fixed->getN(), vec_res);
+                Impl::vectorFixedToVector(col_fixed->getChars(), col_fixed->getN(), vec_res);
 
                 block.getByPosition(result).column = std::move(col_res);
             }
diff --git a/dbms/src/Functions/FunctionStringToString.h b/dbms/src/Functions/FunctionStringToString.h
index a5ebaa6e415..1f712a7a785 100644
--- a/dbms/src/Functions/FunctionStringToString.h
+++ b/dbms/src/Functions/FunctionStringToString.h
@@ -63,7 +63,7 @@ public:
         else if (const ColumnFixedString * col_fixed = checkAndGetColumn<ColumnFixedString>(column.get()))
         {
             auto col_res = ColumnFixedString::create(col_fixed->getN());
-            Impl::vector_fixed(col_fixed->getChars(), col_fixed->getN(), col_res->getChars());
+            Impl::vectorFixed(col_fixed->getChars(), col_fixed->getN(), col_res->getChars());
             block.getByPosition(result).column = std::move(col_res);
         }
         else
diff --git a/dbms/src/Functions/FunctionsComparison.h b/dbms/src/Functions/FunctionsComparison.h
index b8cba4e5f6e..824f64a6b45 100644
--- a/dbms/src/Functions/FunctionsComparison.h
+++ b/dbms/src/Functions/FunctionsComparison.h
@@ -78,7 +78,7 @@ template <typename A, typename B, typename Op>
 struct NumComparisonImpl
 {
     /// If you don't specify NO_INLINE, the compiler will inline this function, but we don't need this as this function contains tight loop inside.
-    static void NO_INLINE vector_vector(const PaddedPODArray<A> & a, const PaddedPODArray<B> & b, PaddedPODArray<UInt8> & c)
+    static void NO_INLINE vectorVector(const PaddedPODArray<A> & a, const PaddedPODArray<B> & b, PaddedPODArray<UInt8> & c)
     {
         /** GCC 4.8.2 vectorizes a loop only if it is written in this form.
           * In this case, if you loop through the array index (the code will look simpler),
@@ -100,7 +100,7 @@ struct NumComparisonImpl
         }
     }
 
-    static void NO_INLINE vector_constant(const PaddedPODArray<A> & a, B b, PaddedPODArray<UInt8> & c)
+    static void NO_INLINE vectorConstant(const PaddedPODArray<A> & a, B b, PaddedPODArray<UInt8> & c)
     {
         size_t size = a.size();
         const A * __restrict a_pos = a.data();
@@ -115,12 +115,12 @@ struct NumComparisonImpl
         }
     }
 
-    static void constant_vector(A a, const PaddedPODArray<B> & b, PaddedPODArray<UInt8> & c)
+    static void constantVector(A a, const PaddedPODArray<B> & b, PaddedPODArray<UInt8> & c)
     {
-        NumComparisonImpl<B, A, typename Op::SymmetricOp>::vector_constant(b, a, c);
+        NumComparisonImpl<B, A, typename Op::SymmetricOp>::vectorConstant(b, a, c);
     }
 
-    static void constant_constant(A a, B b, UInt8 & c)
+    static void constantConstant(A a, B b, UInt8 & c)
     {
         c = Op::apply(a, b);
     }
@@ -168,7 +168,7 @@ struct StringComparisonImpl
         }
     }
 
-    static void NO_INLINE string_vector_constant(
+    static void NO_INLINE string_vectorConstant(
         const ColumnString::Chars & a_data, const ColumnString::Offsets & a_offsets,
         const ColumnString::Chars & b_data, ColumnString::Offset b_size,
         PaddedPODArray<UInt8> & c)
@@ -243,7 +243,7 @@ struct StringComparisonImpl
         }
     }
 
-    static void NO_INLINE fixed_string_vector_constant(
+    static void NO_INLINE fixed_string_vectorConstant(
         const ColumnString::Chars & a_data, ColumnString::Offset a_n,
         const ColumnString::Chars & b_data, ColumnString::Offset b_size,
         PaddedPODArray<UInt8> & c)
@@ -271,7 +271,7 @@ struct StringComparisonImpl
         const ColumnString::Chars & b_data, const ColumnString::Offsets & b_offsets,
         PaddedPODArray<UInt8> & c)
     {
-        StringComparisonImpl<typename Op::SymmetricOp>::string_vector_constant(b_data, b_offsets, a_data, a_size, c);
+        StringComparisonImpl<typename Op::SymmetricOp>::string_vectorConstant(b_data, b_offsets, a_data, a_size, c);
     }
 
     static void constant_fixed_string_vector(
@@ -279,10 +279,10 @@ struct StringComparisonImpl
         const ColumnString::Chars & b_data, ColumnString::Offset b_n,
         PaddedPODArray<UInt8> & c)
     {
-        StringComparisonImpl<typename Op::SymmetricOp>::fixed_string_vector_constant(b_data, b_n, a_data, a_size, c);
+        StringComparisonImpl<typename Op::SymmetricOp>::fixed_string_vectorConstant(b_data, b_n, a_data, a_size, c);
     }
 
-    static void constant_constant(
+    static void constantConstant(
         const ColumnString::Chars & a_data, ColumnString::Offset a_size,
         const ColumnString::Chars & b_data, ColumnString::Offset b_size,
         UInt8 & c)
@@ -339,7 +339,7 @@ struct StringEqualsImpl
         }
     }
 
-    static void NO_INLINE string_vector_constant(
+    static void NO_INLINE string_vectorConstant(
         const ColumnString::Chars & a_data, const ColumnString::Offsets & a_offsets,
         const ColumnString::Chars & b_data, ColumnString::Offset b_size,
         PaddedPODArray<UInt8> & c)
@@ -405,7 +405,7 @@ struct StringEqualsImpl
         }
     }
 
-    static void NO_INLINE fixed_string_vector_constant(
+    static void NO_INLINE fixed_string_vectorConstant(
         const ColumnString::Chars & a_data, ColumnString::Offset a_n,
         const ColumnString::Chars & b_data, ColumnString::Offset b_size,
         PaddedPODArray<UInt8> & c)
@@ -435,7 +435,7 @@ struct StringEqualsImpl
         const ColumnString::Chars & b_data, const ColumnString::Offsets & b_offsets,
         PaddedPODArray<UInt8> & c)
     {
-        string_vector_constant(b_data, b_offsets, a_data, a_size, c);
+        string_vectorConstant(b_data, b_offsets, a_data, a_size, c);
     }
 
     static void constant_fixed_string_vector(
@@ -443,10 +443,10 @@ struct StringEqualsImpl
         const ColumnString::Chars & b_data, ColumnString::Offset b_n,
         PaddedPODArray<UInt8> & c)
     {
-        fixed_string_vector_constant(b_data, b_n, a_data, a_size, c);
+        fixed_string_vectorConstant(b_data, b_n, a_data, a_size, c);
     }
 
-    static void constant_constant(
+    static void constantConstant(
         const ColumnString::Chars & a_data, ColumnString::Offset a_size,
         const ColumnString::Chars & b_data, ColumnString::Offset b_size,
         UInt8 & c)
@@ -467,25 +467,25 @@ struct StringComparisonImpl<NotEqualsOp<A, B>> : StringEqualsImpl<false> {};
 template <typename Op>
 struct GenericComparisonImpl
 {
-    static void NO_INLINE vector_vector(const IColumn & a, const IColumn & b, PaddedPODArray<UInt8> & c)
+    static void NO_INLINE vectorVector(const IColumn & a, const IColumn & b, PaddedPODArray<UInt8> & c)
     {
         for (size_t i = 0, size = a.size(); i < size; ++i)
             c[i] = Op::apply(a.compareAt(i, i, b, 1), 0);
     }
 
-    static void NO_INLINE vector_constant(const IColumn & a, const IColumn & b, PaddedPODArray<UInt8> & c)
+    static void NO_INLINE vectorConstant(const IColumn & a, const IColumn & b, PaddedPODArray<UInt8> & c)
     {
         auto b_materialized = b.cloneResized(1)->convertToFullColumnIfConst();
         for (size_t i = 0, size = a.size(); i < size; ++i)
             c[i] = Op::apply(a.compareAt(i, 0, *b_materialized, 1), 0);
     }
 
-    static void constant_vector(const IColumn & a, const IColumn & b, PaddedPODArray<UInt8> & c)
+    static void constantVector(const IColumn & a, const IColumn & b, PaddedPODArray<UInt8> & c)
     {
-        GenericComparisonImpl<typename Op::SymmetricOp>::vector_constant(b, a, c);
+        GenericComparisonImpl<typename Op::SymmetricOp>::vectorConstant(b, a, c);
     }
 
-    static void constant_constant(const IColumn & a, const IColumn & b, UInt8 & c)
+    static void constantConstant(const IColumn & a, const IColumn & b, UInt8 & c)
     {
         c = Op::apply(a.compareAt(0, 0, b, 1), 0);
     }
@@ -582,7 +582,7 @@ private:
 
             ColumnUInt8::Container & vec_res = col_res->getData();
             vec_res.resize(col_left->getData().size());
-            NumComparisonImpl<T0, T1, Op<T0, T1>>::vector_vector(col_left->getData(), col_right->getData(), vec_res);
+            NumComparisonImpl<T0, T1, Op<T0, T1>>::vectorVector(col_left->getData(), col_right->getData(), vec_res);
 
             block.getByPosition(result).column = std::move(col_res);
             return true;
@@ -593,7 +593,7 @@ private:
 
             ColumnUInt8::Container & vec_res = col_res->getData();
             vec_res.resize(col_left->size());
-            NumComparisonImpl<T0, T1, Op<T0, T1>>::vector_constant(col_left->getData(), col_right_const->template getValue<T1>(), vec_res);
+            NumComparisonImpl<T0, T1, Op<T0, T1>>::vectorConstant(col_left->getData(), col_right_const->template getValue<T1>(), vec_res);
 
             block.getByPosition(result).column = std::move(col_res);
             return true;
@@ -611,7 +611,7 @@ private:
 
             ColumnUInt8::Container & vec_res = col_res->getData();
             vec_res.resize(col_left->size());
-            NumComparisonImpl<T0, T1, Op<T0, T1>>::constant_vector(col_left->template getValue<T0>(), col_right->getData(), vec_res);
+            NumComparisonImpl<T0, T1, Op<T0, T1>>::constantVector(col_left->template getValue<T0>(), col_right->getData(), vec_res);
 
             block.getByPosition(result).column = std::move(col_res);
             return true;
@@ -619,7 +619,7 @@ private:
         else if (auto col_right_const = checkAndGetColumnConst<ColumnVector<T1>>(col_right_untyped))
         {
             UInt8 res = 0;
-            NumComparisonImpl<T0, T1, Op<T0, T1>>::constant_constant(col_left->template getValue<T0>(), col_right_const->template getValue<T1>(), res);
+            NumComparisonImpl<T0, T1, Op<T0, T1>>::constantConstant(col_left->template getValue<T0>(), col_right_const->template getValue<T1>(), res);
 
             block.getByPosition(result).column = DataTypeUInt8().createColumnConst(col_left->size(), toField(res));
             return true;
@@ -759,7 +759,7 @@ private:
         if (c0_const && c1_const)
         {
             UInt8 res = 0;
-            StringImpl::constant_constant(*c0_const_chars, c0_const_size, *c1_const_chars, c1_const_size, res);
+            StringImpl::constantConstant(*c0_const_chars, c0_const_size, *c1_const_chars, c1_const_size, res);
             block.getByPosition(result).column = block.getByPosition(result).type->createColumnConst(c0_const->size(), toField(res));
             return true;
         }
@@ -780,7 +780,7 @@ private:
                     c1_fixed_string->getChars(), c1_fixed_string->getN(),
                     c_res->getData());
             else if (c0_string && c1_const)
-                StringImpl::string_vector_constant(
+                StringImpl::string_vectorConstant(
                     c0_string->getChars(), c0_string->getOffsets(),
                     *c1_const_chars, c1_const_size,
                     c_res->getData());
@@ -795,7 +795,7 @@ private:
                     c1_fixed_string->getChars(), c1_fixed_string->getN(),
                     c_res->getData());
             else if (c0_fixed_string && c1_const)
-                StringImpl::fixed_string_vector_constant(
+                StringImpl::fixed_string_vectorConstant(
                     c0_fixed_string->getChars(), c0_fixed_string->getN(),
                     *c1_const_chars, c1_const_size,
                     c_res->getData());
@@ -1081,7 +1081,7 @@ private:
         if (c0_const && c1_const)
         {
             UInt8 res = 0;
-            GenericComparisonImpl<Op<int, int>>::constant_constant(*c0, *c1, res);
+            GenericComparisonImpl<Op<int, int>>::constantConstant(*c0, *c1, res);
             block.getByPosition(result).column = DataTypeUInt8().createColumnConst(c0->size(), toField(res));
         }
         else
@@ -1091,11 +1091,11 @@ private:
             vec_res.resize(c0->size());
 
             if (c0_const)
-                GenericComparisonImpl<Op<int, int>>::constant_vector(*c0, *c1, vec_res);
+                GenericComparisonImpl<Op<int, int>>::constantVector(*c0, *c1, vec_res);
             else if (c1_const)
-                GenericComparisonImpl<Op<int, int>>::vector_constant(*c0, *c1, vec_res);
+                GenericComparisonImpl<Op<int, int>>::vectorConstant(*c0, *c1, vec_res);
             else
-                GenericComparisonImpl<Op<int, int>>::vector_vector(*c0, *c1, vec_res);
+                GenericComparisonImpl<Op<int, int>>::vectorVector(*c0, *c1, vec_res);
 
             block.getByPosition(result).column = std::move(c_res);
         }
diff --git a/dbms/src/Functions/FunctionsLogical.cpp b/dbms/src/Functions/FunctionsLogical.cpp
index b5fe1ff59e1..c2a277a478d 100644
--- a/dbms/src/Functions/FunctionsLogical.cpp
+++ b/dbms/src/Functions/FunctionsLogical.cpp
@@ -301,13 +301,13 @@ struct OperationApplier
             return;
         }
 
-        const OperationApplierImpl<Op, N> operationApplierImpl(in);
+        const OperationApplierImpl<Op, N> operation_applier_impl(in);
         size_t i = 0;
         for (auto & res : result_data)
             if constexpr (CarryResult)
-                res = Op::apply(res, operationApplierImpl.apply(i++));
+                res = Op::apply(res, operation_applier_impl.apply(i++));
             else
-                res = operationApplierImpl.apply(i++);
+                res = operation_applier_impl.apply(i++);
 
         in.erase(in.end() - N, in.end());
     }
diff --git a/dbms/src/Functions/FunctionsStringRegex.cpp b/dbms/src/Functions/FunctionsStringRegex.cpp
index 4f89c3ae305..30bb3b26d7c 100644
--- a/dbms/src/Functions/FunctionsStringRegex.cpp
+++ b/dbms/src/Functions/FunctionsStringRegex.cpp
@@ -96,7 +96,7 @@ struct MatchImpl
 
     using ResultType = UInt8;
 
-    static void vector_constant(
+    static void vectorConstant(
         const ColumnString::Chars & data, const ColumnString::Offsets & offsets, const std::string & pattern, PaddedPODArray<UInt8> & res)
     {
         if (offsets.empty())
@@ -246,14 +246,14 @@ struct MatchImpl
     }
 
     template <typename... Args>
-    static void vector_vector(Args &&...)
+    static void vectorVector(Args &&...)
     {
         throw Exception("Functions 'like' and 'match' don't support non-constant needle argument", ErrorCodes::ILLEGAL_COLUMN);
     }
 
     /// Search different needles in single haystack.
     template <typename... Args>
-    static void constant_vector(Args &&...)
+    static void constantVector(Args &&...)
     {
         throw Exception("Functions 'like' and 'match' don't support non-constant needle argument", ErrorCodes::ILLEGAL_COLUMN);
     }
@@ -269,22 +269,22 @@ struct MultiMatchAnyImpl
     /// Variable for understanding, if we used offsets for the output, most
     /// likely to determine whether the function returns ColumnVector of ColumnArray.
     static constexpr bool is_column_array = false;
-    static auto ReturnType()
+    static auto getReturnType()
     {
         return std::make_shared<DataTypeNumber<ResultType>>();
     }
 
-    static void vector_constant(
+    static void vectorConstant(
         const ColumnString::Chars & haystack_data,
         const ColumnString::Offsets & haystack_offsets,
         const std::vector<StringRef> & needles,
         PaddedPODArray<Type> & res,
         PaddedPODArray<UInt64> & offsets)
     {
-        vector_constant(haystack_data, haystack_offsets, needles, res, offsets, std::nullopt);
+        vectorConstant(haystack_data, haystack_offsets, needles, res, offsets, std::nullopt);
     }
 
-    static void vector_constant(
+    static void vectorConstant(
         const ColumnString::Chars & haystack_data,
         const ColumnString::Offsets & haystack_offsets,
         const std::vector<StringRef> & needles,
@@ -351,7 +351,7 @@ struct MultiMatchAnyImpl
         memset(accum.data(), 0, accum.size());
         for (size_t j = 0; j < needles.size(); ++j)
         {
-            MatchImpl<false, false>::vector_constant(haystack_data, haystack_offsets, needles[j].toString(), accum);
+            MatchImpl<false, false>::vectorConstant(haystack_data, haystack_offsets, needles[j].toString(), accum);
             for (size_t i = 0; i < res.size(); ++i)
             {
                 if constexpr (FindAny)
@@ -372,22 +372,22 @@ struct MultiMatchAllIndicesImpl
     /// Variable for understanding, if we used offsets for the output, most
     /// likely to determine whether the function returns ColumnVector of ColumnArray.
     static constexpr bool is_column_array = true;
-    static auto ReturnType()
+    static auto getReturnType()
     {
         return std::make_shared<DataTypeArray>(std::make_shared<DataTypeUInt64>());
     }
 
-    static void vector_constant(
+    static void vectorConstant(
         const ColumnString::Chars & haystack_data,
         const ColumnString::Offsets & haystack_offsets,
         const std::vector<StringRef> & needles,
         PaddedPODArray<Type> & res,
         PaddedPODArray<UInt64> & offsets)
     {
-        vector_constant(haystack_data, haystack_offsets, needles, res, offsets, std::nullopt);
+        vectorConstant(haystack_data, haystack_offsets, needles, res, offsets, std::nullopt);
     }
 
-    static void vector_constant(
+    static void vectorConstant(
         const ColumnString::Chars & haystack_data,
         const ColumnString::Offsets & haystack_offsets,
         const std::vector<StringRef> & needles,
@@ -652,7 +652,7 @@ struct ReplaceRegexpImpl
         }
     }
 
-    static void vector_fixed(
+    static void vectorFixed(
         const ColumnString::Chars & data,
         size_t n,
         const std::string & needle,
@@ -763,7 +763,7 @@ struct ReplaceStringImpl
 
     /// Note: this function converts fixed-length strings to variable-length strings
     ///       and each variable-length string should ends with zero byte.
-    static void vector_fixed(
+    static void vectorFixed(
         const ColumnString::Chars & data,
         size_t n,
         const std::string & needle,
@@ -910,7 +910,7 @@ public:
         else if (const ColumnFixedString * col_fixed = checkAndGetColumn<ColumnFixedString>(column_src.get()))
         {
             auto col_res = ColumnString::create();
-            Impl::vector_fixed(col_fixed->getChars(), col_fixed->getN(), needle, replacement, col_res->getChars(), col_res->getOffsets());
+            Impl::vectorFixed(col_fixed->getChars(), col_fixed->getN(), needle, replacement, col_res->getChars(), col_res->getOffsets());
             block.getByPosition(result).column = std::move(col_res);
         }
         else
diff --git a/dbms/src/Functions/FunctionsStringRegex.h b/dbms/src/Functions/FunctionsStringRegex.h
index 9db745e0885..e8cc72d26e5 100644
--- a/dbms/src/Functions/FunctionsStringRegex.h
+++ b/dbms/src/Functions/FunctionsStringRegex.h
@@ -63,7 +63,7 @@ public:
         if (!array_type || !checkAndGetDataType<DataTypeString>(array_type->getNestedType().get()))
             throw Exception(
                 "Illegal type " + arguments[2]->getName() + " of argument of function " + getName(), ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
-        return Impl::ReturnType();
+        return Impl::getReturnType();
     }
 
     void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result, size_t /*input_rows_count*/) override
@@ -121,7 +121,7 @@ public:
 
         /// The blame for resizing output is for the callee.
         if (col_haystack_vector)
-            Impl::vector_constant(
+            Impl::vectorConstant(
                 col_haystack_vector->getChars(), col_haystack_vector->getOffsets(), refs, vec_res, offsets_res, edit_distance);
         else
             throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName(), ErrorCodes::ILLEGAL_COLUMN);
diff --git a/dbms/src/Functions/FunctionsStringSearch.cpp b/dbms/src/Functions/FunctionsStringSearch.cpp
index d8911f7bca2..a3ae362d20c 100644
--- a/dbms/src/Functions/FunctionsStringSearch.cpp
+++ b/dbms/src/Functions/FunctionsStringSearch.cpp
@@ -155,7 +155,7 @@ struct PositionImpl
     using ResultType = UInt64;
 
     /// Find one substring in many strings.
-    static void vector_constant(
+    static void vectorConstant(
         const ColumnString::Chars & data, const ColumnString::Offsets & offsets, const std::string & needle, PaddedPODArray<UInt64> & res)
     {
         const UInt8 * begin = data.data();
@@ -192,7 +192,7 @@ struct PositionImpl
     }
 
     /// Search for substring in string.
-    static void constant_constant(std::string data, std::string needle, UInt64 & res)
+    static void constantConstant(std::string data, std::string needle, UInt64 & res)
     {
         Impl::toLowerIfNeed(data);
         Impl::toLowerIfNeed(needle);
@@ -205,7 +205,7 @@ struct PositionImpl
     }
 
     /// Search each time for a different single substring inside each time different string.
-    static void vector_vector(
+    static void vectorVector(
         const ColumnString::Chars & haystack_data,
         const ColumnString::Offsets & haystack_offsets,
         const ColumnString::Chars & needle_data,
@@ -255,7 +255,7 @@ struct PositionImpl
     }
 
     /// Find many substrings in single string.
-    static void constant_vector(
+    static void constantVector(
         const String & haystack,
         const ColumnString::Chars & needle_data,
         const ColumnString::Offsets & needle_offsets,
@@ -303,7 +303,7 @@ struct MultiSearchAllPositionsImpl
 {
     using ResultType = UInt64;
 
-    static void vector_constant(
+    static void vectorConstant(
         const ColumnString::Chars & haystack_data,
         const ColumnString::Offsets & haystack_offsets,
         const std::vector<StringRef> & needles,
@@ -344,9 +344,9 @@ struct MultiSearchImpl
     /// Variable for understanding, if we used offsets for the output, most
     /// likely to determine whether the function returns ColumnVector of ColumnArray.
     static constexpr bool is_column_array = false;
-    static auto ReturnType() { return std::make_shared<DataTypeNumber<ResultType>>(); }
+    static auto getReturnType() { return std::make_shared<DataTypeNumber<ResultType>>(); }
 
-    static void vector_constant(
+    static void vectorConstant(
         const ColumnString::Chars & haystack_data,
         const ColumnString::Offsets & haystack_offsets,
         const std::vector<StringRef> & needles,
@@ -381,9 +381,9 @@ struct MultiSearchFirstPositionImpl
     /// Variable for understanding, if we used offsets for the output, most
     /// likely to determine whether the function returns ColumnVector of ColumnArray.
     static constexpr bool is_column_array = false;
-    static auto ReturnType() { return std::make_shared<DataTypeNumber<ResultType>>(); }
+    static auto getReturnType() { return std::make_shared<DataTypeNumber<ResultType>>(); }
 
-    static void vector_constant(
+    static void vectorConstant(
         const ColumnString::Chars & haystack_data,
         const ColumnString::Offsets & haystack_offsets,
         const std::vector<StringRef> & needles,
@@ -428,9 +428,9 @@ struct MultiSearchFirstIndexImpl
     /// Variable for understanding, if we used offsets for the output, most
     /// likely to determine whether the function returns ColumnVector of ColumnArray.
     static constexpr bool is_column_array = false;
-    static auto ReturnType() { return std::make_shared<DataTypeNumber<ResultType>>(); }
+    static auto getReturnType() { return std::make_shared<DataTypeNumber<ResultType>>(); }
 
-    static void vector_constant(
+    static void vectorConstant(
         const ColumnString::Chars & haystack_data,
         const ColumnString::Offsets & haystack_offsets,
         const std::vector<StringRef> & needles,
@@ -467,7 +467,7 @@ struct HasTokenImpl
 
     static constexpr bool use_default_implementation_for_constants = true;
 
-    static void vector_constant(
+    static void vectorConstant(
         const ColumnString::Chars & data, const ColumnString::Offsets & offsets, const std::string & pattern, PaddedPODArray<UInt8> & res)
     {
         if (offsets.empty())
@@ -508,14 +508,14 @@ struct HasTokenImpl
     }
 
     template <typename... Args>
-    static void vector_vector(Args &&...)
+    static void vectorVector(Args &&...)
     {
         throw Exception("Function 'hasToken' does not support non-constant needle argument", ErrorCodes::ILLEGAL_COLUMN);
     }
 
     /// Search different needles in single haystack.
     template <typename... Args>
-    static void constant_vector(Args &&...)
+    static void constantVector(Args &&...)
     {
         throw Exception("Function 'hasToken' does not support non-constant needle argument", ErrorCodes::ILLEGAL_COLUMN);
     }
diff --git a/dbms/src/Functions/FunctionsStringSearch.h b/dbms/src/Functions/FunctionsStringSearch.h
index 8cbf92902ab..e3df872a493 100644
--- a/dbms/src/Functions/FunctionsStringSearch.h
+++ b/dbms/src/Functions/FunctionsStringSearch.h
@@ -119,7 +119,7 @@ public:
             if (col_haystack_const && col_needle_const)
             {
                 ResultType res{};
-                Impl::constant_constant(col_haystack_const->getValue<String>(), col_needle_const->getValue<String>(), res);
+                Impl::constantConstant(col_haystack_const->getValue<String>(), col_needle_const->getValue<String>(), res);
                 block.getByPosition(result).column
                     = block.getByPosition(result).type->createColumnConst(col_haystack_const->size(), toField(res));
                 return;
@@ -135,17 +135,17 @@ public:
         const ColumnString * col_needle_vector = checkAndGetColumn<ColumnString>(&*column_needle);
 
         if (col_haystack_vector && col_needle_vector)
-            Impl::vector_vector(
+            Impl::vectorVector(
                 col_haystack_vector->getChars(),
                 col_haystack_vector->getOffsets(),
                 col_needle_vector->getChars(),
                 col_needle_vector->getOffsets(),
                 vec_res);
         else if (col_haystack_vector && col_needle_const)
-            Impl::vector_constant(
+            Impl::vectorConstant(
                 col_haystack_vector->getChars(), col_haystack_vector->getOffsets(), col_needle_const->getValue<String>(), vec_res);
         else if (col_haystack_const && col_needle_vector)
-            Impl::constant_vector(
+            Impl::constantVector(
                 col_haystack_const->getValue<String>(), col_needle_vector->getChars(), col_needle_vector->getOffsets(), vec_res);
         else
             throw Exception(
@@ -277,7 +277,7 @@ public:
         vec_res.resize(column_haystack_size * refs.size());
 
         if (col_haystack_vector)
-            Impl::vector_constant(col_haystack_vector->getChars(), col_haystack_vector->getOffsets(), refs, vec_res);
+            Impl::vectorConstant(col_haystack_vector->getChars(), col_haystack_vector->getOffsets(), refs, vec_res);
         else
             throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName(), ErrorCodes::ILLEGAL_COLUMN);
 
@@ -325,7 +325,7 @@ public:
         if (!array_type || !checkAndGetDataType<DataTypeString>(array_type->getNestedType().get()))
             throw Exception(
                 "Illegal type " + arguments[1]->getName() + " of argument of function " + getName(), ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
-        return Impl::ReturnType();
+        return Impl::getReturnType();
     }
 
     void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result, size_t /*input_rows_count*/) override
@@ -366,7 +366,7 @@ public:
 
         /// The blame for resizing output is for the callee.
         if (col_haystack_vector)
-            Impl::vector_constant(col_haystack_vector->getChars(), col_haystack_vector->getOffsets(), refs, vec_res, offsets_res);
+            Impl::vectorConstant(col_haystack_vector->getChars(), col_haystack_vector->getOffsets(), refs, vec_res, offsets_res);
         else
             throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName(), ErrorCodes::ILLEGAL_COLUMN);
 
diff --git a/dbms/src/Functions/FunctionsStringSimilarity.cpp b/dbms/src/Functions/FunctionsStringSimilarity.cpp
index 17f7b004fef..cf9d4d6e42a 100644
--- a/dbms/src/Functions/FunctionsStringSimilarity.cpp
+++ b/dbms/src/Functions/FunctionsStringSimilarity.cpp
@@ -54,12 +54,12 @@ struct NgramDistanceImpl
       */
     using NgramStats = UInt16[map_size];
 
-    static ALWAYS_INLINE UInt16 ASCIIHash(const CodePoint * code_points)
+    static ALWAYS_INLINE UInt16 calculateASCIIHash(const CodePoint * code_points)
     {
         return intHashCRC32(unalignedLoad<UInt32>(code_points)) & 0xFFFFu;
     }
 
-    static ALWAYS_INLINE UInt16 UTF8Hash(const CodePoint * code_points)
+    static ALWAYS_INLINE UInt16 calculateUTF8Hash(const CodePoint * code_points)
     {
         UInt64 combined = (static_cast<UInt64>(code_points[0]) << 32) | code_points[1];
 #ifdef __SSE4_2__
@@ -249,12 +249,12 @@ struct NgramDistanceImpl
     static inline auto dispatchSearcher(Callback callback, Args &&... args)
     {
         if constexpr (!UTF8)
-            return callback(std::forward<Args>(args)..., readASCIICodePoints, ASCIIHash);
+            return callback(std::forward<Args>(args)..., readASCIICodePoints, calculateASCIIHash);
         else
-            return callback(std::forward<Args>(args)..., readUTF8CodePoints, UTF8Hash);
+            return callback(std::forward<Args>(args)..., readUTF8CodePoints, calculateUTF8Hash);
     }
 
-    static void constant_constant(std::string data, std::string needle, Float32 & res)
+    static void constantConstant(std::string data, std::string needle, Float32 & res)
     {
         NgramStats common_stats = {};
 
@@ -284,7 +284,7 @@ struct NgramDistanceImpl
         }
     }
 
-    static void vector_vector(
+    static void vectorVector(
         const ColumnString::Chars & haystack_data,
         const ColumnString::Offsets & haystack_offsets,
         const ColumnString::Chars & needle_data,
@@ -358,7 +358,7 @@ struct NgramDistanceImpl
         }
     }
 
-    static void constant_vector(
+    static void constantVector(
         std::string haystack,
         const ColumnString::Chars & needle_data,
         const ColumnString::Offsets & needle_offsets,
@@ -367,7 +367,7 @@ struct NgramDistanceImpl
         /// For symmetric version it is better to use vector_constant
         if constexpr (symmetric)
         {
-            vector_constant(needle_data, needle_offsets, std::move(haystack), res);
+            vectorConstant(needle_data, needle_offsets, std::move(haystack), res);
         }
         else
         {
@@ -423,7 +423,7 @@ struct NgramDistanceImpl
         }
     }
 
-    static void vector_constant(
+    static void vectorConstant(
         const ColumnString::Chars & data,
         const ColumnString::Offsets & offsets,
         std::string needle,
diff --git a/dbms/src/Functions/FunctionsStringSimilarity.h b/dbms/src/Functions/FunctionsStringSimilarity.h
index 1be2e0e61c4..ab32f214520 100644
--- a/dbms/src/Functions/FunctionsStringSimilarity.h
+++ b/dbms/src/Functions/FunctionsStringSimilarity.h
@@ -72,7 +72,7 @@ public:
                         + std::to_string(Impl::max_string_size),
                     ErrorCodes::TOO_LARGE_STRING_SIZE);
             }
-            Impl::constant_constant(col_haystack_const->getValue<String>(), needle, res);
+            Impl::constantConstant(col_haystack_const->getValue<String>(), needle, res);
             block.getByPosition(result).column
                 = block.getByPosition(result).type->createColumnConst(col_haystack_const->size(), toField(res));
             return;
@@ -96,11 +96,11 @@ public:
                         + std::to_string(Impl::max_string_size),
                     ErrorCodes::TOO_LARGE_STRING_SIZE);
             }
-            Impl::vector_constant(col_haystack_vector->getChars(), col_haystack_vector->getOffsets(), needle, vec_res);
+            Impl::vectorConstant(col_haystack_vector->getChars(), col_haystack_vector->getOffsets(), needle, vec_res);
         }
         else if (col_haystack_vector && col_needle_vector)
         {
-            Impl::vector_vector(
+            Impl::vectorVector(
                 col_haystack_vector->getChars(),
                 col_haystack_vector->getOffsets(),
                 col_needle_vector->getChars(),
@@ -117,7 +117,7 @@ public:
                         + std::to_string(Impl::max_string_size),
                     ErrorCodes::TOO_LARGE_STRING_SIZE);
             }
-            Impl::constant_vector(haystack, col_needle_vector->getChars(), col_needle_vector->getOffsets(), vec_res);
+            Impl::constantVector(haystack, col_needle_vector->getChars(), col_needle_vector->getOffsets(), vec_res);
         }
         else
         {
diff --git a/dbms/src/Functions/FunctionsVisitParam.h b/dbms/src/Functions/FunctionsVisitParam.h
index 03dee724fd7..b560dd31555 100644
--- a/dbms/src/Functions/FunctionsVisitParam.h
+++ b/dbms/src/Functions/FunctionsVisitParam.h
@@ -81,7 +81,7 @@ struct ExtractParamImpl
     static constexpr bool use_default_implementation_for_constants = true;
 
     /// It is assumed that `res` is the correct size and initialized with zeros.
-    static void vector_constant(const ColumnString::Chars & data, const ColumnString::Offsets & offsets,
+    static void vectorConstant(const ColumnString::Chars & data, const ColumnString::Offsets & offsets,
         std::string needle,
         PaddedPODArray<ResultType> & res)
     {
@@ -121,12 +121,12 @@ struct ExtractParamImpl
             memset(&res[i], 0, (res.size() - i) * sizeof(res[0]));
     }
 
-    template <typename... Args> static void vector_vector(Args &&...)
+    template <typename... Args> static void vectorVector(Args &&...)
     {
         throw Exception("Functions 'visitParamHas' and 'visitParamExtract*' doesn't support non-constant needle argument", ErrorCodes::ILLEGAL_COLUMN);
     }
 
-    template <typename... Args> static void constant_vector(Args &&...)
+    template <typename... Args> static void constantVector(Args &&...)
     {
         throw Exception("Functions 'visitParamHas' and 'visitParamExtract*' doesn't support non-constant needle argument", ErrorCodes::ILLEGAL_COLUMN);
     }
diff --git a/dbms/src/Functions/LowerUpperImpl.h b/dbms/src/Functions/LowerUpperImpl.h
index a3900694251..8562087db80 100644
--- a/dbms/src/Functions/LowerUpperImpl.h
+++ b/dbms/src/Functions/LowerUpperImpl.h
@@ -17,7 +17,7 @@ struct LowerUpperImpl
         array(data.data(), data.data() + data.size(), res_data.data());
     }
 
-    static void vector_fixed(const ColumnString::Chars & data, size_t /*n*/, ColumnString::Chars & res_data)
+    static void vectorFixed(const ColumnString::Chars & data, size_t /*n*/, ColumnString::Chars & res_data)
     {
         res_data.resize(data.size());
         array(data.data(), data.data() + data.size(), res_data.data());
diff --git a/dbms/src/Functions/LowerUpperUTF8Impl.h b/dbms/src/Functions/LowerUpperUTF8Impl.h
index 416667933d1..c738c8e8255 100644
--- a/dbms/src/Functions/LowerUpperUTF8Impl.h
+++ b/dbms/src/Functions/LowerUpperUTF8Impl.h
@@ -96,7 +96,7 @@ struct LowerUpperUTF8Impl
         array(data.data(), data.data() + data.size(), res_data.data());
     }
 
-    static void vector_fixed(const ColumnString::Chars &, size_t, ColumnString::Chars &)
+    static void vectorFixed(const ColumnString::Chars &, size_t, ColumnString::Chars &)
     {
         throw Exception("Functions lowerUTF8 and upperUTF8 cannot work with FixedString argument", ErrorCodes::BAD_ARGUMENTS);
     }
diff --git a/dbms/src/Functions/URL/FunctionsURL.h b/dbms/src/Functions/URL/FunctionsURL.h
index 2d77026f4c4..fa5e9246488 100644
--- a/dbms/src/Functions/URL/FunctionsURL.h
+++ b/dbms/src/Functions/URL/FunctionsURL.h
@@ -98,7 +98,7 @@ struct ExtractSubstringImpl
         res_data.assign(start, length);
     }
 
-    static void vector_fixed(const ColumnString::Chars &, size_t, ColumnString::Chars &)
+    static void vectorFixed(const ColumnString::Chars &, size_t, ColumnString::Chars &)
     {
         throw Exception("Column of type FixedString is not supported by URL functions", ErrorCodes::ILLEGAL_COLUMN);
     }
@@ -153,7 +153,7 @@ struct CutSubstringImpl
         res_data.append(start + length, data.data() + data.size());
     }
 
-    static void vector_fixed(const ColumnString::Chars &, size_t, ColumnString::Chars &)
+    static void vectorFixed(const ColumnString::Chars &, size_t, ColumnString::Chars &)
     {
         throw Exception("Column of type FixedString is not supported by URL functions", ErrorCodes::ILLEGAL_COLUMN);
     }
diff --git a/dbms/src/Functions/URL/decodeURLComponent.cpp b/dbms/src/Functions/URL/decodeURLComponent.cpp
index 8f83ec86438..96cdcb64537 100644
--- a/dbms/src/Functions/URL/decodeURLComponent.cpp
+++ b/dbms/src/Functions/URL/decodeURLComponent.cpp
@@ -93,7 +93,7 @@ struct DecodeURLComponentImpl
         res_data.resize(res_offset);
     }
 
-    [[noreturn]] static void vector_fixed(const ColumnString::Chars &, size_t, ColumnString::Chars &)
+    [[noreturn]] static void vectorFixed(const ColumnString::Chars &, size_t, ColumnString::Chars &)
     {
         throw Exception("Column of type FixedString is not supported by URL functions", ErrorCodes::ILLEGAL_COLUMN);
     }
diff --git a/dbms/src/Functions/URL/firstSignificantSubdomain.h b/dbms/src/Functions/URL/firstSignificantSubdomain.h
index a7fed7975bc..e3869417dd5 100644
--- a/dbms/src/Functions/URL/firstSignificantSubdomain.h
+++ b/dbms/src/Functions/URL/firstSignificantSubdomain.h
@@ -64,7 +64,7 @@ struct ExtractFirstSignificantSubdomain
             end_of_level_domain = end;
         }
 
-        if (tldLookup::is_valid(last_3_periods[1] + 1, end_of_level_domain - last_3_periods[1] - 1) != nullptr)
+        if (tldLookup::isValid(last_3_periods[1] + 1, end_of_level_domain - last_3_periods[1] - 1) != nullptr)
         {
             res_data += last_3_periods[2] + 1 - begin;
             res_size = last_3_periods[1] - last_3_periods[2] - 1;
diff --git a/dbms/src/Functions/URL/tldLookup.generated.cpp b/dbms/src/Functions/URL/tldLookup.generated.cpp
index 14eabbc935f..dea5cd1da9b 100644
--- a/dbms/src/Functions/URL/tldLookup.generated.cpp
+++ b/dbms/src/Functions/URL/tldLookup.generated.cpp
@@ -33,16 +33,16 @@
 #define MAX_HASH_VALUE 95690
 /* maximum key range = 95616, duplicates = 0 */
 
-class tldLookupHash
+class TopLevelDomainLookupHash
 {
 private:
     static inline unsigned int hash(const char * str, size_t len);
 
 public:
-    static const char * is_valid(const char * str, size_t len);
+    static const char * isValid(const char * str, size_t len);
 };
 
-inline unsigned int tldLookupHash::hash(const char * str, size_t len)
+inline unsigned int TopLevelDomainLookupHash::hash(const char * str, size_t len)
 {
     static const unsigned int asso_values[] = {
         95691, 95691, 95691, 95691, 95691, 95691, 95691, 95691, 95691, 95691, 95691, 95691, 95691, 95691, 95691, 95691, 95691, 95691, 95691,
@@ -105,7 +105,7 @@ inline unsigned int tldLookupHash::hash(const char * str, size_t len)
     return hval + asso_values[static_cast<unsigned char>(str[len - 1])];
 }
 
-const char * tldLookupHash::is_valid(const char * str, size_t len)
+const char * TopLevelDomainLookupHash::isValid(const char * str, size_t len)
 {
     static const char * const wordlist[]
         = {"",
diff --git a/dbms/src/Functions/URL/tldLookup.h b/dbms/src/Functions/URL/tldLookup.h
index 2b25ae4cdb3..25857be3dd2 100644
--- a/dbms/src/Functions/URL/tldLookup.h
+++ b/dbms/src/Functions/URL/tldLookup.h
@@ -1,15 +1,15 @@
 #pragma once
 
 // Definition of the class generated by gperf, present on gperf/tldLookup.gperf
-class tldLookupHash
+class TopLevelDomainLookupHash
 {
 private:
-    static inline unsigned int hash (const char *str, size_t len);
+    static inline unsigned int hash(const char *str, size_t len);
 public:
-    static const char *is_valid (const char *str, size_t len);
+    static const char * isValid(const char *str, size_t len);
 };
 
 namespace DB
 {
-    using tldLookup = tldLookupHash;
+    using tldLookup = TopLevelDomainLookupHash;
 }
diff --git a/dbms/src/Functions/array/arrayIndex.h b/dbms/src/Functions/array/arrayIndex.h
index 53895d7f548..1b1ac172f24 100644
--- a/dbms/src/Functions/array/arrayIndex.h
+++ b/dbms/src/Functions/array/arrayIndex.h
@@ -349,7 +349,7 @@ struct ArrayIndexStringImpl
         }
     }
 
-    static void vector_vector(
+    static void vectorVector(
         const ColumnString::Chars & data, const ColumnArray::Offsets & offsets, const ColumnString::Offsets & string_offsets,
         const ColumnString::Chars & item_values, const ColumnString::Offsets & item_offsets,
         PaddedPODArray<typename IndexConv::ResultType> & result,
@@ -731,7 +731,7 @@ private:
         }
         else if (const auto item_arg_vector = checkAndGetColumn<ColumnString>(item_arg))
         {
-            ArrayIndexStringImpl<IndexConv>::vector_vector(col_nested->getChars(), col_array->getOffsets(),
+            ArrayIndexStringImpl<IndexConv>::vectorVector(col_nested->getChars(), col_array->getOffsets(),
                 col_nested->getOffsets(), item_arg_vector->getChars(), item_arg_vector->getOffsets(),
                 col_res->getData(), null_map_data, null_map_item);
         }
diff --git a/dbms/src/Functions/array/length.cpp b/dbms/src/Functions/array/length.cpp
index 67267434794..a7fe2fb0662 100644
--- a/dbms/src/Functions/array/length.cpp
+++ b/dbms/src/Functions/array/length.cpp
@@ -20,12 +20,12 @@ struct LengthImpl
             res[i] = offsets[i] - 1 - offsets[i - 1];
     }
 
-    static void vector_fixed_to_constant(const ColumnString::Chars & /*data*/, size_t n, UInt64 & res)
+    static void vectorFixedToConstant(const ColumnString::Chars & /*data*/, size_t n, UInt64 & res)
     {
         res = n;
     }
 
-    static void vector_fixed_to_vector(const ColumnString::Chars & /*data*/, size_t /*n*/, PaddedPODArray<UInt64> & /*res*/)
+    static void vectorFixedToVector(const ColumnString::Chars & /*data*/, size_t /*n*/, PaddedPODArray<UInt64> & /*res*/)
     {
     }
 
diff --git a/dbms/src/Functions/concat.cpp b/dbms/src/Functions/concat.cpp
index fd9448a5327..7cf0b2ce891 100644
--- a/dbms/src/Functions/concat.cpp
+++ b/dbms/src/Functions/concat.cpp
@@ -119,7 +119,7 @@ private:
         auto c_res = ColumnString::create();
         std::vector<const ColumnString::Chars *> data(arguments.size());
         std::vector<const ColumnString::Offsets *> offsets(arguments.size());
-        std::vector<size_t> fixed_string_N(arguments.size());
+        std::vector<size_t> fixed_string_sizes(arguments.size());
         std::vector<String> constant_strings(arguments.size());
         bool has_column_string = false;
         bool has_column_fixed_string = false;
@@ -136,7 +136,7 @@ private:
             {
                 has_column_fixed_string = true;
                 data[i] = &fixed_col->getChars();
-                fixed_string_N[i] = fixed_col->getN();
+                fixed_string_sizes[i] = fixed_col->getN();
             }
             else if (const ColumnConst * const_col = checkAndGetColumnConstStringOrFixedString(column.get()))
             {
@@ -159,7 +159,7 @@ private:
             std::move(pattern),
             data,
             offsets,
-            fixed_string_N,
+            fixed_string_sizes,
             constant_strings,
             c_res->getChars(),
             c_res->getOffsets(),
diff --git a/dbms/src/Functions/dateDiff.cpp b/dbms/src/Functions/dateDiff.cpp
index 27427b81143..6d7574a2eed 100644
--- a/dbms/src/Functions/dateDiff.cpp
+++ b/dbms/src/Functions/dateDiff.cpp
@@ -145,13 +145,13 @@ private:
         ColumnInt64::Container & result)
     {
         if (auto * y_vec_16 = checkAndGetColumn<ColumnUInt16>(&y))
-            vector_vector<Transform>(x, *y_vec_16, timezone_x, timezone_y, result);
+            vectorVector<Transform>(x, *y_vec_16, timezone_x, timezone_y, result);
         else if (auto * y_vec_32 = checkAndGetColumn<ColumnUInt32>(&y))
-            vector_vector<Transform>(x, *y_vec_32, timezone_x, timezone_y, result);
+            vectorVector<Transform>(x, *y_vec_32, timezone_x, timezone_y, result);
         else if (auto * y_const_16 = checkAndGetColumnConst<ColumnUInt16>(&y))
-            vector_constant<Transform>(x, y_const_16->getValue<UInt16>(), timezone_x, timezone_y, result);
+            vectorConstant<Transform>(x, y_const_16->getValue<UInt16>(), timezone_x, timezone_y, result);
         else if (auto * y_const_32 = checkAndGetColumnConst<ColumnUInt32>(&y))
-            vector_constant<Transform>(x, y_const_32->getValue<UInt32>(), timezone_x, timezone_y, result);
+            vectorConstant<Transform>(x, y_const_32->getValue<UInt32>(), timezone_x, timezone_y, result);
         else
             throw Exception("Illegal column for second argument of function " + getName() + ", must be Date or DateTime", ErrorCodes::ILLEGAL_COLUMN);
     }
@@ -163,15 +163,15 @@ private:
         ColumnInt64::Container & result)
     {
         if (auto * y_vec_16 = checkAndGetColumn<ColumnUInt16>(&y))
-            constant_vector<Transform>(x, *y_vec_16, timezone_x, timezone_y, result);
+            constantVector<Transform>(x, *y_vec_16, timezone_x, timezone_y, result);
         else if (auto * y_vec_32 = checkAndGetColumn<ColumnUInt32>(&y))
-            constant_vector<Transform>(x, *y_vec_32, timezone_x, timezone_y, result);
+            constantVector<Transform>(x, *y_vec_32, timezone_x, timezone_y, result);
         else
             throw Exception("Illegal column for second argument of function " + getName() + ", must be Date or DateTime", ErrorCodes::ILLEGAL_COLUMN);
     }
 
     template <typename Transform, typename T1, typename T2>
-    void vector_vector(
+    void vectorVector(
         const ColumnVector<T1> & x, const ColumnVector<T2> & y,
         const DateLUTImpl & timezone_x, const DateLUTImpl & timezone_y,
         ColumnInt64::Container & result)
@@ -183,7 +183,7 @@ private:
     }
 
     template <typename Transform, typename T1, typename T2>
-    void vector_constant(
+    void vectorConstant(
         const ColumnVector<T1> & x, T2 y,
         const DateLUTImpl & timezone_x, const DateLUTImpl & timezone_y,
         ColumnInt64::Container & result)
@@ -194,7 +194,7 @@ private:
     }
 
     template <typename Transform, typename T1, typename T2>
-    void constant_vector(
+    void constantVector(
         T1 x, const ColumnVector<T2> & y,
         const DateLUTImpl & timezone_x, const DateLUTImpl & timezone_y,
         ColumnInt64::Container & result)
diff --git a/dbms/src/Functions/formatDateTime.cpp b/dbms/src/Functions/formatDateTime.cpp
index 5273348d00e..e058a8e3596 100644
--- a/dbms/src/Functions/formatDateTime.cpp
+++ b/dbms/src/Functions/formatDateTime.cpp
@@ -155,7 +155,7 @@ private:
                 writeNumber2(target, day);
         }
 
-        static void ISO8601Date(char * target, Time source, const DateLUTImpl & timezone)
+        static void ISO8601Date(char * target, Time source, const DateLUTImpl & timezone) // NOLINT
         {
             writeNumber4(target, ToYearImpl::execute(source, timezone));
             writeNumber2(target + 5, ToMonthImpl::execute(source, timezone));
@@ -183,7 +183,7 @@ private:
             *target += (day == 7 ? 0 : day);
         }
 
-        static void ISO8601Week(char * target, Time source, const DateLUTImpl & timezone)
+        static void ISO8601Week(char * target, Time source, const DateLUTImpl & timezone) // NOLINT
         {
             writeNumber2(target, ToISOWeekImpl::execute(source, timezone));
         }
@@ -214,7 +214,7 @@ private:
             writeNumber2(target, ToMinuteImpl::execute(source, timezone));
         }
 
-        static void AMPM(char * target, Time source, const DateLUTImpl & timezone)
+        static void AMPM(char * target, Time source, const DateLUTImpl & timezone) // NOLINT
         {
             auto hour = ToHourImpl::execute(source, timezone);
             if (hour >= 12)
@@ -232,7 +232,7 @@ private:
             writeNumber2(target, ToSecondImpl::execute(source, timezone));
         }
 
-        static void ISO8601Time(char * target, Time source, const DateLUTImpl & timezone)
+        static void ISO8601Time(char * target, Time source, const DateLUTImpl & timezone) // NOLINT
         {
             writeNumber2(target, ToHourImpl::execute(source, timezone));
             writeNumber2(target + 3, ToMinuteImpl::execute(source, timezone));
@@ -394,7 +394,7 @@ public:
         const char * end = pos + pattern.size();
 
         /// Add shift to previous action; or if there were none, add noop action with shift.
-        auto addShift = [&](size_t amount)
+        auto add_shift = [&](size_t amount)
         {
             if (instructions.empty())
                 instructions.emplace_back(&Action<T>::noop);
@@ -402,12 +402,12 @@ public:
         };
 
         /// If the argument was DateTime, add instruction for printing. If it was date, just shift (the buffer is pre-filled with default values).
-        auto addInstructionOrShift = [&](typename Action<T>::Func func [[maybe_unused]], size_t shift)
+        auto add_instruction_or_shift = [&](typename Action<T>::Func func [[maybe_unused]], size_t shift)
         {
             if constexpr (std::is_same_v<T, UInt32>)
                 instructions.emplace_back(func, shift);
             else
-                addShift(shift);
+                add_shift(shift);
         };
 
         while (true)
@@ -419,7 +419,7 @@ public:
                 if (pos < percent_pos)
                 {
                     result.append(pos, percent_pos);
-                    addShift(percent_pos - pos);
+                    add_shift(percent_pos - pos);
                 }
 
                 pos = percent_pos + 1;
@@ -505,58 +505,58 @@ public:
 
                     // Minute (00-59)
                     case 'M':
-                        addInstructionOrShift(&Action<T>::minute, 2);
+                        add_instruction_or_shift(&Action<T>::minute, 2);
                         result.append("00");
                         break;
 
                     // AM or PM
                     case 'p':
-                        addInstructionOrShift(&Action<T>::AMPM, 2);
+                        add_instruction_or_shift(&Action<T>::AMPM, 2);
                         result.append("AM");
                         break;
 
                     // 24-hour HH:MM time, equivalent to %H:%M 14:55
                     case 'R':
-                        addInstructionOrShift(&Action<T>::hhmm24, 5);
+                        add_instruction_or_shift(&Action<T>::hhmm24, 5);
                         result.append("00:00");
                         break;
 
                     // Seconds
                     case 'S':
-                        addInstructionOrShift(&Action<T>::second, 2);
+                        add_instruction_or_shift(&Action<T>::second, 2);
                         result.append("00");
                         break;
 
                     // ISO 8601 time format (HH:MM:SS), equivalent to %H:%M:%S 14:55:02
                     case 'T':
-                        addInstructionOrShift(&Action<T>::ISO8601Time, 8);
+                        add_instruction_or_shift(&Action<T>::ISO8601Time, 8);
                         result.append("00:00:00");
                         break;
 
                     // Hour in 24h format (00-23)
                     case 'H':
-                        addInstructionOrShift(&Action<T>::hour24, 2);
+                        add_instruction_or_shift(&Action<T>::hour24, 2);
                         result.append("00");
                         break;
 
                     // Hour in 12h format (01-12)
                     case 'I':
-                        addInstructionOrShift(&Action<T>::hour12, 2);
+                        add_instruction_or_shift(&Action<T>::hour12, 2);
                         result.append("12");
                         break;
 
                     /// Escaped literal characters.
                     case '%':
                         result += '%';
-                        addShift(1);
+                        add_shift(1);
                         break;
                     case 't':
                         result += '\t';
-                        addShift(1);
+                        add_shift(1);
                         break;
                     case 'n':
                         result += '\n';
-                        addShift(1);
+                        add_shift(1);
                         break;
 
                     // Unimplemented
@@ -575,7 +575,7 @@ public:
             else
             {
                 result.append(pos, end);
-                addShift(end + 1 - pos); /// including zero terminator
+                add_shift(end + 1 - pos); /// including zero terminator
                 break;
             }
         }
diff --git a/dbms/src/Functions/formatString.cpp b/dbms/src/Functions/formatString.cpp
index fd152ea83a5..0fefe3f95cb 100644
--- a/dbms/src/Functions/formatString.cpp
+++ b/dbms/src/Functions/formatString.cpp
@@ -78,7 +78,7 @@ public:
 
         std::vector<const ColumnString::Chars *> data(arguments.size() - 1);
         std::vector<const ColumnString::Offsets *> offsets(arguments.size() - 1);
-        std::vector<size_t> fixed_string_N(arguments.size() - 1);
+        std::vector<size_t> fixed_string_sizes(arguments.size() - 1);
         std::vector<String> constant_strings(arguments.size() - 1);
 
         bool has_column_string = false;
@@ -96,7 +96,7 @@ public:
             {
                 has_column_fixed_string = true;
                 data[i - 1] = &fixed_col->getChars();
-                fixed_string_N[i - 1] = fixed_col->getN();
+                fixed_string_sizes[i - 1] = fixed_col->getN();
             }
             else if (const ColumnConst * const_col = checkAndGetColumnConstStringOrFixedString(column.get()))
             {
@@ -113,7 +113,7 @@ public:
             std::move(pattern),
             data,
             offsets,
-            fixed_string_N,
+            fixed_string_sizes,
             constant_strings,
             col_res->getChars(),
             col_res->getOffsets(),
diff --git a/dbms/src/Functions/if.cpp b/dbms/src/Functions/if.cpp
index dfafbe36471..f16033b1f52 100644
--- a/dbms/src/Functions/if.cpp
+++ b/dbms/src/Functions/if.cpp
@@ -53,7 +53,7 @@ struct NumIfImpl
     using ArrayB = PaddedPODArray<B>;
     using ColVecResult = ColumnVector<ResultType>;
 
-    static void vector_vector(const ArrayCond & cond, const ArrayA & a, const ArrayB & b, Block & block, size_t result, UInt32)
+    static void vectorVector(const ArrayCond & cond, const ArrayA & a, const ArrayB & b, Block & block, size_t result, UInt32)
     {
         size_t size = cond.size();
         auto col_res = ColVecResult::create(size);
@@ -64,7 +64,7 @@ struct NumIfImpl
         block.getByPosition(result).column = std::move(col_res);
     }
 
-    static void vector_constant(const ArrayCond & cond, const ArrayA & a, B b, Block & block, size_t result, UInt32)
+    static void vectorConstant(const ArrayCond & cond, const ArrayA & a, B b, Block & block, size_t result, UInt32)
     {
         size_t size = cond.size();
         auto col_res = ColVecResult::create(size);
@@ -75,7 +75,7 @@ struct NumIfImpl
         block.getByPosition(result).column = std::move(col_res);
     }
 
-    static void constant_vector(const ArrayCond & cond, A a, const ArrayB & b, Block & block, size_t result, UInt32)
+    static void constantVector(const ArrayCond & cond, A a, const ArrayB & b, Block & block, size_t result, UInt32)
     {
         size_t size = cond.size();
         auto col_res = ColVecResult::create(size);
@@ -86,7 +86,7 @@ struct NumIfImpl
         block.getByPosition(result).column = std::move(col_res);
     }
 
-    static void constant_constant(const ArrayCond & cond, A a, B b, Block & block, size_t result, UInt32)
+    static void constantConstant(const ArrayCond & cond, A a, B b, Block & block, size_t result, UInt32)
     {
         size_t size = cond.size();
         auto col_res = ColVecResult::create(size);
@@ -107,7 +107,7 @@ struct NumIfImpl<Decimal<A>, Decimal<B>, Decimal<R>>
     using ArrayB = DecimalPaddedPODArray<Decimal<B>>;
     using ColVecResult = ColumnDecimal<ResultType>;
 
-    static void vector_vector(const ArrayCond & cond, const ArrayA & a, const ArrayB & b, Block & block, size_t result, UInt32 scale)
+    static void vectorVector(const ArrayCond & cond, const ArrayA & a, const ArrayB & b, Block & block, size_t result, UInt32 scale)
     {
         size_t size = cond.size();
         auto col_res = ColVecResult::create(size, scale);
@@ -118,7 +118,7 @@ struct NumIfImpl<Decimal<A>, Decimal<B>, Decimal<R>>
         block.getByPosition(result).column = std::move(col_res);
     }
 
-    static void vector_constant(const ArrayCond & cond, const ArrayA & a, B b, Block & block, size_t result, UInt32 scale)
+    static void vectorConstant(const ArrayCond & cond, const ArrayA & a, B b, Block & block, size_t result, UInt32 scale)
     {
         size_t size = cond.size();
         auto col_res = ColVecResult::create(size, scale);
@@ -129,7 +129,7 @@ struct NumIfImpl<Decimal<A>, Decimal<B>, Decimal<R>>
         block.getByPosition(result).column = std::move(col_res);
     }
 
-    static void constant_vector(const ArrayCond & cond, A a, const ArrayB & b, Block & block, size_t result, UInt32 scale)
+    static void constantVector(const ArrayCond & cond, A a, const ArrayB & b, Block & block, size_t result, UInt32 scale)
     {
         size_t size = cond.size();
         auto col_res = ColVecResult::create(size, scale);
@@ -140,7 +140,7 @@ struct NumIfImpl<Decimal<A>, Decimal<B>, Decimal<R>>
         block.getByPosition(result).column = std::move(col_res);
     }
 
-    static void constant_constant(const ArrayCond & cond, A a, B b, Block & block, size_t result, UInt32 scale)
+    static void constantConstant(const ArrayCond & cond, A a, B b, Block & block, size_t result, UInt32 scale)
     {
         size_t size = cond.size();
         auto col_res = ColVecResult::create(size, scale);
@@ -156,15 +156,15 @@ template <typename A, typename B>
 struct NumIfImpl<A, B, NumberTraits::Error>
 {
 private:
-    [[noreturn]] static void throw_error()
+    [[noreturn]] static void throwError()
     {
         throw Exception("Internal logic error: invalid types of arguments 2 and 3 of if", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
     }
 public:
-    template <typename... Args> static void vector_vector(Args &&...) { throw_error(); }
-    template <typename... Args> static void vector_constant(Args &&...) { throw_error(); }
-    template <typename... Args> static void constant_vector(Args &&...) { throw_error(); }
-    template <typename... Args> static void constant_constant(Args &&...) { throw_error(); }
+    template <typename... Args> static void vectorVector(Args &&...) { throwError(); }
+    template <typename... Args> static void vectorConstant(Args &&...) { throwError(); }
+    template <typename... Args> static void constantVector(Args &&...) { throwError(); }
+    template <typename... Args> static void constantConstant(Args &&...) { throwError(); }
 };
 
 
@@ -209,13 +209,13 @@ private:
 
         if (auto col_right_vec = checkAndGetColumn<ColVecT1>(col_right_untyped))
         {
-            NumIfImpl<T0, T1, ResultType>::vector_vector(
+            NumIfImpl<T0, T1, ResultType>::vectorVector(
                 cond_col->getData(), col_left->getData(), col_right_vec->getData(), block, result, scale);
             return true;
         }
         else if (auto col_right_const = checkAndGetColumnConst<ColVecT1>(col_right_untyped))
         {
-            NumIfImpl<T0, T1, ResultType>::vector_constant(
+            NumIfImpl<T0, T1, ResultType>::vectorConstant(
                 cond_col->getData(), col_left->getData(), col_right_const->template getValue<T1>(), block, result, scale);
             return true;
         }
@@ -238,13 +238,13 @@ private:
 
         if (auto col_right_vec = checkAndGetColumn<ColVecT1>(col_right_untyped))
         {
-            NumIfImpl<T0, T1, ResultType>::constant_vector(
+            NumIfImpl<T0, T1, ResultType>::constantVector(
                 cond_col->getData(), col_left->template getValue<T0>(), col_right_vec->getData(), block, result, scale);
             return true;
         }
         else if (auto col_right_const = checkAndGetColumnConst<ColVecT1>(col_right_untyped))
         {
-            NumIfImpl<T0, T1, ResultType>::constant_constant(
+            NumIfImpl<T0, T1, ResultType>::constantConstant(
                 cond_col->getData(), col_left->template getValue<T0>(), col_right_const->template getValue<T1>(), block, result, scale);
             return true;
         }
diff --git a/dbms/src/Functions/intDiv.cpp b/dbms/src/Functions/intDiv.cpp
index 5bd6abcbff8..0b6734c0136 100644
--- a/dbms/src/Functions/intDiv.cpp
+++ b/dbms/src/Functions/intDiv.cpp
@@ -24,7 +24,7 @@ struct DivideIntegralByConstantImpl
     using ResultType = typename DivideIntegralImpl<A, B>::ResultType;
     static const constexpr bool allow_fixed_string = false;
 
-    static NO_INLINE void vector_constant(const A * __restrict a_pos, B b, ResultType * __restrict c_pos, size_t size)
+    static NO_INLINE void vectorConstant(const A * __restrict a_pos, B b, ResultType * __restrict c_pos, size_t size)
     {
         if (unlikely(b == 0))
             throw Exception("Division by zero", ErrorCodes::ILLEGAL_DIVISION);
diff --git a/dbms/src/Functions/isValidUTF8.cpp b/dbms/src/Functions/isValidUTF8.cpp
index a62596908ab..354dc24e3d8 100644
--- a/dbms/src/Functions/isValidUTF8.cpp
+++ b/dbms/src/Functions/isValidUTF8.cpp
@@ -304,9 +304,9 @@ SOFTWARE.
         }
     }
 
-    static void vector_fixed_to_constant(const ColumnString::Chars & /*data*/, size_t /*n*/, UInt8 & /*res*/) {}
+    static void vectorFixedToConstant(const ColumnString::Chars & /*data*/, size_t /*n*/, UInt8 & /*res*/) {}
 
-    static void vector_fixed_to_vector(const ColumnString::Chars & data, size_t n, PaddedPODArray<UInt8> & res)
+    static void vectorFixedToVector(const ColumnString::Chars & data, size_t n, PaddedPODArray<UInt8> & res)
     {
         size_t size = data.size() / n;
         for (size_t i = 0; i < size; ++i)
diff --git a/dbms/src/Functions/lengthUTF8.cpp b/dbms/src/Functions/lengthUTF8.cpp
index 2549e32b8f7..7c71533acd9 100644
--- a/dbms/src/Functions/lengthUTF8.cpp
+++ b/dbms/src/Functions/lengthUTF8.cpp
@@ -34,11 +34,11 @@ struct LengthUTF8Impl
         }
     }
 
-    static void vector_fixed_to_constant(const ColumnString::Chars & /*data*/, size_t /*n*/, UInt64 & /*res*/)
+    static void vectorFixedToConstant(const ColumnString::Chars & /*data*/, size_t /*n*/, UInt64 & /*res*/)
     {
     }
 
-    static void vector_fixed_to_vector(const ColumnString::Chars & data, size_t n, PaddedPODArray<UInt64> & res)
+    static void vectorFixedToVector(const ColumnString::Chars & data, size_t n, PaddedPODArray<UInt64> & res)
     {
         size_t size = data.size() / n;
 
diff --git a/dbms/src/Functions/modulo.cpp b/dbms/src/Functions/modulo.cpp
index 3cfa2fa0c1a..9e4409ca91b 100644
--- a/dbms/src/Functions/modulo.cpp
+++ b/dbms/src/Functions/modulo.cpp
@@ -25,7 +25,7 @@ struct ModuloByConstantImpl
     using ResultType = typename ModuloImpl<A, B>::ResultType;
     static const constexpr bool allow_fixed_string = false;
 
-    static NO_INLINE void vector_constant(const A * __restrict src, B b, ResultType * __restrict dst, size_t size)
+    static NO_INLINE void vectorConstant(const A * __restrict src, B b, ResultType * __restrict dst, size_t size)
     {
         if (unlikely(b == 0))
             throw Exception("Division by zero", ErrorCodes::ILLEGAL_DIVISION);
diff --git a/dbms/src/Functions/pointInPolygon.cpp b/dbms/src/Functions/pointInPolygon.cpp
index 0392fe005db..158c4f18ccf 100644
--- a/dbms/src/Functions/pointInPolygon.cpp
+++ b/dbms/src/Functions/pointInPolygon.cpp
@@ -121,28 +121,28 @@ public:
             throw Exception("Too few arguments", ErrorCodes::TOO_FEW_ARGUMENTS_FOR_FUNCTION);
         }
 
-        auto getMsgPrefix = [this](size_t i) { return "Argument " + toString(i + 1) + " for function " + getName(); };
+        auto get_message_prefix = [this](size_t i) { return "Argument " + toString(i + 1) + " for function " + getName(); };
 
         for (size_t i = 1; i < arguments.size(); ++i)
         {
             auto * array = checkAndGetDataType<DataTypeArray>(arguments[i].get());
             if (array == nullptr && i != 1)
-                throw Exception(getMsgPrefix(i) + " must be array of tuples.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+                throw Exception(get_message_prefix(i) + " must be array of tuples.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
             auto * tuple = checkAndGetDataType<DataTypeTuple>(array ? array->getNestedType().get() : arguments[i].get());
             if (tuple == nullptr)
-                throw Exception(getMsgPrefix(i) + " must contains tuple.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+                throw Exception(get_message_prefix(i) + " must contains tuple.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
             const DataTypes & elements = tuple->getElements();
 
             if (elements.size() != 2)
-                throw Exception(getMsgPrefix(i) + " must have exactly two elements.", ErrorCodes::BAD_ARGUMENTS);
+                throw Exception(get_message_prefix(i) + " must have exactly two elements.", ErrorCodes::BAD_ARGUMENTS);
 
             for (auto j : ext::range(0, elements.size()))
             {
                 if (!isNativeNumber(elements[j]))
                 {
-                    throw Exception(getMsgPrefix(i) + " must contains numeric tuple at position " + toString(j + 1),
+                    throw Exception(get_message_prefix(i) + " must contains numeric tuple at position " + toString(j + 1),
                                     ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
                 }
             }
@@ -207,7 +207,7 @@ private:
     {
         Polygon<Type> polygon;
 
-        auto getMsgPrefix = [this](size_t i) { return "Argument " + toString(i + 1) + " for function " + getName(); };
+        auto get_message_prefix = [this](size_t i) { return "Argument " + toString(i + 1) + " for function " + getName(); };
 
         for (size_t i = 1; i < arguments.size(); ++i)
         {
@@ -216,7 +216,7 @@ private:
             auto tuple_col = array_col ? checkAndGetColumn<ColumnTuple>(&array_col->getData()) : nullptr;
 
             if (!tuple_col)
-                throw Exception(getMsgPrefix(i) + " must be constant array of tuples.", ErrorCodes::ILLEGAL_COLUMN);
+                throw Exception(get_message_prefix(i) + " must be constant array of tuples.", ErrorCodes::ILLEGAL_COLUMN);
 
             const auto & tuple_columns = tuple_col->getColumns();
             const auto & column_x = tuple_columns[0];
@@ -230,7 +230,7 @@ private:
             auto size = column_x->size();
 
             if (size == 0)
-                throw Exception(getMsgPrefix(i) + " shouldn't be empty.", ErrorCodes::ILLEGAL_COLUMN);
+                throw Exception(get_message_prefix(i) + " shouldn't be empty.", ErrorCodes::ILLEGAL_COLUMN);
 
             for (auto j : ext::range(0, size))
             {
@@ -244,13 +244,12 @@ private:
                 container.push_back(container.front());
         }
 
-        auto callImpl = use_object_pool
+        auto call_impl = use_object_pool
             ? FunctionPointInPolygonDetail::callPointInPolygonImplWithPool<Polygon<Type>, PointInPolygonImpl<Type>>
             : FunctionPointInPolygonDetail::callPointInPolygonImpl<Polygon<Type>, PointInPolygonImpl<Type>>;
 
-        return callImpl(x, y, polygon);
+        return call_impl(x, y, polygon);
     }
-
 };
 
 
diff --git a/dbms/src/Functions/reverse.cpp b/dbms/src/Functions/reverse.cpp
index c764d6e7338..2c135cf3d7d 100644
--- a/dbms/src/Functions/reverse.cpp
+++ b/dbms/src/Functions/reverse.cpp
@@ -40,7 +40,7 @@ struct ReverseImpl
         }
     }
 
-    static void vector_fixed(const ColumnString::Chars & data, size_t n, ColumnString::Chars & res_data)
+    static void vectorFixed(const ColumnString::Chars & data, size_t n, ColumnString::Chars & res_data)
     {
         res_data.resize(data.size());
         size_t size = data.size() / n;
@@ -100,7 +100,7 @@ public:
         else if (const ColumnFixedString * col_fixed = checkAndGetColumn<ColumnFixedString>(column.get()))
         {
             auto col_res = ColumnFixedString::create(col_fixed->getN());
-            ReverseImpl::vector_fixed(col_fixed->getChars(), col_fixed->getN(), col_res->getChars());
+            ReverseImpl::vectorFixed(col_fixed->getChars(), col_fixed->getN(), col_res->getChars());
             block.getByPosition(result).column = std::move(col_res);
         }
         else
diff --git a/dbms/src/Functions/reverseUTF8.cpp b/dbms/src/Functions/reverseUTF8.cpp
index 261aa6935e2..40f3214f880 100644
--- a/dbms/src/Functions/reverseUTF8.cpp
+++ b/dbms/src/Functions/reverseUTF8.cpp
@@ -61,7 +61,7 @@ struct ReverseUTF8Impl
         }
     }
 
-    [[noreturn]] static void vector_fixed(const ColumnString::Chars &, size_t, ColumnString::Chars &)
+    [[noreturn]] static void vectorFixed(const ColumnString::Chars &, size_t, ColumnString::Chars &)
     {
         throw Exception("Cannot apply function reverseUTF8 to fixed string.", ErrorCodes::ILLEGAL_COLUMN);
     }
diff --git a/dbms/src/Functions/timeSlots.cpp b/dbms/src/Functions/timeSlots.cpp
index 15c7f42dedc..b908a9c00ef 100644
--- a/dbms/src/Functions/timeSlots.cpp
+++ b/dbms/src/Functions/timeSlots.cpp
@@ -34,7 +34,7 @@ namespace ErrorCodes
 template <typename DurationType>
 struct TimeSlotsImpl
 {
-    static void vector_vector(
+    static void vectorVector(
         const PaddedPODArray<UInt32> & starts, const PaddedPODArray<DurationType> & durations, UInt32 time_slot_size,
         PaddedPODArray<UInt32> & result_values, ColumnArray::Offsets & result_offsets)
     {
@@ -56,7 +56,7 @@ struct TimeSlotsImpl
         }
     }
 
-    static void vector_constant(
+    static void vectorConstant(
         const PaddedPODArray<UInt32> & starts, DurationType duration, UInt32 time_slot_size,
         PaddedPODArray<UInt32> & result_values, ColumnArray::Offsets & result_offsets)
     {
@@ -78,7 +78,7 @@ struct TimeSlotsImpl
         }
     }
 
-    static void constant_vector(
+    static void constantVector(
         UInt32 start, const PaddedPODArray<DurationType> & durations, UInt32 time_slot_size,
         PaddedPODArray<UInt32> & result_values, ColumnArray::Offsets & result_offsets)
     {
@@ -168,17 +168,17 @@ public:
 
         if (starts && durations)
         {
-            TimeSlotsImpl<UInt32>::vector_vector(starts->getData(), durations->getData(), time_slot_size, res_values, res->getOffsets());
+            TimeSlotsImpl<UInt32>::vectorVector(starts->getData(), durations->getData(), time_slot_size, res_values, res->getOffsets());
             block.getByPosition(result).column = std::move(res);
         }
         else if (starts && const_durations)
         {
-            TimeSlotsImpl<UInt32>::vector_constant(starts->getData(), const_durations->getValue<UInt32>(), time_slot_size, res_values, res->getOffsets());
+            TimeSlotsImpl<UInt32>::vectorConstant(starts->getData(), const_durations->getValue<UInt32>(), time_slot_size, res_values, res->getOffsets());
             block.getByPosition(result).column = std::move(res);
         }
         else if (const_starts && durations)
         {
-            TimeSlotsImpl<UInt32>::constant_vector(const_starts->getValue<UInt32>(), durations->getData(), time_slot_size, res_values, res->getOffsets());
+            TimeSlotsImpl<UInt32>::constantVector(const_starts->getValue<UInt32>(), durations->getData(), time_slot_size, res_values, res->getOffsets());
             block.getByPosition(result).column = std::move(res);
         }
         else
diff --git a/dbms/src/Functions/toValidUTF8.cpp b/dbms/src/Functions/toValidUTF8.cpp
index 4cc11a0a68d..e7add23fb07 100644
--- a/dbms/src/Functions/toValidUTF8.cpp
+++ b/dbms/src/Functions/toValidUTF8.cpp
@@ -124,7 +124,7 @@ struct ToValidUTF8Impl
         write_buffer.finalize();
     }
 
-    [[noreturn]] static void vector_fixed(const ColumnString::Chars &, size_t, ColumnString::Chars &)
+    [[noreturn]] static void vectorFixed(const ColumnString::Chars &, size_t, ColumnString::Chars &)
     {
         throw Exception("Column of type FixedString is not supported by toValidUTF8 function", ErrorCodes::ILLEGAL_COLUMN);
     }
diff --git a/dbms/src/Functions/trim.cpp b/dbms/src/Functions/trim.cpp
index f674afbd310..eba49739074 100644
--- a/dbms/src/Functions/trim.cpp
+++ b/dbms/src/Functions/trim.cpp
@@ -33,7 +33,7 @@ struct TrimModeBoth
     static constexpr bool trim_right = true;
 };
 
-template <typename mode>
+template <typename Mode>
 class FunctionTrimImpl
 {
 public:
@@ -67,7 +67,7 @@ public:
         }
     }
 
-    static void vector_fixed(const ColumnString::Chars &, size_t, ColumnString::Chars &)
+    static void vectorFixed(const ColumnString::Chars &, size_t, ColumnString::Chars &)
     {
         throw Exception("Functions trimLeft, trimRight and trimBoth cannot work with FixedString argument", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
     }
@@ -78,14 +78,14 @@ private:
         const char * char_data = reinterpret_cast<const char *>(data);
         const char * char_end = char_data + size;
 
-        if constexpr (mode::trim_left)
+        if constexpr (Mode::trim_left)
         { // NOLINT
             const char * found = find_first_not_symbols<' '>(char_data, char_end);
             size_t num_chars = found - char_data;
             char_data += num_chars;
         }
 
-        if constexpr (mode::trim_right)
+        if constexpr (Mode::trim_right)
         { // NOLINT
             const char * found = find_last_not_symbols_or_null<' '>(char_data, char_end);
             if (found)
diff --git a/dbms/src/IO/HTTPCommon.cpp b/dbms/src/IO/HTTPCommon.cpp
index e00ef5edf76..d8ce3427c91 100644
--- a/dbms/src/IO/HTTPCommon.cpp
+++ b/dbms/src/IO/HTTPCommon.cpp
@@ -164,10 +164,10 @@ namespace
 
             /// We store exception messages in session data.
             /// Poco HTTPSession also stores exception, but it can be removed at any time.
-            const auto & sessionData = session->sessionData();
-            if (!sessionData.empty())
+            const auto & session_data = session->sessionData();
+            if (!session_data.empty())
             {
-                auto msg = Poco::AnyCast<std::string>(sessionData);
+                auto msg = Poco::AnyCast<std::string>(session_data);
                 if (!msg.empty())
                 {
                     LOG_TRACE((&Logger::get("HTTPCommon")), "Failed communicating with " << host << " with error '" << msg << "' will try to reconnect session");
diff --git a/dbms/src/IO/ReadHelpers.cpp b/dbms/src/IO/ReadHelpers.cpp
index 7c3c99ecd7d..75682906242 100644
--- a/dbms/src/IO/ReadHelpers.cpp
+++ b/dbms/src/IO/ReadHelpers.cpp
@@ -786,14 +786,14 @@ ReturnType readDateTimeTextFallback(time_t & datetime, ReadBuffer & buf, const D
 {
     static constexpr bool throw_exception = std::is_same_v<ReturnType, void>;
 
-    static constexpr auto DATE_TIME_BROKEN_DOWN_LENGTH = 19;
-    static constexpr auto UNIX_TIMESTAMP_MAX_LENGTH = 10;
+    static constexpr auto date_time_broken_down_length = 19;
+    static constexpr auto unix_timestamp_max_length = 10;
 
-    char s[DATE_TIME_BROKEN_DOWN_LENGTH];
+    char s[date_time_broken_down_length];
     char * s_pos = s;
 
     /// A piece similar to unix timestamp.
-    while (s_pos < s + UNIX_TIMESTAMP_MAX_LENGTH && !buf.eof() && isNumericASCII(*buf.position()))
+    while (s_pos < s + unix_timestamp_max_length && !buf.eof() && isNumericASCII(*buf.position()))
     {
         *s_pos = *buf.position();
         ++s_pos;
@@ -803,7 +803,7 @@ ReturnType readDateTimeTextFallback(time_t & datetime, ReadBuffer & buf, const D
     /// 2015-01-01 01:02:03
     if (s_pos == s + 4 && !buf.eof() && (*buf.position() < '0' || *buf.position() > '9'))
     {
-        const size_t remaining_size = DATE_TIME_BROKEN_DOWN_LENGTH - (s_pos - s);
+        const size_t remaining_size = date_time_broken_down_length - (s_pos - s);
         size_t size = buf.read(s_pos, remaining_size);
         if (remaining_size != size)
         {
diff --git a/dbms/src/IO/S3Common.cpp b/dbms/src/IO/S3Common.cpp
index e169eff7846..137fe22c872 100644
--- a/dbms/src/IO/S3Common.cpp
+++ b/dbms/src/IO/S3Common.cpp
@@ -106,7 +106,7 @@ namespace S3
 
     URI::URI(const Poco::URI & uri_)
     {
-        static const std::regex BUCKET_KEY_PATTERN("([^/]+)/(.*)");
+        static const std::regex bucket_key_pattern("([^/]+)/(.*)"); /// TODO std::regex is discouraged
 
         uri = uri_;
 
@@ -133,7 +133,7 @@ namespace S3
 
         // Parse bucket and key from path.
         std::smatch match;
-        std::regex_search(uri.getPath(), match, BUCKET_KEY_PATTERN);
+        std::regex_search(uri.getPath(), match, bucket_key_pattern);
         if (!match.empty())
         {
             bucket = match.str(1);
diff --git a/dbms/src/IO/tests/gtest_DateTimeToString.cpp b/dbms/src/IO/tests/gtest_DateTimeToString.cpp
index 3ffc5a9a354..b40bbcddecd 100644
--- a/dbms/src/IO/tests/gtest_DateTimeToString.cpp
+++ b/dbms/src/IO/tests/gtest_DateTimeToString.cpp
@@ -86,7 +86,7 @@ template <typename ValueType>
 class DateTimeToStringParamTestBase : public ::testing::TestWithParam<DateTimeToStringParamTestCase<ValueType>>
 {
 public:
-    void Test(const DateTimeToStringParamTestCase<ValueType> & param)
+    void test(const DateTimeToStringParamTestCase<ValueType> & param)
     {
         [[maybe_unused]] const auto & [description, input, expected, timezone_name] = param;
 
@@ -119,7 +119,7 @@ class DateTimeToStringParamTestDayNum : public DateTimeToStringParamTestBase<Day
 
 TEST_P(DateTimeToStringParamTestDayNum, writeDateText)
 {
-    ASSERT_NO_FATAL_FAILURE(Test(GetParam()));
+    ASSERT_NO_FATAL_FAILURE(test(GetParam()));
 }
 
 class DateTimeToStringParamTestTimeT : public DateTimeToStringParamTestBase<time_t>
@@ -127,7 +127,7 @@ class DateTimeToStringParamTestTimeT : public DateTimeToStringParamTestBase<time
 
 TEST_P(DateTimeToStringParamTestTimeT, writeDateText)
 {
-    ASSERT_NO_FATAL_FAILURE(Test(GetParam()));
+    ASSERT_NO_FATAL_FAILURE(test(GetParam()));
 }
 
 class DateTimeToStringParamTestDateTime64 : public DateTimeToStringParamTestBase<DateTime64WithScale>
@@ -135,7 +135,7 @@ class DateTimeToStringParamTestDateTime64 : public DateTimeToStringParamTestBase
 
 TEST_P(DateTimeToStringParamTestDateTime64, writeDateText)
 {
-    ASSERT_NO_FATAL_FAILURE(Test(GetParam()));
+    ASSERT_NO_FATAL_FAILURE(test(GetParam()));
 }
 
 static const Int32 NON_ZERO_TIME_T = 10 * 365 * 3600 * 24 + 123456;
diff --git a/dbms/src/IO/tests/hashing_read_buffer.cpp b/dbms/src/IO/tests/hashing_read_buffer.cpp
index be31d5b05d3..dbec6b2374b 100644
--- a/dbms/src/IO/tests/hashing_read_buffer.cpp
+++ b/dbms/src/IO/tests/hashing_read_buffer.cpp
@@ -23,8 +23,8 @@ static void test(size_t data_size)
     {
         std::cout << "block size " << read_buffer_block_size << std::endl;
         std::stringstream io;
-        DB::WriteBufferFromOStream out_(io);
-        DB::HashingWriteBuffer out(out_);
+        DB::WriteBufferFromOStream out_impl(io);
+        DB::HashingWriteBuffer out(out_impl);
         out.write(data, data_size);
         out.next();
 
diff --git a/dbms/src/IO/tests/o_direct_and_dirty_pages.cpp b/dbms/src/IO/tests/o_direct_and_dirty_pages.cpp
index c08069454c9..8387ecac9e4 100644
--- a/dbms/src/IO/tests/o_direct_and_dirty_pages.cpp
+++ b/dbms/src/IO/tests/o_direct_and_dirty_pages.cpp
@@ -14,8 +14,8 @@ int main(int, char **)
 
     try
     {
-        const size_t N = 100000;
-        const size_t BUF_SIZE = 1048576;
+        static const size_t N = 100000;
+        static const size_t BUF_SIZE = 1048576;
 
         ReadBufferFromFile rand_in("/dev/urandom");
         unsigned rand = 0;
diff --git a/dbms/src/IO/tests/ryu_test.cpp b/dbms/src/IO/tests/ryu_test.cpp
index 0713a01960f..503eec82fd6 100644
--- a/dbms/src/IO/tests/ryu_test.cpp
+++ b/dbms/src/IO/tests/ryu_test.cpp
@@ -23,7 +23,7 @@ struct DecomposedFloat64
         return (x_uint >> 52) & 0x7FF;
     }
 
-    int16_t normalized_exponent() const
+    int16_t normalizedExponent() const
     {
         return int16_t(exponent()) - 1023;
     }
@@ -33,11 +33,11 @@ struct DecomposedFloat64
         return x_uint & 0x5affffffffffffful;
     }
 
-    bool is_inside_int64() const
+    bool isInsideInt64() const
     {
         return x_uint == 0
-            || (normalized_exponent() >= 0 && normalized_exponent() <= 52
-                && ((mantissa() & ((1ULL << (52 - normalized_exponent())) - 1)) == 0));
+            || (normalizedExponent() >= 0 && normalizedExponent() <= 52
+                && ((mantissa() & ((1ULL << (52 - normalizedExponent())) - 1)) == 0));
     }
 };
 
@@ -60,7 +60,7 @@ struct DecomposedFloat32
         return (x_uint >> 23) & 0xFF;
     }
 
-    int16_t normalized_exponent() const
+    int16_t normalizedExponent() const
     {
         return int16_t(exponent()) - 127;
     }
@@ -70,11 +70,11 @@ struct DecomposedFloat32
         return x_uint & 0x7fffff;
     }
 
-    bool is_inside_int32() const
+    bool isInsideInt32() const
     {
         return x_uint == 0
-            || (normalized_exponent() >= 0 && normalized_exponent() <= 23
-                && ((mantissa() & ((1ULL << (23 - normalized_exponent())) - 1)) == 0));
+            || (normalizedExponent() >= 0 && normalizedExponent() <= 23
+                && ((mantissa() & ((1ULL << (23 - normalizedExponent())) - 1)) == 0));
     }
 };
 
@@ -87,7 +87,7 @@ int main(int argc, char ** argv)
     d2s_buffered(x, buf);
     std::cout << buf << "\n";
 
-    std::cout << DecomposedFloat64(x).is_inside_int64() << "\n";
+    std::cout << DecomposedFloat64(x).isInsideInt64() << "\n";
 
     return 0;
 }
diff --git a/dbms/src/Interpreters/ActionsVisitor.cpp b/dbms/src/Interpreters/ActionsVisitor.cpp
index 3e07105c2f1..4e008a81973 100644
--- a/dbms/src/Interpreters/ActionsVisitor.cpp
+++ b/dbms/src/Interpreters/ActionsVisitor.cpp
@@ -145,19 +145,19 @@ SetPtr makeExplicitSet(
 
     auto [right_arg_value, right_arg_type] = evaluateConstantExpression(right_arg, context);
 
-    std::function<size_t(const DataTypePtr &)> getTypeDepth;
-    getTypeDepth = [&getTypeDepth](const DataTypePtr & type) -> size_t
+    std::function<size_t(const DataTypePtr &)> get_type_depth;
+    get_type_depth = [&get_type_depth](const DataTypePtr & type) -> size_t
     {
         if (auto array_type = typeid_cast<const DataTypeArray *>(type.get()))
-            return 1 + getTypeDepth(array_type->getNestedType());
+            return 1 + get_type_depth(array_type->getNestedType());
         else if (auto tuple_type = typeid_cast<const DataTypeTuple *>(type.get()))
-            return 1 + (tuple_type->getElements().empty() ? 0 : getTypeDepth(tuple_type->getElements().at(0)));
+            return 1 + (tuple_type->getElements().empty() ? 0 : get_type_depth(tuple_type->getElements().at(0)));
 
         return 0;
     };
 
-    const size_t left_type_depth = getTypeDepth(left_arg_type);
-    const size_t right_type_depth = getTypeDepth(right_arg_type);
+    const size_t left_type_depth = get_type_depth(left_arg_type);
+    const size_t right_type_depth = get_type_depth(right_arg_type);
 
     auto throw_unsupported_type = [](const auto & type)
     {
diff --git a/dbms/src/Interpreters/ArrayJoinedColumnsVisitor.h b/dbms/src/Interpreters/ArrayJoinedColumnsVisitor.h
index 204e4324c53..d7c40278818 100644
--- a/dbms/src/Interpreters/ArrayJoinedColumnsVisitor.h
+++ b/dbms/src/Interpreters/ArrayJoinedColumnsVisitor.h
@@ -60,7 +60,7 @@ public:
 private:
     static void visit(const ASTSelectQuery & node, ASTPtr &, Data & data)
     {
-        ASTPtr array_join_expression_list = node.array_join_expression_list();
+        ASTPtr array_join_expression_list = node.arrayJoinExpressionList();
         if (!array_join_expression_list)
             throw Exception("Logical error: no ARRAY JOIN", ErrorCodes::LOGICAL_ERROR);
 
diff --git a/dbms/src/Interpreters/CatBoostModel.cpp b/dbms/src/Interpreters/CatBoostModel.cpp
index ca286aa5ab5..67251859298 100644
--- a/dbms/src/Interpreters/CatBoostModel.cpp
+++ b/dbms/src/Interpreters/CatBoostModel.cpp
@@ -31,39 +31,39 @@ struct CatBoostWrapperAPI
 {
     using ModelCalcerHandle = void;
 
-    ModelCalcerHandle * (* ModelCalcerCreate)();
+    ModelCalcerHandle * (* ModelCalcerCreate)(); // NOLINT
 
-    void (* ModelCalcerDelete)(ModelCalcerHandle * calcer);
+    void (* ModelCalcerDelete)(ModelCalcerHandle * calcer); // NOLINT
 
-    const char * (* GetErrorString)();
+    const char * (* GetErrorString)(); // NOLINT
 
-    bool (* LoadFullModelFromFile)(ModelCalcerHandle * calcer, const char * filename);
+    bool (* LoadFullModelFromFile)(ModelCalcerHandle * calcer, const char * filename); // NOLINT
 
-    bool (* CalcModelPredictionFlat)(ModelCalcerHandle * calcer, size_t docCount,
+    bool (* CalcModelPredictionFlat)(ModelCalcerHandle * calcer, size_t docCount, // NOLINT
                                      const float ** floatFeatures, size_t floatFeaturesSize,
                                      double * result, size_t resultSize);
 
-    bool (* CalcModelPrediction)(ModelCalcerHandle * calcer, size_t docCount,
+    bool (* CalcModelPrediction)(ModelCalcerHandle * calcer, size_t docCount, // NOLINT
                                  const float ** floatFeatures, size_t floatFeaturesSize,
                                  const char *** catFeatures, size_t catFeaturesSize,
                                  double * result, size_t resultSize);
 
-    bool (* CalcModelPredictionWithHashedCatFeatures)(ModelCalcerHandle * calcer, size_t docCount,
+    bool (* CalcModelPredictionWithHashedCatFeatures)(ModelCalcerHandle * calcer, size_t docCount, // NOLINT
                                                       const float ** floatFeatures, size_t floatFeaturesSize,
                                                       const int ** catFeatures, size_t catFeaturesSize,
                                                       double * result, size_t resultSize);
 
-    int (* GetStringCatFeatureHash)(const char * data, size_t size);
-    int (* GetIntegerCatFeatureHash)(uint64_t val);
+    int (* GetStringCatFeatureHash)(const char * data, size_t size); // NOLINT
+    int (* GetIntegerCatFeatureHash)(uint64_t val); // NOLINT
 
-    size_t (* GetFloatFeaturesCount)(ModelCalcerHandle* calcer);
-    size_t (* GetCatFeaturesCount)(ModelCalcerHandle* calcer);
-    size_t (* GetTreeCount)(ModelCalcerHandle* modelHandle);
-    size_t (* GetDimensionsCount)(ModelCalcerHandle* modelHandle);
+    size_t (* GetFloatFeaturesCount)(ModelCalcerHandle* calcer); // NOLINT
+    size_t (* GetCatFeaturesCount)(ModelCalcerHandle* calcer); // NOLINT
+    size_t (* GetTreeCount)(ModelCalcerHandle* modelHandle); // NOLINT
+    size_t (* GetDimensionsCount)(ModelCalcerHandle* modelHandle); // NOLINT
 
-    bool (* CheckModelMetadataHasKey)(ModelCalcerHandle* modelHandle, const char* keyPtr, size_t keySize);
-    size_t (*GetModelInfoValueSize)(ModelCalcerHandle* modelHandle, const char* keyPtr, size_t keySize);
-    const char* (*GetModelInfoValue)(ModelCalcerHandle* modelHandle, const char* keyPtr, size_t keySize);
+    bool (* CheckModelMetadataHasKey)(ModelCalcerHandle* modelHandle, const char* keyPtr, size_t keySize); // NOLINT
+    size_t (*GetModelInfoValueSize)(ModelCalcerHandle* modelHandle, const char* keyPtr, size_t keySize); // NOLINT
+    const char* (*GetModelInfoValue)(ModelCalcerHandle* modelHandle, const char* keyPtr, size_t keySize); // NOLINT
 };
 
 
@@ -88,25 +88,23 @@ class CatBoostModelImpl : public ICatBoostModel
 public:
     CatBoostModelImpl(const CatBoostWrapperAPI * api_, const std::string & model_path) : api(api_)
     {
-        auto handle_ = std::make_unique<CatBoostModelHolder>(api);
-        if (!handle_)
+        handle = std::make_unique<CatBoostModelHolder>(api);
+        if (!handle)
         {
             std::string msg = "Cannot create CatBoost model: ";
             throw Exception(msg + api->GetErrorString(), ErrorCodes::CANNOT_LOAD_CATBOOST_MODEL);
         }
-        if (!api->LoadFullModelFromFile(handle_->get(), model_path.c_str()))
+        if (!api->LoadFullModelFromFile(handle->get(), model_path.c_str()))
         {
             std::string msg = "Cannot load CatBoost model: ";
             throw Exception(msg + api->GetErrorString(), ErrorCodes::CANNOT_LOAD_CATBOOST_MODEL);
         }
 
-        float_features_count = api->GetFloatFeaturesCount(handle_->get());
-        cat_features_count = api->GetCatFeaturesCount(handle_->get());
+        float_features_count = api->GetFloatFeaturesCount(handle->get());
+        cat_features_count = api->GetCatFeaturesCount(handle->get());
         tree_count = 1;
         if (api->GetDimensionsCount)
-            tree_count = api->GetDimensionsCount(handle_->get());
-
-        handle = std::move(handle_);
+            tree_count = api->GetDimensionsCount(handle->get());
     }
 
     ColumnPtr evaluate(const ColumnRawPtrs & columns) const override
diff --git a/dbms/src/Interpreters/Context.cpp b/dbms/src/Interpreters/Context.cpp
index 6ca4b4a0a2e..91c40a4cb86 100644
--- a/dbms/src/Interpreters/Context.cpp
+++ b/dbms/src/Interpreters/Context.cpp
@@ -1048,13 +1048,13 @@ void Context::setCurrentQueryId(const String & query_id)
         random.words.b = thread_local_rng(); //-V656
 
         /// Use protected constructor.
-        struct qUUID : Poco::UUID
+        struct QueryUUID : Poco::UUID
         {
-            qUUID(const char * bytes, Poco::UUID::Version version)
+            QueryUUID(const char * bytes, Poco::UUID::Version version)
                 : Poco::UUID(bytes, version) {}
         };
 
-        query_id_to_set = qUUID(random.bytes, Poco::UUID::UUID_RANDOM).toString();
+        query_id_to_set = QueryUUID(random.bytes, Poco::UUID::UUID_RANDOM).toString();
     }
 
     client_info.current_query_id = query_id_to_set;
diff --git a/dbms/src/Interpreters/DatabaseCatalog.cpp b/dbms/src/Interpreters/DatabaseCatalog.cpp
index 129599f9714..281152bdfb3 100644
--- a/dbms/src/Interpreters/DatabaseCatalog.cpp
+++ b/dbms/src/Interpreters/DatabaseCatalog.cpp
@@ -147,7 +147,10 @@ DatabaseAndTable DatabaseCatalog::tryGetByUUID(const UUID & uuid) const
 }
 
 
-DatabaseAndTable  DatabaseCatalog::getTableImpl(const StorageID & table_id, const Context & local_context, std::optional<Exception> * exception) const
+DatabaseAndTable DatabaseCatalog::getTableImpl(
+    const StorageID & table_id,
+    const Context & local_context,
+    std::optional<Exception> * exception) const
 {
     if (!table_id)
     {
@@ -182,7 +185,7 @@ DatabaseAndTable  DatabaseCatalog::getTableImpl(const StorageID & table_id, cons
 
     DatabasePtr database;
     {
-        std::lock_guard _lock{databases_mutex};
+        std::lock_guard lock{databases_mutex};
         auto it = databases.find(table_id.getDatabaseName());
         if (databases.end() == it)
         {
diff --git a/dbms/src/Interpreters/ExpressionActions.cpp b/dbms/src/Interpreters/ExpressionActions.cpp
index 67899995c4a..a94638dd22c 100644
--- a/dbms/src/Interpreters/ExpressionActions.cpp
+++ b/dbms/src/Interpreters/ExpressionActions.cpp
@@ -958,8 +958,8 @@ std::string ExpressionActions::dumpActions() const
 
 void ExpressionActions::optimizeArrayJoin()
 {
-    const size_t NONE = actions.size();
-    size_t first_array_join = NONE;
+    const size_t none = actions.size();
+    size_t first_array_join = none;
 
     /// Columns that need to be evaluated for arrayJoin.
     /// Actions for adding them can not be moved to the left of the arrayJoin.
@@ -985,7 +985,7 @@ void ExpressionActions::optimizeArrayJoin()
         }
         else
         {
-            if (first_array_join == NONE)
+            if (first_array_join == none)
                 continue;
 
             needed = actions[i].getNeededColumns();
@@ -1002,7 +1002,7 @@ void ExpressionActions::optimizeArrayJoin()
 
         if (depends_on_array_join)
         {
-            if (first_array_join == NONE)
+            if (first_array_join == none)
                 first_array_join = i;
 
             if (!actions[i].result_name.empty())
diff --git a/dbms/src/Interpreters/ExpressionAnalyzer.cpp b/dbms/src/Interpreters/ExpressionAnalyzer.cpp
index 6361c1027ae..cad4b3bd188 100644
--- a/dbms/src/Interpreters/ExpressionAnalyzer.cpp
+++ b/dbms/src/Interpreters/ExpressionAnalyzer.cpp
@@ -163,7 +163,7 @@ void ExpressionAnalyzer::analyzeAggregation()
     if (select_query)
     {
         bool is_array_join_left;
-        ASTPtr array_join_expression_list = select_query->array_join_expression_list(is_array_join_left);
+        ASTPtr array_join_expression_list = select_query->arrayJoinExpressionList(is_array_join_left);
         if (array_join_expression_list)
         {
             getRootActionsNoMakeSet(array_join_expression_list, true, temp_actions, false);
@@ -468,7 +468,7 @@ bool SelectQueryExpressionAnalyzer::appendArrayJoin(ExpressionActionsChain & cha
     const auto * select_query = getSelectQuery();
 
     bool is_array_join_left;
-    ASTPtr array_join_expression_list = select_query->array_join_expression_list(is_array_join_left);
+    ASTPtr array_join_expression_list = select_query->arrayJoinExpressionList(is_array_join_left);
     if (!array_join_expression_list)
         return false;
 
@@ -962,7 +962,7 @@ ExpressionAnalysisResult::ExpressionAnalysisResult(
     bool finalized = false;
     size_t where_step_num = 0;
 
-    auto finalizeChain = [&](ExpressionActionsChain & chain)
+    auto finalize_chain = [&](ExpressionActionsChain & chain)
     {
         if (!finalized)
         {
@@ -977,7 +977,7 @@ ExpressionAnalysisResult::ExpressionAnalysisResult(
         ExpressionActionsChain chain(context);
         Names additional_required_columns_after_prewhere;
 
-        if (storage && (query.sample_size() || settings.parallel_replicas_count > 1))
+        if (storage && (query.sampleSize() || settings.parallel_replicas_count > 1))
         {
             Names columns_for_sampling = storage->getColumnsRequiredForSampling();
             additional_required_columns_after_prewhere.insert(additional_required_columns_after_prewhere.end(),
@@ -1056,7 +1056,7 @@ ExpressionAnalysisResult::ExpressionAnalysisResult(
             query_analyzer.appendAggregateFunctionsArguments(chain, only_types || !first_stage);
             before_aggregation = chain.getLastActions();
 
-            finalizeChain(chain);
+            finalize_chain(chain);
 
             if (query_analyzer.appendHaving(chain, only_types || !second_stage))
             {
@@ -1090,7 +1090,7 @@ ExpressionAnalysisResult::ExpressionAnalysisResult(
         query_analyzer.appendProjectResult(chain);
         final_projection = chain.getLastActions();
 
-        finalizeChain(chain);
+        finalize_chain(chain);
     }
 
     /// Before executing WHERE and HAVING, remove the extra columns from the block (mostly the aggregation keys).
diff --git a/dbms/src/Interpreters/ExpressionJIT.cpp b/dbms/src/Interpreters/ExpressionJIT.cpp
index 9b60323a885..1f6ac0a9926 100644
--- a/dbms/src/Interpreters/ExpressionJIT.cpp
+++ b/dbms/src/Interpreters/ExpressionJIT.cpp
@@ -528,27 +528,27 @@ bool LLVMFunction::hasInformationAboutMonotonicity() const
 
 LLVMFunction::Monotonicity LLVMFunction::getMonotonicityForRange(const IDataType & type, const Field & left, const Field & right) const
 {
-    const IDataType * type_ = &type;
-    Field left_ = left;
-    Field right_ = right;
+    const IDataType * type_ptr = &type;
+    Field left_mut = left;
+    Field right_mut = right;
     Monotonicity result(true, true, true);
     /// monotonicity is only defined for unary functions, so the chain must describe a sequence of nested calls
     for (size_t i = 0; i < originals.size(); ++i)
     {
-        Monotonicity m = originals[i]->getMonotonicityForRange(*type_, left_, right_);
+        Monotonicity m = originals[i]->getMonotonicityForRange(*type_ptr, left_mut, right_mut);
         if (!m.is_monotonic)
             return m;
         result.is_positive ^= !m.is_positive;
         result.is_always_monotonic &= m.is_always_monotonic;
         if (i + 1 < originals.size())
         {
-            if (left_ != Field())
-                applyFunction(*originals[i], left_);
-            if (right_ != Field())
-                applyFunction(*originals[i], right_);
+            if (left_mut != Field())
+                applyFunction(*originals[i], left_mut);
+            if (right_mut != Field())
+                applyFunction(*originals[i], right_mut);
             if (!m.is_positive)
-                std::swap(left_, right_);
-            type_ = originals[i]->getReturnType().get();
+                std::swap(left_mut, right_mut);
+            type_ptr = originals[i]->getReturnType().get();
         }
     }
     return result;
diff --git a/dbms/src/Interpreters/ExternalLoader.cpp b/dbms/src/Interpreters/ExternalLoader.cpp
index 471c88e0ecd..d9ea3d31cb9 100644
--- a/dbms/src/Interpreters/ExternalLoader.cpp
+++ b/dbms/src/Interpreters/ExternalLoader.cpp
@@ -621,7 +621,7 @@ public:
             for (const auto & name_and_info : infos)
             {
                 const auto & info = name_and_info.second;
-                if ((now >= info.next_update_time) && !info.is_loading() && info.loaded())
+                if ((now >= info.next_update_time) && !info.isLoading() && info.loaded())
                     should_update_map.emplace(info.object, info.failedToReload());
             }
         }
@@ -651,7 +651,7 @@ public:
             TimePoint now = std::chrono::system_clock::now();
             for (auto & [name, info] : infos)
             {
-                if ((now >= info.next_update_time) && !info.is_loading())
+                if ((now >= info.next_update_time) && !info.isLoading())
                 {
                     if (info.loaded())
                     {
@@ -693,23 +693,23 @@ private:
         bool loaded() const { return object != nullptr; }
         bool failed() const { return !object && exception; }
         bool loadedOrFailed() const { return loaded() || failed(); }
-        bool triedToLoad() const { return loaded() || failed() || is_loading(); }
+        bool triedToLoad() const { return loaded() || failed() || isLoading(); }
         bool failedToReload() const { return loaded() && exception != nullptr; }
-        bool is_loading() const { return loading_id > state_id; }
+        bool isLoading() const { return loading_id > state_id; }
 
         Status status() const
         {
             if (object)
-                return is_loading() ? Status::LOADED_AND_RELOADING : Status::LOADED;
+                return isLoading() ? Status::LOADED_AND_RELOADING : Status::LOADED;
             else if (exception)
-                return is_loading() ? Status::FAILED_AND_RELOADING : Status::FAILED;
+                return isLoading() ? Status::FAILED_AND_RELOADING : Status::FAILED;
             else
-                return is_loading() ? Status::LOADING : Status::NOT_LOADED;
+                return isLoading() ? Status::LOADING : Status::NOT_LOADED;
         }
 
         Duration loadingDuration() const
         {
-            if (is_loading())
+            if (isLoading())
                 return std::chrono::duration_cast<Duration>(std::chrono::system_clock::now() - loading_start_time);
             return std::chrono::duration_cast<Duration>(loading_end_time - loading_start_time);
         }
@@ -871,7 +871,7 @@ private:
 
     void startLoading(Info & info, bool forced_to_reload = false, size_t min_id_to_finish_loading_dependencies_ = 1)
     {
-        if (info.is_loading())
+        if (info.isLoading())
         {
             LOG_TRACE(log, "The object '" << info.name <<
                       "' is already being loaded, force = " << forced_to_reload << ".");
@@ -911,7 +911,7 @@ private:
 
     static void cancelLoading(Info & info)
     {
-        if (!info.is_loading())
+        if (!info.isLoading())
             return;
 
         /// In fact we cannot actually CANCEL the loading (because it's possibly already being performed in another thread).
@@ -972,7 +972,7 @@ private:
         Info * info = getInfo(name);
         /// We check here if this is exactly the same loading as we planned to perform.
         /// This check is necessary because the object could be removed or load with another config before this thread even starts.
-        if (!info || !info->is_loading() || (info->loading_id != loading_id))
+        if (!info || !info->isLoading() || (info->loading_id != loading_id))
             return {};
 
         min_id_to_finish_loading_dependencies[std::this_thread::get_id()] = min_id_to_finish_loading_dependencies_;
@@ -1040,7 +1040,7 @@ private:
             LOG_TRACE(log, "Next update time for '" << name << "' will not be set because this object was not found.");
             return;
         }
-        if (!info->is_loading())
+        if (!info->isLoading())
         {
             LOG_TRACE(log, "Next update time for '" << name << "' will not be set because this object is not currently loading.");
             return;
diff --git a/dbms/src/Interpreters/InternalTextLogsQueue.cpp b/dbms/src/Interpreters/InternalTextLogsQueue.cpp
index ef555f1b34f..a61b0d6dd9e 100644
--- a/dbms/src/Interpreters/InternalTextLogsQueue.cpp
+++ b/dbms/src/Interpreters/InternalTextLogsQueue.cpp
@@ -50,7 +50,8 @@ const char * InternalTextLogsQueue::getPriorityName(int priority)
 {
     /// See Poco::Message::Priority
 
-    static const char * PRIORITIES [] = {
+    static constexpr const char * const PRIORITIES[] =
+    {
         "Unknown",
         "Fatal",
         "Critical",
diff --git a/dbms/src/Interpreters/InterpreterSelectQuery.cpp b/dbms/src/Interpreters/InterpreterSelectQuery.cpp
index 8a5f3c1bcb7..9ac176f2608 100644
--- a/dbms/src/Interpreters/InterpreterSelectQuery.cpp
+++ b/dbms/src/Interpreters/InterpreterSelectQuery.cpp
@@ -322,7 +322,7 @@ InterpreterSelectQuery::InterpreterSelectQuery(
 
         if (!options.only_analyze)
         {
-            if (query.sample_size() && (input || input_pipe || !storage || !storage->supportsSampling()))
+            if (query.sampleSize() && (input || input_pipe || !storage || !storage->supportsSampling()))
                 throw Exception("Illegal SAMPLE: table doesn't support sampling", ErrorCodes::SAMPLING_NOT_SUPPORTED);
 
             if (query.final() && (input || input_pipe || !storage || !storage->supportsFinal()))
@@ -1063,7 +1063,7 @@ void InterpreterSelectQuery::executeFetchColumns(
     auto check_trivial_count_query = [&]() -> std::optional<AggregateDescription>
     {
         if (!settings.optimize_trivial_count_query || !syntax_analyzer_result->maybe_optimize_trivial_count || !storage
-            || query.sample_size() || query.sample_offset() || query.final() || query.prewhere() || query.where()
+            || query.sampleSize() || query.sampleOffset() || query.final() || query.prewhere() || query.where()
             || !query_analyzer->hasAggregation() || processing_stage != QueryProcessingStage::FetchColumns)
             return {};
 
diff --git a/dbms/src/Interpreters/JoinToSubqueryTransformVisitor.cpp b/dbms/src/Interpreters/JoinToSubqueryTransformVisitor.cpp
index 51e5ab44fc2..46cf3817720 100644
--- a/dbms/src/Interpreters/JoinToSubqueryTransformVisitor.cpp
+++ b/dbms/src/Interpreters/JoinToSubqueryTransformVisitor.cpp
@@ -507,7 +507,7 @@ public:
 private:
     std::unordered_map<String, String> long_to_short;
 
-    String generateUniqueName(const String & long_name)
+    static String generateUniqueName(const String & long_name)
     {
         return String(pattern) + long_name;
     }
diff --git a/dbms/src/Interpreters/PredicateExpressionsOptimizer.cpp b/dbms/src/Interpreters/PredicateExpressionsOptimizer.cpp
index 8791008ac09..d2f38b85b4b 100644
--- a/dbms/src/Interpreters/PredicateExpressionsOptimizer.cpp
+++ b/dbms/src/Interpreters/PredicateExpressionsOptimizer.cpp
@@ -34,7 +34,7 @@ bool PredicateExpressionsOptimizer::optimize(ASTSelectQuery & select_query)
     if (!select_query.tables() || select_query.tables()->children.empty())
         return false;
 
-    if ((!select_query.where() && !select_query.prewhere()) || select_query.array_join_expression_list())
+    if ((!select_query.where() && !select_query.prewhere()) || select_query.arrayJoinExpressionList())
         return false;
 
     const auto & tables_predicates = extractTablesPredicates(select_query.where(), select_query.prewhere());
diff --git a/dbms/src/Interpreters/SyntaxAnalyzer.cpp b/dbms/src/Interpreters/SyntaxAnalyzer.cpp
index 855ff298f9a..099513ed098 100644
--- a/dbms/src/Interpreters/SyntaxAnalyzer.cpp
+++ b/dbms/src/Interpreters/SyntaxAnalyzer.cpp
@@ -437,7 +437,7 @@ void optimizeIf(ASTPtr & query, Aliases & aliases, bool if_chain_to_miltiif)
 void getArrayJoinedColumns(ASTPtr & query, SyntaxAnalyzerResult & result, const ASTSelectQuery * select_query,
                            const NamesAndTypesList & source_columns, const NameSet & source_columns_set)
 {
-    if (ASTPtr array_join_expression_list = select_query->array_join_expression_list())
+    if (ASTPtr array_join_expression_list = select_query->arrayJoinExpressionList())
     {
         ArrayJoinedColumnsVisitor::Data visitor_data{result.aliases,
                                                     result.array_join_name_to_alias,
@@ -449,7 +449,7 @@ void getArrayJoinedColumns(ASTPtr & query, SyntaxAnalyzerResult & result, const
         /// to get the correct number of rows.
         if (result.array_join_result_to_source.empty())
         {
-            ASTPtr expr = select_query->array_join_expression_list()->children.at(0);
+            ASTPtr expr = select_query->arrayJoinExpressionList()->children.at(0);
             String source_name = expr->getColumnName();
             String result_name = expr->getAliasOrColumnName();
 
diff --git a/dbms/src/Interpreters/evaluateConstantExpression.cpp b/dbms/src/Interpreters/evaluateConstantExpression.cpp
index 2834939407d..2372c247072 100644
--- a/dbms/src/Interpreters/evaluateConstantExpression.cpp
+++ b/dbms/src/Interpreters/evaluateConstantExpression.cpp
@@ -275,21 +275,21 @@ std::optional<Blocks> evaluateExpressionOverConstantCondition(const ASTPtr & nod
             return {};
         }
 
-        auto hasRequiredColumns = [&target_expr](const Block & block) -> bool
+        auto has_required_columns = [&target_expr](const Block & block) -> bool
         {
             for (const auto & name : target_expr->getRequiredColumns())
             {
-                bool hasColumn = false;
+                bool has_column = false;
                 for (const auto & column_name : block.getNames())
                 {
                     if (column_name == name)
                     {
-                        hasColumn = true;
+                        has_column = true;
                         break;
                     }
                 }
 
-                if (!hasColumn)
+                if (!has_column)
                     return false;
             }
 
@@ -301,7 +301,7 @@ std::optional<Blocks> evaluateExpressionOverConstantCondition(const ASTPtr & nod
             Block block(conjunct);
 
             // Block should contain all required columns from `target_expr`
-            if (!hasRequiredColumns(block))
+            if (!has_required_columns(block))
             {
                 return {};
             }
diff --git a/dbms/src/Interpreters/tests/hash_map.cpp b/dbms/src/Interpreters/tests/hash_map.cpp
index bc35bea16bb..8ddbd3b5886 100644
--- a/dbms/src/Interpreters/tests/hash_map.cpp
+++ b/dbms/src/Interpreters/tests/hash_map.cpp
@@ -67,7 +67,7 @@ struct AlternativeHash
 
 #if defined(__x86_64__)
 
-struct CRC32Hash_
+struct CRC32HashTest
 {
     size_t operator() (UInt64 x) const
     {
@@ -215,7 +215,7 @@ int main(int argc, char ** argv)
     {
         Stopwatch watch;
 
-        using Map = HashMap<Key, Value, CRC32Hash_>;
+        using Map = HashMap<Key, Value, CRC32HashTest>;
         Map map;
         Map::LookupResult it;
         bool inserted;
diff --git a/dbms/src/Parsers/ASTSelectQuery.cpp b/dbms/src/Parsers/ASTSelectQuery.cpp
index 977bb8849db..6a88700e3b8 100644
--- a/dbms/src/Parsers/ASTSelectQuery.cpp
+++ b/dbms/src/Parsers/ASTSelectQuery.cpp
@@ -249,7 +249,7 @@ static const ASTTablesInSelectQueryElement * getFirstTableJoin(const ASTSelectQu
 }
 
 
-ASTPtr ASTSelectQuery::sample_size() const
+ASTPtr ASTSelectQuery::sampleSize() const
 {
     const ASTTableExpression * table_expression = getFirstTableExpression(*this);
     if (!table_expression)
@@ -259,7 +259,7 @@ ASTPtr ASTSelectQuery::sample_size() const
 }
 
 
-ASTPtr ASTSelectQuery::sample_offset() const
+ASTPtr ASTSelectQuery::sampleOffset() const
 {
     const ASTTableExpression * table_expression = getFirstTableExpression(*this);
     if (!table_expression)
@@ -291,7 +291,7 @@ bool ASTSelectQuery::withFill() const
 }
 
 
-ASTPtr ASTSelectQuery::array_join_expression_list(bool & is_left) const
+ASTPtr ASTSelectQuery::arrayJoinExpressionList(bool & is_left) const
 {
     const ASTArrayJoin * array_join = getFirstArrayJoin(*this);
     if (!array_join)
@@ -302,10 +302,10 @@ ASTPtr ASTSelectQuery::array_join_expression_list(bool & is_left) const
 }
 
 
-ASTPtr ASTSelectQuery::array_join_expression_list() const
+ASTPtr ASTSelectQuery::arrayJoinExpressionList() const
 {
     bool is_left;
-    return array_join_expression_list(is_left);
+    return arrayJoinExpressionList(is_left);
 }
 
 
diff --git a/dbms/src/Parsers/ASTSelectQuery.h b/dbms/src/Parsers/ASTSelectQuery.h
index 309802e8c60..480e6bd63e2 100644
--- a/dbms/src/Parsers/ASTSelectQuery.h
+++ b/dbms/src/Parsers/ASTSelectQuery.h
@@ -78,10 +78,10 @@ public:
     }
 
     /// Compatibility with old parser of tables list. TODO remove
-    ASTPtr sample_size() const;
-    ASTPtr sample_offset() const;
-    ASTPtr array_join_expression_list(bool & is_left) const;
-    ASTPtr array_join_expression_list() const;
+    ASTPtr sampleSize() const;
+    ASTPtr sampleOffset() const;
+    ASTPtr arrayJoinExpressionList(bool & is_left) const;
+    ASTPtr arrayJoinExpressionList() const;
     const ASTTablesInSelectQueryElement * join() const;
     bool final() const;
     bool withFill() const;
diff --git a/dbms/src/Parsers/Lexer.cpp b/dbms/src/Parsers/Lexer.cpp
index 76fdb612bca..c5017870d82 100644
--- a/dbms/src/Parsers/Lexer.cpp
+++ b/dbms/src/Parsers/Lexer.cpp
@@ -65,7 +65,7 @@ Token Lexer::nextTokenImpl()
 
     const char * const token_begin = pos;
 
-    auto commentUntilEndOfLine = [&]() mutable
+    auto comment_until_end_of_line = [&]() mutable
     {
         pos = find_first_symbols<'\n'>(pos, end);    /// This means that newline in single-line comment cannot be escaped.
         return Token(TokenType::Comment, token_begin, pos);
@@ -225,7 +225,7 @@ Token Lexer::nextTokenImpl()
             if (pos < end && *pos == '-')
             {
                 ++pos;
-                return commentUntilEndOfLine();
+                return comment_until_end_of_line();
             }
 
             return Token(TokenType::Minus, token_begin, pos);
@@ -241,7 +241,7 @@ Token Lexer::nextTokenImpl()
                 if (*pos == '/')
                 {
                     ++pos;
-                    return commentUntilEndOfLine();
+                    return comment_until_end_of_line();
                 }
                 else
                 {
diff --git a/dbms/src/Processors/Executors/PipelineExecutor.cpp b/dbms/src/Processors/Executors/PipelineExecutor.cpp
index ea7478e3f80..4295012f8b2 100644
--- a/dbms/src/Processors/Executors/PipelineExecutor.cpp
+++ b/dbms/src/Processors/Executors/PipelineExecutor.cpp
@@ -45,7 +45,7 @@ PipelineExecutor::PipelineExecutor(Processors & processors_, QueryStatus * elem)
 
 bool PipelineExecutor::addEdges(UInt64 node)
 {
-    auto throwUnknownProcessor = [](const IProcessor * proc, const IProcessor * parent, bool from_input_port)
+    auto throw_unknown_processor = [](const IProcessor * proc, const IProcessor * parent, bool from_input_port)
     {
         String msg = "Processor " + proc->getName() + " was found as " + (from_input_port ? "input" : "output")
                      + " for processor " + parent->getName() + ", but not found in list of processors.";
@@ -61,7 +61,7 @@ bool PipelineExecutor::addEdges(UInt64 node)
     {
         auto it = processors_map.find(to_proc);
         if (it == processors_map.end())
-            throwUnknownProcessor(to_proc, cur, true);
+            throw_unknown_processor(to_proc, cur, true);
 
         UInt64 proc_num = it->second;
         auto & edge = edges.emplace_back(proc_num, is_backward, input_port_number, output_port_number, update_list);
diff --git a/dbms/src/Processors/Formats/Impl/CapnProtoRowInputFormat.cpp b/dbms/src/Processors/Formats/Impl/CapnProtoRowInputFormat.cpp
index 597410f7c01..5c758624d84 100644
--- a/dbms/src/Processors/Formats/Impl/CapnProtoRowInputFormat.cpp
+++ b/dbms/src/Processors/Formats/Impl/CapnProtoRowInputFormat.cpp
@@ -65,10 +65,10 @@ static Field convertNodeToField(const capnp::DynamicValue::Reader & value)
         }
         case capnp::DynamicValue::LIST:
         {
-            auto listValue = value.as<capnp::DynamicList>();
-            Array res(listValue.size());
-            for (auto i : kj::indices(listValue))
-                res[i] = convertNodeToField(listValue[i]);
+            auto list_value = value.as<capnp::DynamicList>();
+            Array res(list_value.size());
+            for (auto i : kj::indices(list_value))
+                res[i] = convertNodeToField(list_value[i]);
 
             return res;
         }
@@ -76,12 +76,12 @@ static Field convertNodeToField(const capnp::DynamicValue::Reader & value)
             return value.as<capnp::DynamicEnum>().getRaw();
         case capnp::DynamicValue::STRUCT:
         {
-            auto structValue = value.as<capnp::DynamicStruct>();
-            const auto & fields = structValue.getSchema().getFields();
+            auto struct_value = value.as<capnp::DynamicStruct>();
+            const auto & fields = struct_value.getSchema().getFields();
 
             Tuple tuple(fields.size());
             for (auto i : kj::indices(fields))
-                tuple[i] = convertNodeToField(structValue.get(fields[i]));
+                tuple[i] = convertNodeToField(struct_value.get(fields[i]));
 
             return tuple;
         }
diff --git a/dbms/src/Processors/Formats/Impl/PrettyBlockOutputFormat.cpp b/dbms/src/Processors/Formats/Impl/PrettyBlockOutputFormat.cpp
index 048e9f23e4e..a816cdd5318 100644
--- a/dbms/src/Processors/Formats/Impl/PrettyBlockOutputFormat.cpp
+++ b/dbms/src/Processors/Formats/Impl/PrettyBlockOutputFormat.cpp
@@ -53,8 +53,8 @@ void PrettyBlockOutputFormat::calculateWidths(
         for (size_t j = 0; j < num_rows; ++j)
         {
             {
-                WriteBufferFromString out_(serialized_value);
-                elem.type->serializeAsText(*column, j, out_, format_settings);
+                WriteBufferFromString out_serialize(serialized_value);
+                elem.type->serializeAsText(*column, j, out_serialize, format_settings);
             }
 
             widths[i][j] = std::min<UInt64>(format_settings.pretty.max_column_pad_width,
@@ -197,7 +197,7 @@ void PrettyBlockOutputFormat::write(const Chunk & chunk, PortKind port_kind)
 void PrettyBlockOutputFormat::writeValueWithPadding(
         const IColumn & column, const IDataType & type, size_t row_num, size_t value_width, size_t pad_to_width)
 {
-    auto writePadding = [&]()
+    auto write_padding = [&]()
     {
         for (size_t k = 0; k < pad_to_width - value_width; ++k)
             writeChar(' ', out);
@@ -205,13 +205,13 @@ void PrettyBlockOutputFormat::writeValueWithPadding(
 
     if (type.shouldAlignRightInPrettyFormats())
     {
-        writePadding();
+        write_padding();
         type.serializeAsText(column, row_num, out, format_settings);
     }
     else
     {
         type.serializeAsText(column, row_num, out, format_settings);
-        writePadding();
+        write_padding();
     }
 }
 
diff --git a/dbms/src/Processors/Transforms/CreatingSetsTransform.cpp b/dbms/src/Processors/Transforms/CreatingSetsTransform.cpp
index 618f8d5f53d..79ceae64d92 100644
--- a/dbms/src/Processors/Transforms/CreatingSetsTransform.cpp
+++ b/dbms/src/Processors/Transforms/CreatingSetsTransform.cpp
@@ -140,7 +140,7 @@ void CreatingSetsTransform::work()
         started_cur_subquery = true;
     }
 
-    auto finishCurrentSubquery = [&]()
+    auto finish_current_subquery = [&]()
     {
         if (subquery.set)
             subquery.set->finishInsert();
@@ -166,7 +166,7 @@ void CreatingSetsTransform::work()
     auto block = subquery.source->read();
     if (!block)
     {
-        finishCurrentSubquery();
+        finish_current_subquery();
         return;
     }
 
@@ -198,7 +198,7 @@ void CreatingSetsTransform::work()
     if (done_with_set && done_with_join && done_with_table)
     {
         subquery.source->cancel(false);
-        finishCurrentSubquery();
+        finish_current_subquery();
     }
     else
         elapsed_nanoseconds += watch.elapsedNanoseconds();
diff --git a/dbms/src/Processors/tests/processors_test_aggregation.cpp b/dbms/src/Processors/tests/processors_test_aggregation.cpp
index 4af2cbfa2a3..70e2f43b31a 100644
--- a/dbms/src/Processors/tests/processors_test_aggregation.cpp
+++ b/dbms/src/Processors/tests/processors_test_aggregation.cpp
@@ -165,7 +165,7 @@ private:
 };
 
 template<typename TimeT = std::chrono::milliseconds>
-struct measure
+struct Measure
 {
     template<typename F, typename ...Args>
     static typename TimeT::rep execution(F&& func, Args&&... args)
@@ -371,7 +371,7 @@ try
             ThreadStatus cur_status;
 
             CurrentThread::attachToIfDetached(thread_group);
-            time = measure<>::execution(func, msg, num_threads, two_level, external);
+            time = Measure<>::execution(func, msg, num_threads, two_level, external);
         };
 
         std::thread thread(wrapper);
diff --git a/dbms/src/Processors/tests/processors_test_chain.cpp b/dbms/src/Processors/tests/processors_test_chain.cpp
index d6d10c56285..0fbd52eef39 100644
--- a/dbms/src/Processors/tests/processors_test_chain.cpp
+++ b/dbms/src/Processors/tests/processors_test_chain.cpp
@@ -109,7 +109,7 @@ private:
 };
 
 template<typename TimeT = std::chrono::milliseconds>
-struct measure
+struct Measure
 {
     template<typename F, typename ...Args>
     static typename TimeT::rep execution(F&& func, Args&&... args)
@@ -150,8 +150,8 @@ try
         executor.execute(num_threads);
     };
 
-    auto time_single = measure<>::execution(execute_chain, 1);
-    auto time_mt = measure<>::execution(execute_chain, 4);
+    auto time_single = Measure<>::execution(execute_chain, 1);
+    auto time_mt = Measure<>::execution(execute_chain, 4);
 
     std::cout << "Single Thread time: " << time_single << " ms.\n";
     std::cout << "Multiple Threads time: " << time_mt << " ms.\n";
diff --git a/dbms/src/Processors/tests/processors_test_expand_pipeline.cpp b/dbms/src/Processors/tests/processors_test_expand_pipeline.cpp
index 78fa0bee7dd..83ac2ed0168 100644
--- a/dbms/src/Processors/tests/processors_test_expand_pipeline.cpp
+++ b/dbms/src/Processors/tests/processors_test_expand_pipeline.cpp
@@ -232,7 +232,7 @@ private:
 
 
 template<typename TimeT = std::chrono::milliseconds>
-struct measure
+struct Measure
 {
     template<typename F, typename ...Args>
     static typename TimeT::rep execution(F&& func, Args&&... args)
@@ -270,8 +270,8 @@ try
 
     ThreadPool pool(4, 4, 10);
 
-    auto time_single = measure<>::execution(execute, "Single thread", 10, 1);
-    auto time_mt = measure<>::execution(execute, "Multiple threads", 10, 4);
+    auto time_single = Measure<>::execution(execute, "Single thread", 10, 1);
+    auto time_mt = Measure<>::execution(execute, "Multiple threads", 10, 4);
 
     std::cout << "Single Thread time: " << time_single << " ms.\n";
     std::cout << "Multiple Threads time:" << time_mt << " ms.\n";
diff --git a/dbms/src/Processors/tests/processors_test_merge.cpp b/dbms/src/Processors/tests/processors_test_merge.cpp
index 226b08ece09..41e4a591f41 100644
--- a/dbms/src/Processors/tests/processors_test_merge.cpp
+++ b/dbms/src/Processors/tests/processors_test_merge.cpp
@@ -244,7 +244,7 @@ private:
 };
 
 template<typename TimeT = std::chrono::milliseconds>
-struct measure
+struct Measure
 {
     template<typename F, typename ...Args>
     static typename TimeT::rep execution(F&& func, Args&&... args)
@@ -307,14 +307,14 @@ try
         executor.execute(num_threads);
     };
 
-    auto even_time_single = measure<>::execution(execute_chain, "Even distribution single thread", 0, 1, 2, 1);
-    auto even_time_mt = measure<>::execution(execute_chain, "Even distribution multiple threads", 0, 1, 2, 4);
+    auto even_time_single = Measure<>::execution(execute_chain, "Even distribution single thread", 0, 1, 2, 1);
+    auto even_time_mt = Measure<>::execution(execute_chain, "Even distribution multiple threads", 0, 1, 2, 4);
 
-    auto half_time_single = measure<>::execution(execute_chain, "Half distribution single thread", 0, 31, 62, 1);
-    auto half_time_mt = measure<>::execution(execute_chain, "Half distribution multiple threads", 0, 31, 62, 4);
+    auto half_time_single = Measure<>::execution(execute_chain, "Half distribution single thread", 0, 31, 62, 1);
+    auto half_time_mt = Measure<>::execution(execute_chain, "Half distribution multiple threads", 0, 31, 62, 4);
 
-    auto ordered_time_single = measure<>::execution(execute_chain, "Ordered distribution single thread", 0, 61, 122, 1);
-    auto ordered_time_mt = measure<>::execution(execute_chain, "Ordered distribution multiple threads", 0, 61, 122, 4);
+    auto ordered_time_single = Measure<>::execution(execute_chain, "Ordered distribution single thread", 0, 61, 122, 1);
+    auto ordered_time_mt = Measure<>::execution(execute_chain, "Ordered distribution multiple threads", 0, 61, 122, 4);
 
     std::cout << "Single Thread [0:60:3] [1:60:3] [2:60:3] time: " << even_time_single << " ms.\n";
     std::cout << "Multiple Threads [0:60:3] [1:60:3] [2:60:3] time:" << even_time_mt << " ms.\n";
diff --git a/dbms/src/Processors/tests/processors_test_merge_sorting_transform.cpp b/dbms/src/Processors/tests/processors_test_merge_sorting_transform.cpp
index 905d9936b0a..b9a0b0c4a5e 100644
--- a/dbms/src/Processors/tests/processors_test_merge_sorting_transform.cpp
+++ b/dbms/src/Processors/tests/processors_test_merge_sorting_transform.cpp
@@ -103,7 +103,7 @@ private:
 };
 
 template<typename TimeT = std::chrono::milliseconds>
-struct measure
+struct Measure
 {
     template<typename F, typename ...Args>
     static typename TimeT::rep execution(F&& func, Args&&... args)
@@ -179,7 +179,7 @@ try
             msg += ", " + toString(blocks_count) + " blocks per " + toString(source_block_size) + " numbers" +
                     ", no remerge and external sorts.";
 
-            Int64 time = measure<>::execution(execute_chain, msg,
+            Int64 time = Measure<>::execution(execute_chain, msg,
                                         source_block_size,
                                         blocks_count,
                                         max_merged_block_size,
@@ -202,7 +202,7 @@ try
             msg += ", " + toString(blocks_count) + " blocks per " + toString(source_block_size) + " numbers" +
                    ", with remerge, no external sorts.";
 
-            Int64 time = measure<>::execution(execute_chain, msg,
+            Int64 time = Measure<>::execution(execute_chain, msg,
                                               source_block_size,
                                               blocks_count,
                                               max_merged_block_size,
@@ -225,7 +225,7 @@ try
             msg += ", " + toString(blocks_count) + " blocks per " + toString(source_block_size) + " numbers" +
                    ", no remerge, with external sorts.";
 
-            Int64 time = measure<>::execution(execute_chain, msg,
+            Int64 time = Measure<>::execution(execute_chain, msg,
                                               source_block_size,
                                               blocks_count,
                                               max_merged_block_size,
diff --git a/dbms/src/Processors/tests/processors_test_merging_sorted_transform.cpp b/dbms/src/Processors/tests/processors_test_merging_sorted_transform.cpp
index f148d46bd19..71d282585fd 100644
--- a/dbms/src/Processors/tests/processors_test_merging_sorted_transform.cpp
+++ b/dbms/src/Processors/tests/processors_test_merging_sorted_transform.cpp
@@ -116,7 +116,7 @@ private:
 };
 
 template<typename TimeT = std::chrono::milliseconds>
-struct measure
+struct Measure
 {
     template<typename F, typename ...Args>
     static typename TimeT::rep execution(F&& func, Args&&... args)
@@ -180,14 +180,14 @@ try
         executor.execute(num_threads);
     };
 
-    auto even_time_single = measure<>::execution(execute_chain, "Even distribution single thread", 0, 1, 2, 1);
-    auto even_time_mt = measure<>::execution(execute_chain, "Even distribution multiple threads", 0, 1, 2, 4);
+    auto even_time_single = Measure<>::execution(execute_chain, "Even distribution single thread", 0, 1, 2, 1);
+    auto even_time_mt = Measure<>::execution(execute_chain, "Even distribution multiple threads", 0, 1, 2, 4);
 
-    auto half_time_single = measure<>::execution(execute_chain, "Half distribution single thread", 0, 31, 62, 1);
-    auto half_time_mt = measure<>::execution(execute_chain, "Half distribution multiple threads", 0, 31, 62, 4);
+    auto half_time_single = Measure<>::execution(execute_chain, "Half distribution single thread", 0, 31, 62, 1);
+    auto half_time_mt = Measure<>::execution(execute_chain, "Half distribution multiple threads", 0, 31, 62, 4);
 
-    auto ordered_time_single = measure<>::execution(execute_chain, "Ordered distribution single thread", 0, 61, 122, 1);
-    auto ordered_time_mt = measure<>::execution(execute_chain, "Ordered distribution multiple threads", 0, 61, 122, 4);
+    auto ordered_time_single = Measure<>::execution(execute_chain, "Ordered distribution single thread", 0, 61, 122, 1);
+    auto ordered_time_mt = Measure<>::execution(execute_chain, "Ordered distribution multiple threads", 0, 61, 122, 4);
 
     std::cout << "Single Thread [0:60:3] [1:60:3] [2:60:3] time: " << even_time_single << " ms.\n";
     std::cout << "Multiple Threads [0:60:3] [1:60:3] [2:60:3] time:" << even_time_mt << " ms.\n";
diff --git a/dbms/src/Storages/Kafka/KafkaBlockInputStream.cpp b/dbms/src/Storages/Kafka/KafkaBlockInputStream.cpp
index c1252086b1d..39f71912f8e 100644
--- a/dbms/src/Storages/Kafka/KafkaBlockInputStream.cpp
+++ b/dbms/src/Storages/Kafka/KafkaBlockInputStream.cpp
@@ -137,22 +137,22 @@ Block KafkaBlockInputStream::readImpl()
 
         buffer->storeLastReadMessageOffset();
 
-        auto _topic         = buffer->currentTopic();
-        auto _key           = buffer->currentKey();
-        auto _offset        = buffer->currentOffset();
-        auto _partition     = buffer->currentPartition();
-        auto _timestamp_raw = buffer->currentTimestamp();
-        auto _timestamp     = _timestamp_raw ? std::chrono::duration_cast<std::chrono::seconds>(_timestamp_raw->get_timestamp()).count()
+        auto topic         = buffer->currentTopic();
+        auto key           = buffer->currentKey();
+        auto offset        = buffer->currentOffset();
+        auto partition     = buffer->currentPartition();
+        auto timestamp_raw = buffer->currentTimestamp();
+        auto timestamp     = timestamp_raw ? std::chrono::duration_cast<std::chrono::seconds>(timestamp_raw->get_timestamp()).count()
                                                 : 0;
         for (size_t i = 0; i < new_rows; ++i)
         {
-            virtual_columns[0]->insert(_topic);
-            virtual_columns[1]->insert(_key);
-            virtual_columns[2]->insert(_offset);
-            virtual_columns[3]->insert(_partition);
-            if (_timestamp_raw)
+            virtual_columns[0]->insert(topic);
+            virtual_columns[1]->insert(key);
+            virtual_columns[2]->insert(offset);
+            virtual_columns[3]->insert(partition);
+            if (timestamp_raw)
             {
-                virtual_columns[4]->insert(_timestamp);
+                virtual_columns[4]->insert(timestamp);
             }
             else
             {
diff --git a/dbms/src/Storages/Kafka/KafkaBlockOutputStream.cpp b/dbms/src/Storages/Kafka/KafkaBlockOutputStream.cpp
index 33e5102b1dc..fe8aa207c93 100644
--- a/dbms/src/Storages/Kafka/KafkaBlockOutputStream.cpp
+++ b/dbms/src/Storages/Kafka/KafkaBlockOutputStream.cpp
@@ -26,7 +26,7 @@ void KafkaBlockOutputStream::writePrefix()
     if (!buffer)
         throw Exception("Failed to create Kafka producer!", ErrorCodes::CANNOT_CREATE_IO_BUFFER);
 
-    child = FormatFactory::instance().getOutput(storage.getFormatName(), *buffer, getHeader(), context, [this](const Columns & columns, size_t row){ buffer->count_row(columns, row); });
+    child = FormatFactory::instance().getOutput(storage.getFormatName(), *buffer, getHeader(), context, [this](const Columns & columns, size_t row){ buffer->countRow(columns, row); });
 }
 
 void KafkaBlockOutputStream::write(const Block & block)
diff --git a/dbms/src/Storages/Kafka/ReadBufferFromKafkaConsumer.cpp b/dbms/src/Storages/Kafka/ReadBufferFromKafkaConsumer.cpp
index 608d8ba2213..9455390c00b 100644
--- a/dbms/src/Storages/Kafka/ReadBufferFromKafkaConsumer.cpp
+++ b/dbms/src/Storages/Kafka/ReadBufferFromKafkaConsumer.cpp
@@ -94,7 +94,7 @@ ReadBufferFromKafkaConsumer::~ReadBufferFromKafkaConsumer()
 
 void ReadBufferFromKafkaConsumer::commit()
 {
-    auto PrintOffsets = [this] (const char * prefix, const cppkafka::TopicPartitionList & offsets)
+    auto print_offsets = [this] (const char * prefix, const cppkafka::TopicPartitionList & offsets)
     {
         for (const auto & topic_part : offsets)
         {
@@ -127,7 +127,7 @@ void ReadBufferFromKafkaConsumer::commit()
         }
     };
 
-    PrintOffsets("Polled offset", consumer->get_offsets_position(consumer->get_assignment()));
+    print_offsets("Polled offset", consumer->get_offsets_position(consumer->get_assignment()));
 
     if (hasMorePolledMessages())
     {
@@ -147,7 +147,7 @@ void ReadBufferFromKafkaConsumer::commit()
         LOG_TRACE(log,"Nothing to commit.");
     }
 
-    PrintOffsets("Committed offset", consumer->get_offsets_committed(consumer->get_assignment()));
+    print_offsets("Committed offset", consumer->get_offsets_committed(consumer->get_assignment()));
     offsets_stored = 0;
 
     stalled = false;
diff --git a/dbms/src/Storages/Kafka/WriteBufferToKafkaProducer.cpp b/dbms/src/Storages/Kafka/WriteBufferToKafkaProducer.cpp
index 8d6c1ae537f..2a497be96ed 100644
--- a/dbms/src/Storages/Kafka/WriteBufferToKafkaProducer.cpp
+++ b/dbms/src/Storages/Kafka/WriteBufferToKafkaProducer.cpp
@@ -49,7 +49,7 @@ WriteBufferToKafkaProducer::~WriteBufferToKafkaProducer()
     assert(rows == 0 && chunks.empty());
 }
 
-void WriteBufferToKafkaProducer::count_row(const Columns & columns, size_t current_row)
+void WriteBufferToKafkaProducer::countRow(const Columns & columns, size_t current_row)
 {
 
     if (++rows % max_rows == 0)
diff --git a/dbms/src/Storages/Kafka/WriteBufferToKafkaProducer.h b/dbms/src/Storages/Kafka/WriteBufferToKafkaProducer.h
index 731dc2dc69f..76859c4e33f 100644
--- a/dbms/src/Storages/Kafka/WriteBufferToKafkaProducer.h
+++ b/dbms/src/Storages/Kafka/WriteBufferToKafkaProducer.h
@@ -25,7 +25,7 @@ public:
         const Block & header);
     ~WriteBufferToKafkaProducer() override;
 
-    void count_row(const Columns & columns, size_t row);
+    void countRow(const Columns & columns, size_t row);
     void flush();
 
 private:
diff --git a/dbms/src/Storages/LiveView/StorageLiveView.cpp b/dbms/src/Storages/LiveView/StorageLiveView.cpp
index 29eb896bcee..049110a3294 100644
--- a/dbms/src/Storages/LiveView/StorageLiveView.cpp
+++ b/dbms/src/Storages/LiveView/StorageLiveView.cpp
@@ -127,8 +127,8 @@ MergeableBlocksPtr StorageLiveView::collectMergeableBlocks(const Context & conte
 Pipes StorageLiveView::blocksToPipes(BlocksPtrs blocks, Block & sample_block)
 {
     Pipes pipes;
-    for (auto & blocks_ : *blocks)
-        pipes.emplace_back(std::make_shared<BlocksSource>(std::make_shared<BlocksPtr>(blocks_), sample_block));
+    for (auto & blocks_for_source : *blocks)
+        pipes.emplace_back(std::make_shared<BlocksSource>(std::make_shared<BlocksPtr>(blocks_for_source), sample_block));
 
     return pipes;
 }
diff --git a/dbms/src/Storages/MergeTree/IMergedBlockOutputStream.h b/dbms/src/Storages/MergeTree/IMergedBlockOutputStream.h
index 3af1b53cd2a..ba04d7fa71b 100644
--- a/dbms/src/Storages/MergeTree/IMergedBlockOutputStream.h
+++ b/dbms/src/Storages/MergeTree/IMergedBlockOutputStream.h
@@ -29,7 +29,7 @@ protected:
 
     /// Remove all columns marked expired in data_part. Also, clears checksums
     /// and columns array. Return set of removed files names.
-    NameSet removeEmptyColumnsFromPart(
+    static NameSet removeEmptyColumnsFromPart(
         const MergeTreeDataPartPtr & data_part,
         NamesAndTypesList & columns,
         MergeTreeData::DataPart::Checksums & checksums);
diff --git a/dbms/src/Storages/MergeTree/MergeTreeBaseSelectProcessor.cpp b/dbms/src/Storages/MergeTree/MergeTreeBaseSelectProcessor.cpp
index f1d4f916473..2917b4e795b 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeBaseSelectProcessor.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreeBaseSelectProcessor.cpp
@@ -104,7 +104,7 @@ Chunk MergeTreeBaseSelectProcessor::readFromPartImpl()
     const MergeTreeIndexGranularity & index_granularity = task->data_part->index_granularity;
     const double min_filtration_ratio = 0.00001;
 
-    auto estimateNumRows = [current_preferred_block_size_bytes, current_max_block_size_rows,
+    auto estimate_num_rows = [current_preferred_block_size_bytes, current_max_block_size_rows,
         &index_granularity, current_preferred_max_column_in_block_size_bytes, min_filtration_ratio](
         MergeTreeReadTask & current_task, MergeTreeRangeReader & current_reader)
     {
@@ -139,7 +139,7 @@ Chunk MergeTreeBaseSelectProcessor::readFromPartImpl()
         return index_granularity.countMarksForRows(current_reader.currentMark(), rows_to_read, current_reader.numReadRowsInCurrentGranule());
     };
 
-    UInt64 recommended_rows = estimateNumRows(*task, task->range_reader);
+    UInt64 recommended_rows = estimate_num_rows(*task, task->range_reader);
     UInt64 rows_to_read = std::max(UInt64(1), std::min(current_max_block_size_rows, recommended_rows));
 
     auto read_result = task->range_reader.read(rows_to_read, task->mark_ranges);
diff --git a/dbms/src/Storages/MergeTree/MergeTreeDataMergerMutator.cpp b/dbms/src/Storages/MergeTree/MergeTreeDataMergerMutator.cpp
index 7857720f862..0f6bc4dbad2 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeDataMergerMutator.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreeDataMergerMutator.cpp
@@ -1053,7 +1053,7 @@ MergeTreeData::MutableDataPartPtr MergeTreeDataMergerMutator::mutatePartToTempor
     else /// TODO: check that we modify only non-key columns in this case.
     {
         /// We will modify only some of the columns. Other columns and key values can be copied as-is.
-        auto indices_to_recalc = getIndicesToRecalc(in, storage_from_source_part, updated_header.getNamesAndTypesList(), context);
+        auto indices_to_recalc = getIndicesToRecalculate(in, storage_from_source_part, updated_header.getNamesAndTypesList(), context);
 
         NameSet files_to_skip = collectFilesToSkip(updated_header, indices_to_recalc, mrk_extension);
         NameSet files_to_remove = collectFilesToRemove(source_part, for_file_renames, mrk_extension);
@@ -1341,7 +1341,7 @@ NamesAndTypesList MergeTreeDataMergerMutator::getColumnsForNewDataPart(
     MergeTreeData::DataPartPtr source_part,
     const Block & updated_header,
     NamesAndTypesList all_columns,
-    const MutationCommands & commands_for_removes) const
+    const MutationCommands & commands_for_removes)
 {
     NameSet removed_columns;
     for (const auto & command : commands_for_removes)
@@ -1371,7 +1371,7 @@ NamesAndTypesList MergeTreeDataMergerMutator::getColumnsForNewDataPart(
 }
 
 
-std::set<MergeTreeIndexPtr> MergeTreeDataMergerMutator::getIndicesToRecalc(
+std::set<MergeTreeIndexPtr> MergeTreeDataMergerMutator::getIndicesToRecalculate(
     BlockInputStreamPtr & input_stream,
     StoragePtr storage_from_source_part,
     const NamesAndTypesList & updated_columns,
@@ -1531,7 +1531,7 @@ void MergeTreeDataMergerMutator::mutateSomePartColumns(
 void MergeTreeDataMergerMutator::finalizeMutatedPart(
     const MergeTreeDataPartPtr & source_part,
     MergeTreeData::MutableDataPartPtr new_data_part,
-    bool need_remove_expired_values) const
+    bool need_remove_expired_values)
 {
     auto disk = new_data_part->disk;
     if (need_remove_expired_values)
diff --git a/dbms/src/Storages/MergeTree/MergeTreeDataMergerMutator.h b/dbms/src/Storages/MergeTree/MergeTreeDataMergerMutator.h
index 48aaab7c129..3d41ceee990 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeDataMergerMutator.h
+++ b/dbms/src/Storages/MergeTree/MergeTreeDataMergerMutator.h
@@ -154,17 +154,17 @@ private:
     static NameSet collectFilesToSkip(const Block & updated_header, const std::set<MergeTreeIndexPtr> & indices_to_recalc, const String & mrk_extension);
 
     /// Get the columns list of the resulting part in the same order as all_columns.
-    NamesAndTypesList getColumnsForNewDataPart(
+    static NamesAndTypesList getColumnsForNewDataPart(
         MergeTreeData::DataPartPtr source_part,
         const Block & updated_header,
         NamesAndTypesList all_columns,
-        const MutationCommands & commands_for_removes) const;
+        const MutationCommands & commands_for_removes);
 
     bool shouldExecuteTTL(const Names & columns, const MutationCommands & commands) const;
 
     /// Return set of indices which should be recalculated during mutation also
     /// wraps input stream into additional expression stream
-    std::set<MergeTreeIndexPtr> getIndicesToRecalc(
+    std::set<MergeTreeIndexPtr> getIndicesToRecalculate(
         BlockInputStreamPtr & input_stream,
         StoragePtr storage_from_source_part,
         const NamesAndTypesList & updated_columns,
@@ -193,10 +193,10 @@ private:
 
     /// Initialize and write to disk new part fields like checksums, columns,
     /// etc.
-    void finalizeMutatedPart(
+    static void finalizeMutatedPart(
         const MergeTreeDataPartPtr & source_part,
         MergeTreeData::MutableDataPartPtr new_data_part,
-        bool need_remove_expired_values) const;
+        bool need_remove_expired_values);
 
 public :
     /** Is used to cancel all merges and mutations. On cancel() call all currently running actions will throw exception soon.
diff --git a/dbms/src/Storages/MergeTree/MergeTreeDataPartChecksum.cpp b/dbms/src/Storages/MergeTree/MergeTreeDataPartChecksum.cpp
index a136649e698..7bf52ee19d1 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeDataPartChecksum.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreeDataPartChecksum.cpp
@@ -101,11 +101,11 @@ bool MergeTreeDataPartChecksums::read(ReadBuffer & in, size_t format_version)
         case 1:
             return false;
         case 2:
-            return read_v2(in);
+            return readV2(in);
         case 3:
-            return read_v3(in);
+            return readV3(in);
         case 4:
-            return read_v4(in);
+            return readV4(in);
         default:
             throw Exception("Bad checksums format version: " + DB::toString(format_version), ErrorCodes::UNKNOWN_FORMAT);
     }
@@ -124,7 +124,7 @@ bool MergeTreeDataPartChecksums::read(ReadBuffer & in)
     return true;
 }
 
-bool MergeTreeDataPartChecksums::read_v2(ReadBuffer & in)
+bool MergeTreeDataPartChecksums::readV2(ReadBuffer & in)
 {
     size_t count;
 
@@ -162,7 +162,7 @@ bool MergeTreeDataPartChecksums::read_v2(ReadBuffer & in)
     return true;
 }
 
-bool MergeTreeDataPartChecksums::read_v3(ReadBuffer & in)
+bool MergeTreeDataPartChecksums::readV3(ReadBuffer & in)
 {
     size_t count;
 
@@ -190,10 +190,10 @@ bool MergeTreeDataPartChecksums::read_v3(ReadBuffer & in)
     return true;
 }
 
-bool MergeTreeDataPartChecksums::read_v4(ReadBuffer & from)
+bool MergeTreeDataPartChecksums::readV4(ReadBuffer & from)
 {
     CompressedReadBuffer in{from};
-    return read_v3(in);
+    return readV3(in);
 }
 
 void MergeTreeDataPartChecksums::write(WriteBuffer & to) const
@@ -372,29 +372,29 @@ void MinimalisticDataPartChecksums::computeTotalChecksums(const MergeTreeDataPar
     num_compressed_files = 0;
     num_uncompressed_files = 0;
 
-    SipHash hash_of_all_files_;
-    SipHash hash_of_uncompressed_files_;
-    SipHash uncompressed_hash_of_compressed_files_;
+    SipHash hash_of_all_files_state;
+    SipHash hash_of_uncompressed_files_state;
+    SipHash uncompressed_hash_of_compressed_files_state;
 
     for (const auto & elem : full_checksums_.files)
     {
         const String & name = elem.first;
         const auto & checksum = elem.second;
 
-        updateHash(hash_of_all_files_, name);
-        hash_of_all_files_.update(checksum.file_hash);
+        updateHash(hash_of_all_files_state, name);
+        hash_of_all_files_state.update(checksum.file_hash);
 
         if (!checksum.is_compressed)
         {
             ++num_uncompressed_files;
-            updateHash(hash_of_uncompressed_files_, name);
-            hash_of_uncompressed_files_.update(checksum.file_hash);
+            updateHash(hash_of_uncompressed_files_state, name);
+            hash_of_uncompressed_files_state.update(checksum.file_hash);
         }
         else
         {
             ++num_compressed_files;
-            updateHash(uncompressed_hash_of_compressed_files_, name);
-            uncompressed_hash_of_compressed_files_.update(checksum.uncompressed_hash);
+            updateHash(uncompressed_hash_of_compressed_files_state, name);
+            uncompressed_hash_of_compressed_files_state.update(checksum.uncompressed_hash);
         }
     }
 
@@ -403,9 +403,9 @@ void MinimalisticDataPartChecksums::computeTotalChecksums(const MergeTreeDataPar
         hash.get128(data.first, data.second);
     };
 
-    get_hash(hash_of_all_files_, hash_of_all_files);
-    get_hash(hash_of_uncompressed_files_, hash_of_uncompressed_files);
-    get_hash(uncompressed_hash_of_compressed_files_, uncompressed_hash_of_compressed_files);
+    get_hash(hash_of_all_files_state, hash_of_all_files);
+    get_hash(hash_of_uncompressed_files_state, hash_of_uncompressed_files);
+    get_hash(uncompressed_hash_of_compressed_files_state, uncompressed_hash_of_compressed_files);
 }
 
 String MinimalisticDataPartChecksums::getSerializedString(const MergeTreeDataPartChecksums & full_checksums, bool minimalistic)
diff --git a/dbms/src/Storages/MergeTree/MergeTreeDataPartChecksum.h b/dbms/src/Storages/MergeTree/MergeTreeDataPartChecksum.h
index 184d01c9985..a4eae3cc0e5 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeDataPartChecksum.h
+++ b/dbms/src/Storages/MergeTree/MergeTreeDataPartChecksum.h
@@ -71,9 +71,9 @@ struct MergeTreeDataPartChecksums
     bool read(ReadBuffer & in);
     /// Assume that header with version (the first line) is read
     bool read(ReadBuffer & in, size_t format_version);
-    bool read_v2(ReadBuffer & in);
-    bool read_v3(ReadBuffer & in);
-    bool read_v4(ReadBuffer & from);
+    bool readV2(ReadBuffer & in);
+    bool readV3(ReadBuffer & in);
+    bool readV4(ReadBuffer & from);
 
     void write(WriteBuffer & to) const;
 
diff --git a/dbms/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp b/dbms/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp
index 0b87b241d85..629a2b2cc18 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp
@@ -300,8 +300,8 @@ Pipes MergeTreeDataSelectExecutor::readFromParts(
 
     const auto & select = query_info.query->as<ASTSelectQuery &>();
 
-    auto select_sample_size = select.sample_size();
-    auto select_sample_offset = select.sample_offset();
+    auto select_sample_size = select.sampleSize();
+    auto select_sample_offset = select.sampleOffset();
 
     if (select_sample_size)
     {
diff --git a/dbms/src/Storages/MergeTree/MergeTreeIndexConditionBloomFilter.cpp b/dbms/src/Storages/MergeTree/MergeTreeIndexConditionBloomFilter.cpp
index acabb7130cc..88e3fc6662a 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeIndexConditionBloomFilter.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreeIndexConditionBloomFilter.cpp
@@ -85,8 +85,8 @@ MergeTreeIndexConditionBloomFilter::MergeTreeIndexConditionBloomFilter(
     const SelectQueryInfo & info_, const Context & context_, const Block & header_, size_t hash_functions_)
     : header(header_), context(context_), query_info(info_), hash_functions(hash_functions_)
 {
-    auto atomFromAST = [this](auto & node, auto &, auto & constants, auto & out) { return traverseAtomAST(node, constants, out); };
-    rpn = std::move(RPNBuilder<RPNElement>(info_, context, atomFromAST).extractRPN());
+    auto atom_from_ast = [this](auto & node, auto &, auto & constants, auto & out) { return traverseAtomAST(node, constants, out); };
+    rpn = std::move(RPNBuilder<RPNElement>(info_, context, atom_from_ast).extractRPN());
 }
 
 bool MergeTreeIndexConditionBloomFilter::alwaysUnknownOrTrue() const
diff --git a/dbms/src/Storages/MergeTree/MergeTreeReaderCompact.cpp b/dbms/src/Storages/MergeTree/MergeTreeReaderCompact.cpp
index 9dd4ff4097b..496371b6e4b 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeReaderCompact.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreeReaderCompact.cpp
@@ -15,18 +15,18 @@ namespace ErrorCodes
 
 
 MergeTreeReaderCompact::MergeTreeReaderCompact(
-    const DataPartCompactPtr & data_part_,
-    const NamesAndTypesList & columns_,
+    DataPartCompactPtr data_part_,
+    NamesAndTypesList columns_,
     UncompressedCache * uncompressed_cache_,
     MarkCache * mark_cache_,
-    const MarkRanges & mark_ranges_,
-    const MergeTreeReaderSettings & settings_,
-    const ValueSizeMap & avg_value_size_hints_,
+    MarkRanges mark_ranges_,
+    MergeTreeReaderSettings settings_,
+    ValueSizeMap avg_value_size_hints_,
     const ReadBufferFromFileBase::ProfileCallback & profile_callback_,
     clockid_t clock_type_)
-    : IMergeTreeReader(data_part_, columns_,
-        uncompressed_cache_, mark_cache_, mark_ranges_,
-        settings_, avg_value_size_hints_)
+    : IMergeTreeReader(std::move(data_part_), std::move(columns_),
+        uncompressed_cache_, mark_cache_, std::move(mark_ranges_),
+        std::move(settings_), std::move(avg_value_size_hints_))
     , marks_loader(
         data_part->disk,
         mark_cache,
diff --git a/dbms/src/Storages/MergeTree/MergeTreeReaderCompact.h b/dbms/src/Storages/MergeTree/MergeTreeReaderCompact.h
index efaf23d2988..827306cd983 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeReaderCompact.h
+++ b/dbms/src/Storages/MergeTree/MergeTreeReaderCompact.h
@@ -15,14 +15,14 @@ class MergeTreeReaderCompact : public IMergeTreeReader
 {
 public:
     MergeTreeReaderCompact(
-        const DataPartCompactPtr & data_part_,
-        const NamesAndTypesList & columns_,
+        DataPartCompactPtr data_part_,
+        NamesAndTypesList columns_,
         UncompressedCache * uncompressed_cache_,
         MarkCache * mark_cache_,
-        const MarkRanges & mark_ranges_,
-        const MergeTreeReaderSettings & settings_,
-        const ValueSizeMap & avg_value_size_hints_ = ValueSizeMap{},
-        const ReadBufferFromFileBase::ProfileCallback & profile_callback_ = ReadBufferFromFileBase::ProfileCallback{},
+        MarkRanges mark_ranges_,
+        MergeTreeReaderSettings settings_,
+        ValueSizeMap avg_value_size_hints_ = {},
+        const ReadBufferFromFileBase::ProfileCallback & profile_callback_ = {},
         clockid_t clock_type_ = CLOCK_MONOTONIC_COARSE);
 
     /// Return the number of rows has been read or zero if there is no columns to read.
diff --git a/dbms/src/Storages/MergeTree/MergeTreeReaderWide.cpp b/dbms/src/Storages/MergeTree/MergeTreeReaderWide.cpp
index f74c7fc920f..1f87f229cc5 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeReaderWide.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreeReaderWide.cpp
@@ -26,18 +26,18 @@ namespace ErrorCodes
 }
 
 MergeTreeReaderWide::MergeTreeReaderWide(
-    const DataPartWidePtr & data_part_,
-    const NamesAndTypesList & columns_,
+    DataPartWidePtr data_part_,
+    NamesAndTypesList columns_,
     UncompressedCache * uncompressed_cache_,
     MarkCache * mark_cache_,
-    const MarkRanges & mark_ranges_,
-    const MergeTreeReaderSettings & settings_,
-    const IMergeTreeDataPart::ValueSizeMap & avg_value_size_hints_,
+    MarkRanges mark_ranges_,
+    MergeTreeReaderSettings settings_,
+    IMergeTreeDataPart::ValueSizeMap avg_value_size_hints_,
     const ReadBufferFromFileBase::ProfileCallback & profile_callback_,
     clockid_t clock_type_)
     : IMergeTreeReader(
-        data_part_, columns_, uncompressed_cache_, mark_cache_,
-        mark_ranges_, settings_, avg_value_size_hints_)
+        std::move(data_part_), std::move(columns_), uncompressed_cache_, std::move(mark_cache_),
+        std::move(mark_ranges_), std::move(settings_), std::move(avg_value_size_hints_))
 {
     try
     {
diff --git a/dbms/src/Storages/MergeTree/MergeTreeReaderWide.h b/dbms/src/Storages/MergeTree/MergeTreeReaderWide.h
index 78d1a59fd89..7684d69f0a5 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeReaderWide.h
+++ b/dbms/src/Storages/MergeTree/MergeTreeReaderWide.h
@@ -15,14 +15,14 @@ class MergeTreeReaderWide : public IMergeTreeReader
 {
 public:
     MergeTreeReaderWide(
-        const DataPartWidePtr & data_part_,
-        const NamesAndTypesList & columns_,
+        DataPartWidePtr data_part_,
+        NamesAndTypesList columns_,
         UncompressedCache * uncompressed_cache_,
         MarkCache * mark_cache_,
-        const MarkRanges & mark_ranges_,
-        const MergeTreeReaderSettings & settings_,
-        const ValueSizeMap & avg_value_size_hints_ = ValueSizeMap{},
-        const ReadBufferFromFileBase::ProfileCallback & profile_callback_ = ReadBufferFromFileBase::ProfileCallback{},
+        MarkRanges mark_ranges_,
+        MergeTreeReaderSettings settings_,
+        ValueSizeMap avg_value_size_hints_ = {},
+        const ReadBufferFromFileBase::ProfileCallback & profile_callback_ = {},
         clockid_t clock_type_ = CLOCK_MONOTONIC_COARSE);
 
     /// Return the number of rows has been read or zero if there is no columns to read.
diff --git a/dbms/src/Storages/MergeTree/MergeTreeWhereOptimizer.cpp b/dbms/src/Storages/MergeTree/MergeTreeWhereOptimizer.cpp
index 8f8b5111f48..fa29494d1c9 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeWhereOptimizer.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreeWhereOptimizer.cpp
@@ -348,7 +348,7 @@ bool MergeTreeWhereOptimizer::cannotBeMoved(const ASTPtr & ptr) const
 
 void MergeTreeWhereOptimizer::determineArrayJoinedNames(ASTSelectQuery & select)
 {
-    auto array_join_expression_list = select.array_join_expression_list();
+    auto array_join_expression_list = select.arrayJoinExpressionList();
 
     /// much simplified code from ExpressionAnalyzer::getArrayJoinedColumns()
     if (!array_join_expression_list)
diff --git a/dbms/src/Storages/MergeTree/ReplicatedMergeTreeCleanupThread.cpp b/dbms/src/Storages/MergeTree/ReplicatedMergeTreeCleanupThread.cpp
index c4d55f2e26f..77a5bca7a92 100644
--- a/dbms/src/Storages/MergeTree/ReplicatedMergeTreeCleanupThread.cpp
+++ b/dbms/src/Storages/MergeTree/ReplicatedMergeTreeCleanupThread.cpp
@@ -28,7 +28,7 @@ ReplicatedMergeTreeCleanupThread::ReplicatedMergeTreeCleanupThread(StorageReplic
 void ReplicatedMergeTreeCleanupThread::run()
 {
     auto storage_settings = storage.getSettings();
-    const auto CLEANUP_SLEEP_MS = storage_settings->cleanup_delay_period * 1000
+    const auto sleep_ms = storage_settings->cleanup_delay_period * 1000
         + std::uniform_int_distribution<UInt64>(0, storage_settings->cleanup_delay_period_random_add * 1000)(rng);
 
     try
@@ -47,7 +47,7 @@ void ReplicatedMergeTreeCleanupThread::run()
         tryLogCurrentException(log, __PRETTY_FUNCTION__);
     }
 
-    task->scheduleAfter(CLEANUP_SLEEP_MS);
+    task->scheduleAfter(sleep_ms);
 }
 
 
diff --git a/dbms/src/Storages/MergeTree/ReplicatedMergeTreeQueue.cpp b/dbms/src/Storages/MergeTree/ReplicatedMergeTreeQueue.cpp
index 420b04df8bd..2cd6edae423 100644
--- a/dbms/src/Storages/MergeTree/ReplicatedMergeTreeQueue.cpp
+++ b/dbms/src/Storages/MergeTree/ReplicatedMergeTreeQueue.cpp
@@ -1578,7 +1578,7 @@ ReplicatedMergeTreeMergePredicate::ReplicatedMergeTreeMergePredicate(
         for (const String & partition : partitions)
             lock_futures.push_back(zookeeper->asyncGetChildren(queue.zookeeper_path + "/block_numbers/" + partition));
 
-        struct BlockInfo_
+        struct BlockInfoInZooKeeper
         {
             String partition;
             Int64 number;
@@ -1586,7 +1586,7 @@ ReplicatedMergeTreeMergePredicate::ReplicatedMergeTreeMergePredicate(
             std::future<Coordination::GetResponse> contents_future;
         };
 
-        std::vector<BlockInfo_> block_infos;
+        std::vector<BlockInfoInZooKeeper> block_infos;
         for (size_t i = 0; i < partitions.size(); ++i)
         {
             Strings partition_block_numbers = lock_futures[i].get().names;
@@ -1599,7 +1599,7 @@ ReplicatedMergeTreeMergePredicate::ReplicatedMergeTreeMergePredicate(
                     Int64 block_number = parse<Int64>(entry.substr(strlen("block-")));
                     String zk_path = queue.zookeeper_path + "/block_numbers/" + partitions[i] + "/" + entry;
                     block_infos.emplace_back(
-                        BlockInfo_{partitions[i], block_number, zk_path, zookeeper->asyncTryGet(zk_path)});
+                        BlockInfoInZooKeeper{partitions[i], block_number, zk_path, zookeeper->asyncTryGet(zk_path)});
                 }
             }
         }
diff --git a/dbms/src/Storages/MergeTree/ReplicatedMergeTreeQuorumAddedParts.h b/dbms/src/Storages/MergeTree/ReplicatedMergeTreeQuorumAddedParts.h
index 53fcc26d039..4f37ba95165 100644
--- a/dbms/src/Storages/MergeTree/ReplicatedMergeTreeQuorumAddedParts.h
+++ b/dbms/src/Storages/MergeTree/ReplicatedMergeTreeQuorumAddedParts.h
@@ -59,14 +59,14 @@ struct ReplicatedMergeTreeQuorumAddedParts
             assertChar('\n', in);
 
             if (version == 2)
-                added_parts = read_v2(in);
+                added_parts = readV2(in);
         }
         else
-            added_parts = read_v1(in);
+            added_parts = readV1(in);
     }
 
     /// Read added bloks when node in ZooKeeper supports only one partition.
-    PartitionIdToPartName read_v1(ReadBuffer & in)
+    PartitionIdToPartName readV1(ReadBuffer & in)
     {
         PartitionIdToPartName parts_in_quorum;
 
@@ -81,7 +81,7 @@ struct ReplicatedMergeTreeQuorumAddedParts
     }
 
     /// Read blocks when node in ZooKeeper suppors multiple partitions.
-    PartitionIdToPartName read_v2(ReadBuffer & in)
+    PartitionIdToPartName readV2(ReadBuffer & in)
     {
         assertString("parts count: ", in);
 
diff --git a/dbms/src/Storages/StorageFactory.cpp b/dbms/src/Storages/StorageFactory.cpp
index 1864ed4168e..9fb548c3893 100644
--- a/dbms/src/Storages/StorageFactory.cpp
+++ b/dbms/src/Storages/StorageFactory.cpp
@@ -123,7 +123,7 @@ StoragePtr StorageFactory::get(
                     throw Exception("Unknown table engine " + name, ErrorCodes::UNKNOWN_STORAGE);
             }
 
-            auto checkFeature = [&](String feature_description, FeatureMatcherFn feature_matcher_fn)
+            auto check_feature = [&](String feature_description, FeatureMatcherFn feature_matcher_fn)
             {
                 if (!feature_matcher_fn(it->second.features))
                 {
@@ -142,22 +142,22 @@ StoragePtr StorageFactory::get(
             };
 
             if (storage_def->settings)
-                checkFeature(
+                check_feature(
                     "SETTINGS clause",
                     [](StorageFeatures features) { return features.supports_settings; });
 
             if (storage_def->partition_by || storage_def->primary_key || storage_def->order_by || storage_def->sample_by)
-                checkFeature(
+                check_feature(
                     "PARTITION_BY, PRIMARY_KEY, ORDER_BY or SAMPLE_BY clauses",
                     [](StorageFeatures features) { return features.supports_sort_order; });
 
             if (storage_def->ttl_table || !columns.getColumnTTLs().empty())
-                checkFeature(
+                check_feature(
                     "TTL clause",
                     [](StorageFeatures features) { return features.supports_ttl; });
 
             if (query.columns_list && query.columns_list->indices && !query.columns_list->indices->children.empty())
-                checkFeature(
+                check_feature(
                     "skipping indices",
                     [](StorageFeatures features) { return features.supports_skipping_indices; });
         }
diff --git a/dbms/src/Storages/StorageFile.cpp b/dbms/src/Storages/StorageFile.cpp
index 92d9c3ccfe2..48341ce918d 100644
--- a/dbms/src/Storages/StorageFile.cpp
+++ b/dbms/src/Storages/StorageFile.cpp
@@ -386,8 +386,6 @@ Pipes StorageFile::read(
     size_t max_block_size,
     unsigned num_streams)
 {
-    const ColumnsDescription & columns_ = getColumns();
-    auto column_defaults = columns_.getDefaults();
     BlockInputStreams blocks_input;
 
     if (use_table_fd)   /// need to call ctr BlockInputStream
@@ -417,7 +415,8 @@ Pipes StorageFile::read(
     pipes.reserve(num_streams);
 
     for (size_t i = 0; i < num_streams; ++i)
-        pipes.emplace_back(std::make_shared<StorageFileSource>(this_ptr, context, max_block_size, files_info, column_defaults));
+        pipes.emplace_back(std::make_shared<StorageFileSource>(
+            this_ptr, context, max_block_size, files_info, getColumns().getDefaults()));
 
     return pipes;
 }
diff --git a/dbms/src/Storages/StorageGenerateRandom.cpp b/dbms/src/Storages/StorageGenerateRandom.cpp
index f2a67210f3f..1fd2d4ec2d8 100644
--- a/dbms/src/Storages/StorageGenerateRandom.cpp
+++ b/dbms/src/Storages/StorageGenerateRandom.cpp
@@ -416,11 +416,11 @@ Pipes StorageGenerateRandom::read(
     Pipes pipes;
     pipes.reserve(num_streams);
 
-    const ColumnsDescription & columns_ = getColumns();
+    const ColumnsDescription & our_columns = getColumns();
     Block block_header;
     for (const auto & name : column_names)
     {
-        const auto & name_type = columns_.get(name);
+        const auto & name_type = our_columns.get(name);
         MutableColumnPtr column = name_type.type->createColumn();
         block_header.insert({std::move(column), name_type.type, name_type.name});
     }
diff --git a/dbms/src/Storages/StorageLog.cpp b/dbms/src/Storages/StorageLog.cpp
index d908b9d459f..eb623561297 100644
--- a/dbms/src/Storages/StorageLog.cpp
+++ b/dbms/src/Storages/StorageLog.cpp
@@ -240,7 +240,7 @@ void LogSource::readData(const String & name, const IDataType & type, IColumn &
 {
     IDataType::DeserializeBinaryBulkSettings settings; /// TODO Use avg_value_size_hint.
 
-    auto createStringGetter = [&](bool stream_for_prefix)
+    auto create_string_getter = [&](bool stream_for_prefix)
     {
         return [&, stream_for_prefix] (const IDataType::SubstreamPath & path) -> ReadBuffer *
         {
@@ -262,11 +262,11 @@ void LogSource::readData(const String & name, const IDataType & type, IColumn &
 
     if (deserialize_states.count(name) == 0)
     {
-        settings.getter = createStringGetter(true);
+        settings.getter = create_string_getter(true);
         type.deserializeBinaryBulkStatePrefix(settings, deserialize_states[name]);
     }
 
-    settings.getter = createStringGetter(false);
+    settings.getter = create_string_getter(false);
     type.deserializeBinaryBulkWithMultipleStreams(column, max_rows_to_read, settings, deserialize_states[name]);
 }
 
diff --git a/dbms/src/Storages/StorageMaterializedView.cpp b/dbms/src/Storages/StorageMaterializedView.cpp
index da8b6bdfacd..e104dcd8edc 100644
--- a/dbms/src/Storages/StorageMaterializedView.cpp
+++ b/dbms/src/Storages/StorageMaterializedView.cpp
@@ -73,7 +73,7 @@ static StorageID extractDependentTableFromSelectQuery(ASTSelectQuery & query, co
 
 static void checkAllowedQueries(const ASTSelectQuery & query)
 {
-    if (query.prewhere() || query.final() || query.sample_size())
+    if (query.prewhere() || query.final() || query.sampleSize())
         throw Exception("MATERIALIZED VIEW cannot have PREWHERE, SAMPLE or FINAL.", DB::ErrorCodes::QUERY_IS_NOT_SUPPORTED_IN_MATERIALIZED_VIEW);
 
     ASTPtr subquery = extractTableExpression(query, 0);
diff --git a/dbms/src/Storages/StorageMerge.cpp b/dbms/src/Storages/StorageMerge.cpp
index e23aa608ec7..9e274c56454 100644
--- a/dbms/src/Storages/StorageMerge.cpp
+++ b/dbms/src/Storages/StorageMerge.cpp
@@ -235,7 +235,7 @@ Pipes StorageMerge::read(
         auto & storage = std::get<0>(table);
 
         /// If sampling requested, then check that table supports it.
-        if (query_info.query->as<ASTSelectQuery>()->sample_size() && !storage->supportsSampling())
+        if (query_info.query->as<ASTSelectQuery>()->sampleSize() && !storage->supportsSampling())
             throw Exception("Illegal SAMPLE: table doesn't support sampling", ErrorCodes::SAMPLING_NOT_SUPPORTED);
 
         auto source_pipes = createSources(
diff --git a/dbms/src/Storages/StorageMySQL.cpp b/dbms/src/Storages/StorageMySQL.cpp
index 84b554115a6..e0f8cc5813a 100644
--- a/dbms/src/Storages/StorageMySQL.cpp
+++ b/dbms/src/Storages/StorageMySQL.cpp
@@ -83,7 +83,7 @@ Pipes StorageMySQL::read(
     Pipes pipes;
     /// TODO: rewrite MySQLBlockInputStream
     pipes.emplace_back(std::make_shared<SourceFromInputStream>(
-            std::make_shared<MySQLBlockInputStream>(pool.Get(), query, sample_block, max_block_size_)));
+            std::make_shared<MySQLBlockInputStream>(pool.get(), query, sample_block, max_block_size_)));
 
     return pipes;
 }
@@ -199,7 +199,7 @@ private:
 BlockOutputStreamPtr StorageMySQL::write(
     const ASTPtr & /*query*/, const Context & context)
 {
-    return std::make_shared<StorageMySQLBlockOutputStream>(*this, remote_database_name, remote_table_name, pool.Get(), context.getSettingsRef().mysql_max_rows_to_insert);
+    return std::make_shared<StorageMySQLBlockOutputStream>(*this, remote_database_name, remote_table_name, pool.get(), context.getSettingsRef().mysql_max_rows_to_insert);
 }
 
 void registerStorageMySQL(StorageFactory & factory)
diff --git a/dbms/src/Storages/StorageReplicatedMergeTree.cpp b/dbms/src/Storages/StorageReplicatedMergeTree.cpp
index 84af8238352..798536eaa80 100644
--- a/dbms/src/Storages/StorageReplicatedMergeTree.cpp
+++ b/dbms/src/Storages/StorageReplicatedMergeTree.cpp
@@ -2973,14 +2973,12 @@ Pipes StorageReplicatedMergeTree::read(
     const size_t max_block_size,
     const unsigned num_streams)
 {
-    const Settings & settings_ = context.getSettingsRef();
-
     /** The `select_sequential_consistency` setting has two meanings:
     * 1. To throw an exception if on a replica there are not all parts which have been written down on quorum of remaining replicas.
     * 2. Do not read parts that have not yet been written to the quorum of the replicas.
     * For this you have to synchronously go to ZooKeeper.
     */
-    if (settings_.select_sequential_consistency)
+    if (context.getSettingsRef().select_sequential_consistency)
     {
         auto max_added_blocks = getMaxAddedBlocks();
         return reader.read(column_names, query_info, context, max_block_size, num_streams, &max_added_blocks);
diff --git a/dbms/src/Storages/System/StorageSystemPartsBase.cpp b/dbms/src/Storages/System/StorageSystemPartsBase.cpp
index c5edde3e5d9..d8f564b0160 100644
--- a/dbms/src/Storages/System/StorageSystemPartsBase.cpp
+++ b/dbms/src/Storages/System/StorageSystemPartsBase.cpp
@@ -96,7 +96,7 @@ StoragesInfoStream::StoragesInfoStream(const SelectQueryInfo & query_info, const
         rows = block_to_filter.rows();
 
         /// Block contains new columns, update database_column.
-        ColumnPtr database_column_ = block_to_filter.getByName("database").column;
+        ColumnPtr database_column_for_filter = block_to_filter.getByName("database").column;
 
         if (rows)
         {
@@ -106,7 +106,7 @@ StoragesInfoStream::StoragesInfoStream(const SelectQueryInfo & query_info, const
 
             for (size_t i = 0; i < rows; ++i)
             {
-                String database_name = (*database_column_)[i].get<String>();
+                String database_name = (*database_column_for_filter)[i].get<String>();
                 const DatabasePtr database = databases.at(database_name);
 
                 offsets[i] = i ? offsets[i - 1] : 0;
@@ -171,7 +171,7 @@ StoragesInfo StoragesInfoStream::next()
         info.database = (*database_column)[next_row].get<String>();
         info.table = (*table_column)[next_row].get<String>();
 
-        auto isSameTable = [&info, this] (size_t row) -> bool
+        auto is_same_table = [&info, this] (size_t row) -> bool
         {
             return (*database_column)[row].get<String>() == info.database &&
                    (*table_column)[row].get<String>() == info.table;
@@ -180,7 +180,7 @@ StoragesInfo StoragesInfoStream::next()
         /// We may have two rows per table which differ in 'active' value.
         /// If rows with 'active = 0' were not filtered out, this means we
         /// must collect the inactive parts. Remember this fact in StoragesInfo.
-        for (; next_row < rows && isSameTable(next_row); ++next_row)
+        for (; next_row < rows && is_same_table(next_row); ++next_row)
         {
             const auto active = (*active_column)[next_row].get<UInt64>();
             if (active == 0)
diff --git a/dbms/src/Storages/tests/gtest_storage_log.cpp b/dbms/src/Storages/tests/gtest_storage_log.cpp
index d5f78b021b4..3fd79079c8f 100644
--- a/dbms/src/Storages/tests/gtest_storage_log.cpp
+++ b/dbms/src/Storages/tests/gtest_storage_log.cpp
@@ -45,22 +45,22 @@ public:
 
     void SetUp() override
     {
-        disk_ = createDisk<T>();
-        table_ = createStorage(disk_);
+        disk = createDisk<T>();
+        table = createStorage(disk);
     }
 
     void TearDown() override
     {
-        table_->shutdown();
-        destroyDisk<T>(disk_);
+        table->shutdown();
+        destroyDisk<T>(disk);
     }
 
-    const DB::DiskPtr & getDisk() { return disk_; }
-    DB::StoragePtr & getTable() { return table_; }
+    const DB::DiskPtr & getDisk() { return disk; }
+    DB::StoragePtr & getTable() { return table; }
 
 private:
-    DB::DiskPtr disk_;
-    DB::StoragePtr table_;
+    DB::DiskPtr disk;
+    DB::StoragePtr table;
 };
 
 
diff --git a/dbms/src/TableFunctions/TableFunctionMySQL.cpp b/dbms/src/TableFunctions/TableFunctionMySQL.cpp
index cc8e17d0d3e..11f797d4ecf 100644
--- a/dbms/src/TableFunctions/TableFunctionMySQL.cpp
+++ b/dbms/src/TableFunctions/TableFunctionMySQL.cpp
@@ -100,7 +100,7 @@ StoragePtr TableFunctionMySQL::executeImpl(const ASTPtr & ast_function, const Co
         << " ORDER BY ORDINAL_POSITION";
 
     NamesAndTypesList columns;
-    MySQLBlockInputStream result(pool.Get(), query.str(), sample_block, DEFAULT_BLOCK_SIZE);
+    MySQLBlockInputStream result(pool.get(), query.str(), sample_block, DEFAULT_BLOCK_SIZE);
     while (Block block = result.read())
     {
         size_t rows = block.rows();
diff --git a/dbms/src/TableFunctions/TableFunctionRemote.cpp b/dbms/src/TableFunctions/TableFunctionRemote.cpp
index aff9d8c7dce..202f8be4703 100644
--- a/dbms/src/TableFunctions/TableFunctionRemote.cpp
+++ b/dbms/src/TableFunctions/TableFunctionRemote.cpp
@@ -51,7 +51,7 @@ StoragePtr TableFunctionRemote::executeImpl(const ASTPtr & ast_function, const C
 
     size_t arg_num = 0;
 
-    auto getStringLiteral = [](const IAST & node, const char * description)
+    auto get_string_literal = [](const IAST & node, const char * description)
     {
         const auto * lit = node.as<ASTLiteral>();
         if (!lit)
@@ -71,7 +71,7 @@ StoragePtr TableFunctionRemote::executeImpl(const ASTPtr & ast_function, const C
     else
     {
         if (!tryGetIdentifierNameInto(args[arg_num], cluster_name))
-            cluster_description = getStringLiteral(*args[arg_num], "Hosts pattern");
+            cluster_description = get_string_literal(*args[arg_num], "Hosts pattern");
     }
     ++arg_num;
 
@@ -116,7 +116,7 @@ StoragePtr TableFunctionRemote::executeImpl(const ASTPtr & ast_function, const C
     {
         if (arg_num < args.size())
         {
-            username = getStringLiteral(*args[arg_num], "Username");
+            username = get_string_literal(*args[arg_num], "Username");
             ++arg_num;
         }
         else
@@ -124,7 +124,7 @@ StoragePtr TableFunctionRemote::executeImpl(const ASTPtr & ast_function, const C
 
         if (arg_num < args.size())
         {
-            password = getStringLiteral(*args[arg_num], "Password");
+            password = get_string_literal(*args[arg_num], "Password");
             ++arg_num;
         }
     }