diff --git a/.clang-tidy b/.clang-tidy
index 4aeb38ca409..e7900cbe2aa 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -5,9 +5,7 @@
 # a) the new check is not controversial (this includes many checks in readability-* and google-*) or
 # b) too noisy (checks with > 100 new warnings are considered noisy, this includes e.g. cppcoreguidelines-*).
 
-# TODO Let clang-tidy check headers in further directories
-#      --> HeaderFilterRegex: '^.*/(src|base|programs|utils)/.*(h|hpp)$'
-HeaderFilterRegex: '^.*/(base|programs|utils)/.*(h|hpp)$'
+HeaderFilterRegex: '^.*/(base|src|programs|utils)/.*(h|hpp)$'
 
 Checks: [
   '*',
@@ -37,6 +35,8 @@ Checks: [
   '-cert-oop54-cpp',
   '-cert-oop57-cpp',
 
+  '-clang-analyzer-optin.performance.Padding',
+
   '-clang-analyzer-unix.Malloc',
 
   '-cppcoreguidelines-*', # impractical in a codebase as large as ClickHouse, also slow
diff --git a/base/poco/Net/include/Poco/Net/HTTPRequestHandlerFactory.h b/base/poco/Net/include/Poco/Net/HTTPRequestHandlerFactory.h
index 029d936769b..9bc35b7ff70 100644
--- a/base/poco/Net/include/Poco/Net/HTTPRequestHandlerFactory.h
+++ b/base/poco/Net/include/Poco/Net/HTTPRequestHandlerFactory.h
@@ -30,7 +30,6 @@ namespace Net
 
 
     class HTTPServerRequest;
-    class HTTPServerResponse;
     class HTTPRequestHandler;
 
 
diff --git a/contrib/libmetrohash/src/metrohash64.cpp b/contrib/libmetrohash/src/metrohash64.cpp
index 7b5ec7f1a42..6ff64027292 100644
--- a/contrib/libmetrohash/src/metrohash64.cpp
+++ b/contrib/libmetrohash/src/metrohash64.cpp
@@ -26,13 +26,13 @@ const uint8_t MetroHash64::test_seed_1[8] =   { 0x3B, 0x0D, 0x48, 0x1C, 0xF4, 0x
 
 
 
-MetroHash64::MetroHash64(const uint64_t seed)
+MetroHash64::MetroHash64(uint64_t seed)
 {
     Initialize(seed);
 }
 
 
-void MetroHash64::Initialize(const uint64_t seed)
+void MetroHash64::Initialize(uint64_t seed)
 {
     vseed = (static_cast<uint64_t>(seed) + k2) * k0;
 
@@ -47,7 +47,7 @@ void MetroHash64::Initialize(const uint64_t seed)
 }
 
 
-void MetroHash64::Update(const uint8_t * const buffer, const uint64_t length)
+void MetroHash64::Update(const uint8_t * const buffer, uint64_t length)
 {
     const uint8_t * ptr = reinterpret_cast<const uint8_t*>(buffer);
     const uint8_t * const end = ptr + length;
@@ -62,7 +62,7 @@ void MetroHash64::Update(const uint8_t * const buffer, const uint64_t length)
         memcpy(input.b + (bytes % 32), ptr, static_cast<size_t>(fill));
         ptr   += fill;
         bytes += fill;
-        
+
         // input buffer is still partially filled
         if ((bytes % 32) != 0) return;
 
@@ -72,7 +72,7 @@ void MetroHash64::Update(const uint8_t * const buffer, const uint64_t length)
         state.v[2] += read_u64(&input.b[16]) * k2; state.v[2] = rotate_right(state.v[2],29) + state.v[0];
         state.v[3] += read_u64(&input.b[24]) * k3; state.v[3] = rotate_right(state.v[3],29) + state.v[1];
     }
-    
+
     // bulk update
     bytes += static_cast<uint64_t>(end - ptr);
     while (ptr <= (end - 32))
@@ -83,14 +83,14 @@ void MetroHash64::Update(const uint8_t * const buffer, const uint64_t length)
         state.v[2] += read_u64(ptr) * k2; ptr += 8; state.v[2] = rotate_right(state.v[2],29) + state.v[0];
         state.v[3] += read_u64(ptr) * k3; ptr += 8; state.v[3] = rotate_right(state.v[3],29) + state.v[1];
     }
-    
+
     // store remaining bytes in input buffer
     if (ptr < end)
         memcpy(input.b, ptr, static_cast<size_t>(end - ptr));
 }
 
 
-void MetroHash64::Finalize(uint8_t * const hash)
+void MetroHash64::Finalize(uint8_t * hash)
 {
     // finalize bulk loop, if used
     if (bytes >= 32)
@@ -102,11 +102,11 @@ void MetroHash64::Finalize(uint8_t * const hash)
 
         state.v[0] = vseed + (state.v[0] ^ state.v[1]);
     }
-    
+
     // process any bytes remaining in the input buffer
     const uint8_t * ptr = reinterpret_cast<const uint8_t*>(input.b);
     const uint8_t * const end = ptr + (bytes % 32);
-    
+
     if ((end - ptr) >= 16)
     {
         state.v[1]  = state.v[0] + (read_u64(ptr) * k2); ptr += 8; state.v[1] = rotate_right(state.v[1],29) * k3;
@@ -139,7 +139,7 @@ void MetroHash64::Finalize(uint8_t * const hash)
         state.v[0] += read_u8 (ptr) * k3;
         state.v[0] ^= rotate_right(state.v[0], 37) * k1;
     }
-    
+
     state.v[0] ^= rotate_right(state.v[0], 28);
     state.v[0] *= k0;
     state.v[0] ^= rotate_right(state.v[0], 29);
@@ -152,7 +152,7 @@ void MetroHash64::Finalize(uint8_t * const hash)
 }
 
 
-void MetroHash64::Hash(const uint8_t * buffer, const uint64_t length, uint8_t * const hash, const uint64_t seed)
+void MetroHash64::Hash(const uint8_t * buffer, uint64_t length, uint8_t * const hash, uint64_t seed)
 {
     const uint8_t * ptr = reinterpret_cast<const uint8_t*>(buffer);
     const uint8_t * const end = ptr + length;
@@ -238,7 +238,7 @@ bool MetroHash64::ImplementationVerified()
 
     // verify incremental implementation
     MetroHash64 metro;
-    
+
     metro.Initialize(0);
     metro.Update(reinterpret_cast<const uint8_t *>(MetroHash64::test_string), strlen(MetroHash64::test_string));
     metro.Finalize(hash);
@@ -262,9 +262,9 @@ void metrohash64_1(const uint8_t * key, uint64_t len, uint32_t seed, uint8_t * o
 
     const uint8_t * ptr = reinterpret_cast<const uint8_t*>(key);
     const uint8_t * const end = ptr + len;
-    
+
     uint64_t hash = ((static_cast<uint64_t>(seed) + k2) * k0) + len;
-    
+
     if (len >= 32)
     {
         uint64_t v[4];
@@ -272,7 +272,7 @@ void metrohash64_1(const uint8_t * key, uint64_t len, uint32_t seed, uint8_t * o
         v[1] = hash;
         v[2] = hash;
         v[3] = hash;
-        
+
         do
         {
             v[0] += read_u64(ptr) * k0; ptr += 8; v[0] = rotate_right(v[0],29) + v[2];
@@ -288,7 +288,7 @@ void metrohash64_1(const uint8_t * key, uint64_t len, uint32_t seed, uint8_t * o
         v[1] ^= rotate_right(((v[1] + v[3]) * k1) + v[2], 33) * k0;
         hash += v[0] ^ v[1];
     }
-    
+
     if ((end - ptr) >= 16)
     {
         uint64_t v0 = hash + (read_u64(ptr) * k0); ptr += 8; v0 = rotate_right(v0,33) * k1;
@@ -297,32 +297,32 @@ void metrohash64_1(const uint8_t * key, uint64_t len, uint32_t seed, uint8_t * o
         v1 ^= rotate_right(v1 * k3, 35) + v0;
         hash += v1;
     }
-    
+
     if ((end - ptr) >= 8)
     {
         hash += read_u64(ptr) * k3; ptr += 8;
         hash ^= rotate_right(hash, 33) * k1;
-        
+
     }
-    
+
     if ((end - ptr) >= 4)
     {
         hash += read_u32(ptr) * k3; ptr += 4;
         hash ^= rotate_right(hash, 15) * k1;
     }
-    
+
     if ((end - ptr) >= 2)
     {
         hash += read_u16(ptr) * k3; ptr += 2;
         hash ^= rotate_right(hash, 13) * k1;
     }
-    
+
     if ((end - ptr) >= 1)
     {
         hash += read_u8 (ptr) * k3;
         hash ^= rotate_right(hash, 25) * k1;
     }
-    
+
     hash ^= rotate_right(hash, 33);
     hash *= k0;
     hash ^= rotate_right(hash, 33);
@@ -336,13 +336,13 @@ void metrohash64_2(const uint8_t * key, uint64_t len, uint32_t seed, uint8_t * o
     static const uint64_t k0 = 0xD6D018F5;
     static const uint64_t k1 = 0xA2AA033B;
     static const uint64_t k2 = 0x62992FC1;
-    static const uint64_t k3 = 0x30BC5B29; 
+    static const uint64_t k3 = 0x30BC5B29;
 
     const uint8_t * ptr = reinterpret_cast<const uint8_t*>(key);
     const uint8_t * const end = ptr + len;
-    
+
     uint64_t hash = ((static_cast<uint64_t>(seed) + k2) * k0) + len;
-    
+
     if (len >= 32)
     {
         uint64_t v[4];
@@ -350,7 +350,7 @@ void metrohash64_2(const uint8_t * key, uint64_t len, uint32_t seed, uint8_t * o
         v[1] = hash;
         v[2] = hash;
         v[3] = hash;
-        
+
         do
         {
             v[0] += read_u64(ptr) * k0; ptr += 8; v[0] = rotate_right(v[0],29) + v[2];
@@ -366,7 +366,7 @@ void metrohash64_2(const uint8_t * key, uint64_t len, uint32_t seed, uint8_t * o
         v[1] ^= rotate_right(((v[1] + v[3]) * k1) + v[2], 30) * k0;
         hash += v[0] ^ v[1];
     }
-    
+
     if ((end - ptr) >= 16)
     {
         uint64_t v0 = hash + (read_u64(ptr) * k2); ptr += 8; v0 = rotate_right(v0,29) * k3;
@@ -375,31 +375,31 @@ void metrohash64_2(const uint8_t * key, uint64_t len, uint32_t seed, uint8_t * o
         v1 ^= rotate_right(v1 * k3, 34) + v0;
         hash += v1;
     }
-    
+
     if ((end - ptr) >= 8)
     {
         hash += read_u64(ptr) * k3; ptr += 8;
         hash ^= rotate_right(hash, 36) * k1;
     }
-    
+
     if ((end - ptr) >= 4)
     {
         hash += read_u32(ptr) * k3; ptr += 4;
         hash ^= rotate_right(hash, 15) * k1;
     }
-    
+
     if ((end - ptr) >= 2)
     {
         hash += read_u16(ptr) * k3; ptr += 2;
         hash ^= rotate_right(hash, 15) * k1;
     }
-    
+
     if ((end - ptr) >= 1)
     {
         hash += read_u8 (ptr) * k3;
         hash ^= rotate_right(hash, 23) * k1;
     }
-    
+
     hash ^= rotate_right(hash, 28);
     hash *= k0;
     hash ^= rotate_right(hash, 29);
diff --git a/contrib/libmetrohash/src/metrohash64.h b/contrib/libmetrohash/src/metrohash64.h
index 911e54e6863..7003a1848be 100644
--- a/contrib/libmetrohash/src/metrohash64.h
+++ b/contrib/libmetrohash/src/metrohash64.h
@@ -25,24 +25,24 @@ public:
     static const uint32_t bits = 64;
 
     // Constructor initializes the same as Initialize()
-    explicit MetroHash64(const uint64_t seed=0);
+    explicit MetroHash64(uint64_t seed=0);
 
     // Initializes internal state for new hash with optional seed
-    void Initialize(const uint64_t seed=0);
+    void Initialize(uint64_t seed=0);
 
     // Update the hash state with a string of bytes. If the length
     // is sufficiently long, the implementation switches to a bulk
     // hashing algorithm directly on the argument buffer for speed.
-    void Update(const uint8_t * buffer, const uint64_t length);
+    void Update(const uint8_t * buffer, uint64_t length);
 
     // Constructs the final hash and writes it to the argument buffer.
     // After a hash is finalized, this instance must be Initialized()-ed
     // again or the behavior of Update() and Finalize() is undefined.
-    void Finalize(uint8_t * const hash);
+    void Finalize(uint8_t * hash);
 
     // A non-incremental function implementation. This can be significantly
     // faster than the incremental implementation for some usage patterns.
-    static void Hash(const uint8_t * buffer, const uint64_t length, uint8_t * const hash, const uint64_t seed=0);
+    static void Hash(const uint8_t * buffer, uint64_t length, uint8_t * hash, uint64_t seed=0);
 
     // Does implementation correctly execute test vectors?
     static bool ImplementationVerified();
diff --git a/src/Access/AccessBackup.cpp b/src/Access/AccessBackup.cpp
index 800a54e69b3..ba89899dd8f 100644
--- a/src/Access/AccessBackup.cpp
+++ b/src/Access/AccessBackup.cpp
@@ -297,7 +297,7 @@ namespace
 
 
 std::pair<String, BackupEntryPtr> makeBackupEntryForAccess(
-    const std::vector<std::pair<UUID, AccessEntityPtr>> access_entities,
+    const std::vector<std::pair<UUID, AccessEntityPtr>> & access_entities,
     const String & data_path_in_backup,
     size_t counter,
     const AccessControl & access_control)
@@ -326,7 +326,7 @@ void AccessRestorerFromBackup::addDataPath(const String & data_path)
         return;
 
     fs::path data_path_in_backup_fs = data_path;
-    Strings filenames = backup->listFiles(data_path);
+    Strings filenames = backup->listFiles(data_path, /*recursive*/ false);
     if (filenames.empty())
         return;
 
diff --git a/src/Access/AccessBackup.h b/src/Access/AccessBackup.h
index 99f22b6c6a8..1aaac589ccb 100644
--- a/src/Access/AccessBackup.h
+++ b/src/Access/AccessBackup.h
@@ -21,7 +21,7 @@ struct RestoreSettings;
 
 /// Makes a backup of access entities of a specified type.
 std::pair<String, BackupEntryPtr> makeBackupEntryForAccess(
-    const std::vector<std::pair<UUID, AccessEntityPtr>> access_entities,
+    const std::vector<std::pair<UUID, AccessEntityPtr>> & access_entities,
     const String & data_path_in_backup,
     size_t counter,
     const AccessControl & access_control);
diff --git a/src/Access/ContextAccessParams.cpp b/src/Access/ContextAccessParams.cpp
index ec839a37b1a..07374e9bbf5 100644
--- a/src/Access/ContextAccessParams.cpp
+++ b/src/Access/ContextAccessParams.cpp
@@ -7,7 +7,7 @@ namespace DB
 {
 
 ContextAccessParams::ContextAccessParams(
-    const std::optional<UUID> user_id_,
+    std::optional<UUID> user_id_,
     bool full_access_,
     bool use_default_roles_,
     const std::shared_ptr<const std::vector<UUID>> & current_roles_,
diff --git a/src/Access/ContextAccessParams.h b/src/Access/ContextAccessParams.h
index 8b68fa44ed4..07503a3af6d 100644
--- a/src/Access/ContextAccessParams.h
+++ b/src/Access/ContextAccessParams.h
@@ -15,7 +15,7 @@ class ContextAccessParams
 {
 public:
     ContextAccessParams(
-        const std::optional<UUID> user_id_,
+        std::optional<UUID> user_id_,
         bool full_access_,
         bool use_default_roles_,
         const std::shared_ptr<const std::vector<UUID>> & current_roles_,
diff --git a/src/Access/GSSAcceptor.h b/src/Access/GSSAcceptor.h
index 8d490fb47ae..225e03056ac 100644
--- a/src/Access/GSSAcceptor.h
+++ b/src/Access/GSSAcceptor.h
@@ -34,7 +34,7 @@ public:
     };
 
     explicit GSSAcceptorContext(const Params & params_);
-    virtual ~GSSAcceptorContext() override;
+    ~GSSAcceptorContext() override;
 
     GSSAcceptorContext(const GSSAcceptorContext &) = delete;
     GSSAcceptorContext(GSSAcceptorContext &&) = delete;
diff --git a/src/Access/LDAPAccessStorage.cpp b/src/Access/LDAPAccessStorage.cpp
index c271cd39845..b1f10cd2d49 100644
--- a/src/Access/LDAPAccessStorage.cpp
+++ b/src/Access/LDAPAccessStorage.cpp
@@ -204,7 +204,7 @@ void LDAPAccessStorage::assignRolesNoLock(User & user, const LDAPClient::SearchR
 }
 
 
-void LDAPAccessStorage::assignRolesNoLock(User & user, const LDAPClient::SearchResultsList & external_roles, const std::size_t external_roles_hash) const
+void LDAPAccessStorage::assignRolesNoLock(User & user, const LDAPClient::SearchResultsList & external_roles, std::size_t external_roles_hash) const
 {
     const auto & user_name = user.getName();
     auto & granted_roles = user.granted_roles;
diff --git a/src/Access/LDAPAccessStorage.h b/src/Access/LDAPAccessStorage.h
index b01f58c724a..d5da64e4111 100644
--- a/src/Access/LDAPAccessStorage.h
+++ b/src/Access/LDAPAccessStorage.h
@@ -33,29 +33,29 @@ public:
     static constexpr char STORAGE_TYPE[] = "ldap";
 
     explicit LDAPAccessStorage(const String & storage_name_, AccessControl & access_control_, const Poco::Util::AbstractConfiguration & config, const String & prefix);
-    virtual ~LDAPAccessStorage() override = default;
+    ~LDAPAccessStorage() override = default;
 
     String getLDAPServerName() const;
 
     // IAccessStorage implementations.
-    virtual const char * getStorageType() const override;
-    virtual String getStorageParamsJSON() const override;
-    virtual bool isReadOnly() const override { return true; }
-    virtual bool exists(const UUID & id) const override;
+    const char * getStorageType() const override;
+    String getStorageParamsJSON() const override;
+    bool isReadOnly() const override { return true; }
+    bool exists(const UUID & id) const override;
 
 private: // IAccessStorage implementations.
-    virtual std::optional<UUID> findImpl(AccessEntityType type, const String & name) const override;
-    virtual std::vector<UUID> findAllImpl(AccessEntityType type) const override;
-    virtual AccessEntityPtr readImpl(const UUID & id, bool throw_if_not_exists) const override;
-    virtual std::optional<std::pair<String, AccessEntityType>> readNameWithTypeImpl(const UUID & id, bool throw_if_not_exists) const override;
-    virtual std::optional<AuthResult> authenticateImpl(const Credentials & credentials, const Poco::Net::IPAddress & address, const ExternalAuthenticators & external_authenticators, bool throw_if_user_not_exists, bool allow_no_password, bool allow_plaintext_password) const override;
+    std::optional<UUID> findImpl(AccessEntityType type, const String & name) const override;
+    std::vector<UUID> findAllImpl(AccessEntityType type) const override;
+    AccessEntityPtr readImpl(const UUID & id, bool throw_if_not_exists) const override;
+    std::optional<std::pair<String, AccessEntityType>> readNameWithTypeImpl(const UUID & id, bool throw_if_not_exists) const override;
+    std::optional<AuthResult> authenticateImpl(const Credentials & credentials, const Poco::Net::IPAddress & address, const ExternalAuthenticators & external_authenticators, bool throw_if_user_not_exists, bool allow_no_password, bool allow_plaintext_password) const override;
 
     void setConfiguration(const Poco::Util::AbstractConfiguration & config, const String & prefix);
     void processRoleChange(const UUID & id, const AccessEntityPtr & entity);
 
     void applyRoleChangeNoLock(bool grant, const UUID & role_id, const String & role_name);
     void assignRolesNoLock(User & user, const LDAPClient::SearchResultsList & external_roles) const;
-    void assignRolesNoLock(User & user, const LDAPClient::SearchResultsList & external_roles, const std::size_t external_roles_hash) const;
+    void assignRolesNoLock(User & user, const LDAPClient::SearchResultsList & external_roles, std::size_t external_roles_hash) const;
     void updateAssignedRolesNoLock(const UUID & id, const String & user_name, const LDAPClient::SearchResultsList & external_roles) const;
     std::set<String> mapExternalRolesNoLock(const LDAPClient::SearchResultsList & external_roles) const;
     bool areLDAPCredentialsValidNoLock(const User & user, const Credentials & credentials,
diff --git a/src/AggregateFunctions/AggregateFunctionFlameGraph.cpp b/src/AggregateFunctions/AggregateFunctionFlameGraph.cpp
index f6aafd9a9b1..f3d99046036 100644
--- a/src/AggregateFunctions/AggregateFunctionFlameGraph.cpp
+++ b/src/AggregateFunctions/AggregateFunctionFlameGraph.cpp
@@ -252,7 +252,6 @@ void dumpFlameGraph(
     fillColumn(chars, offsets, out.str());
 }
 
-// NOLINTBEGIN(clang-analyzer-optin.performance.Padding)
 struct AggregateFunctionFlameGraphData
 {
     struct Entry
@@ -469,7 +468,6 @@ struct AggregateFunctionFlameGraphData
         DB::dumpFlameGraph(tree.dump(max_depth, min_bytes), chars, offsets);
     }
 };
-// NOLINTEND(clang-analyzer-optin.performance.Padding)
 
 /// Aggregate function which builds a flamegraph using the list of stacktraces.
 /// The output is an array of strings which can be used by flamegraph.pl util.
diff --git a/src/AggregateFunctions/AggregateFunctionMLMethod.h b/src/AggregateFunctions/AggregateFunctionMLMethod.h
index fd50fe4b28c..cfb8550d829 100644
--- a/src/AggregateFunctions/AggregateFunctionMLMethod.h
+++ b/src/AggregateFunctions/AggregateFunctionMLMethod.h
@@ -157,7 +157,7 @@ public:
 
     void update(UInt64 batch_size, std::vector<Float64> & weights, Float64 & bias, Float64 learning_rate, const std::vector<Float64> & batch_gradient) override;
 
-    virtual void merge(const IWeightsUpdater & rhs, Float64 frac, Float64 rhs_frac) override;
+    void merge(const IWeightsUpdater & rhs, Float64 frac, Float64 rhs_frac) override;
 
     void write(WriteBuffer & buf) const override;
 
@@ -189,7 +189,7 @@ public:
 
     void update(UInt64 batch_size, std::vector<Float64> & weights, Float64 & bias, Float64 learning_rate, const std::vector<Float64> & batch_gradient) override;
 
-    virtual void merge(const IWeightsUpdater & rhs, Float64 frac, Float64 rhs_frac) override;
+    void merge(const IWeightsUpdater & rhs, Float64 frac, Float64 rhs_frac) override;
 
     void write(WriteBuffer & buf) const override;
 
@@ -226,7 +226,7 @@ public:
 
     void update(UInt64 batch_size, std::vector<Float64> & weights, Float64 & bias, Float64 learning_rate, const std::vector<Float64> & batch_gradient) override;
 
-    virtual void merge(const IWeightsUpdater & rhs, Float64 frac, Float64 rhs_frac) override;
+    void merge(const IWeightsUpdater & rhs, Float64 frac, Float64 rhs_frac) override;
 
     void write(WriteBuffer & buf) const override;
 
diff --git a/src/AggregateFunctions/AggregateFunctionStatisticsSimple.h b/src/AggregateFunctions/AggregateFunctionStatisticsSimple.h
index f9a60c0c0b4..cb20d54b2a8 100644
--- a/src/AggregateFunctions/AggregateFunctionStatisticsSimple.h
+++ b/src/AggregateFunctions/AggregateFunctionStatisticsSimple.h
@@ -234,9 +234,6 @@ namespace ErrorCodes
     extern const int ILLEGAL_TYPE_OF_ARGUMENT;
 }
 
-namespace
-{
-
 template <template <typename> typename FunctionTemplate, StatisticsFunctionKind kind>
 AggregateFunctionPtr createAggregateFunctionStatisticsUnary(
     const std::string & name, const DataTypes & argument_types, const Array & parameters, const Settings *)
@@ -273,5 +270,3 @@ AggregateFunctionPtr createAggregateFunctionStatisticsBinary(
 }
 
 }
-
-}
diff --git a/src/AggregateFunctions/AggregateFunctionUniqCombined.h b/src/AggregateFunctions/AggregateFunctionUniqCombined.h
index 10774442610..6d5486a3b09 100644
--- a/src/AggregateFunctions/AggregateFunctionUniqCombined.h
+++ b/src/AggregateFunctions/AggregateFunctionUniqCombined.h
@@ -42,9 +42,6 @@ struct UniqCombinedHashTableGrower : public HashTableGrowerWithPrecalculation<>
     void increaseSize() { increaseSizeDegree(1); }
 };
 
-namespace
-{
-
 template <typename T, UInt8 K, typename HashValueType>
 struct AggregateFunctionUniqCombinedData
 {
@@ -268,8 +265,6 @@ AggregateFunctionPtr createAggregateFunctionWithK(const DataTypes & argument_typ
         return std::make_shared<typename WithK<K, HashValueType>::template AggregateFunctionVariadic<false, false>>(argument_types, params);
 }
 
-}
-
 template <UInt8 K>
 AggregateFunctionPtr createAggregateFunctionWithHashType(bool use_64_bit_hash, const DataTypes & argument_types, const Array & params)
 {
diff --git a/src/AggregateFunctions/Combinators/AggregateFunctionNull.h b/src/AggregateFunctions/Combinators/AggregateFunctionNull.h
index ba72f960852..72ab3cf5acb 100644
--- a/src/AggregateFunctions/Combinators/AggregateFunctionNull.h
+++ b/src/AggregateFunctions/Combinators/AggregateFunctionNull.h
@@ -521,7 +521,7 @@ public:
             }
         }
 
-        chassert(nullable_filters.size() > 0);
+        chassert(!nullable_filters.empty());
         bool found_one = false;
         if (nullable_filters.size() == 1)
         {
diff --git a/src/AggregateFunctions/DDSketch/Store.h b/src/AggregateFunctions/DDSketch/Store.h
index 91eaeacedfe..428b2a6c9b8 100644
--- a/src/AggregateFunctions/DDSketch/Store.h
+++ b/src/AggregateFunctions/DDSketch/Store.h
@@ -38,7 +38,7 @@ public:
         offset = other->offset;
     }
 
-    int length()
+    int length() const
     {
         return static_cast<int>(bins.size());
     }
diff --git a/src/AggregateFunctions/QuantileExact.h b/src/AggregateFunctions/QuantileExact.h
index a92d1979bab..94e321083a7 100644
--- a/src/AggregateFunctions/QuantileExact.h
+++ b/src/AggregateFunctions/QuantileExact.h
@@ -150,7 +150,7 @@ struct QuantileExactExclusive : public QuantileExact<Value>
                 return static_cast<Float64>(*std::min_element(array.begin(), array.end()));
 
             ::nth_element(array.begin(), array.begin() + n - 1, array.end());
-            auto nth_elem = std::min_element(array.begin() + n, array.end());
+            auto * nth_elem = std::min_element(array.begin() + n, array.end());
 
             return static_cast<Float64>(array[n - 1]) + (h - n) * static_cast<Float64>(*nth_elem - array[n - 1]);
         }
@@ -179,7 +179,7 @@ struct QuantileExactExclusive : public QuantileExact<Value>
                 else
                 {
                     ::nth_element(array.begin() + prev_n, array.begin() + n - 1, array.end());
-                    auto nth_elem = std::min_element(array.begin() + n, array.end());
+                    auto * nth_elem = std::min_element(array.begin() + n, array.end());
 
                     result[indices[i]] = static_cast<Float64>(array[n - 1]) + (h - n) * static_cast<Float64>(*nth_elem - array[n - 1]);
                     prev_n = n - 1;
@@ -214,7 +214,7 @@ struct QuantileExactInclusive : public QuantileExact<Value>
             else if (n < 1)
                 return static_cast<Float64>(*std::min_element(array.begin(), array.end()));
             ::nth_element(array.begin(), array.begin() + n - 1, array.end());
-            auto nth_elem = std::min_element(array.begin() + n, array.end());
+            auto * nth_elem = std::min_element(array.begin() + n, array.end());
 
             return static_cast<Float64>(array[n - 1]) + (h - n) * static_cast<Float64>(*nth_elem - array[n - 1]);
         }
@@ -241,7 +241,7 @@ struct QuantileExactInclusive : public QuantileExact<Value>
                 else
                 {
                     ::nth_element(array.begin() + prev_n, array.begin() + n - 1, array.end());
-                    auto nth_elem = std::min_element(array.begin() + n, array.end());
+                    auto * nth_elem = std::min_element(array.begin() + n, array.end());
 
                     result[indices[i]] = static_cast<Float64>(array[n - 1]) + (h - n) * (static_cast<Float64>(*nth_elem) - array[n - 1]);
                     prev_n = n - 1;
diff --git a/src/AggregateFunctions/ReservoirSamplerDeterministic.h b/src/AggregateFunctions/ReservoirSamplerDeterministic.h
index daed0b98ca3..b7032a01884 100644
--- a/src/AggregateFunctions/ReservoirSamplerDeterministic.h
+++ b/src/AggregateFunctions/ReservoirSamplerDeterministic.h
@@ -191,7 +191,7 @@ public:
             /// TODO: After implementation of "versioning aggregate function state",
             /// change the serialization format.
             Element elem;
-            memset(&elem, 0, sizeof(elem));
+            memset(&elem, 0, sizeof(elem)); /// NOLINT(bugprone-undefined-memory-manipulation)
             elem = samples[i];
 
             DB::transformEndianness<std::endian::little>(elem);
diff --git a/src/AggregateFunctions/SingleValueData.h b/src/AggregateFunctions/SingleValueData.h
index 2ba98f8a9c3..cde13b128e5 100644
--- a/src/AggregateFunctions/SingleValueData.h
+++ b/src/AggregateFunctions/SingleValueData.h
@@ -23,7 +23,7 @@ struct SingleValueDataBase
     /// For example argMin holds 1 of these (for the result), while keeping a template for the value
     static constexpr UInt32 MAX_STORAGE_SIZE = 64;
 
-    virtual ~SingleValueDataBase() { }
+    virtual ~SingleValueDataBase() = default;
     virtual bool has() const = 0;
     virtual void insertResultInto(IColumn &) const = 0;
     virtual void write(WriteBuffer &, const ISerialization &) const = 0;
diff --git a/src/AggregateFunctions/UniqExactSet.h b/src/AggregateFunctions/UniqExactSet.h
index 2a790690f51..131c59b9ed6 100644
--- a/src/AggregateFunctions/UniqExactSet.h
+++ b/src/AggregateFunctions/UniqExactSet.h
@@ -39,8 +39,8 @@ public:
     /// This method will convert all the SingleLevelSet to TwoLevelSet in parallel if the hashsets are not all singlelevel or not all twolevel.
     static void parallelizeMergePrepare(const std::vector<UniqExactSet *> & data_vec, ThreadPool & thread_pool)
     {
-        unsigned long single_level_set_num = 0;
-        unsigned long all_single_hash_size = 0;
+        UInt64 single_level_set_num = 0;
+        UInt64 all_single_hash_size = 0;
 
         for (auto ele : data_vec)
         {
diff --git a/src/Analyzer/Passes/QueryAnalysisPass.h b/src/Analyzer/Passes/QueryAnalysisPass.h
index 8c746833eee..e0a42a530b0 100644
--- a/src/Analyzer/Passes/QueryAnalysisPass.h
+++ b/src/Analyzer/Passes/QueryAnalysisPass.h
@@ -77,7 +77,7 @@ public:
       * Available expression columns are extracted from table expression.
       * Table expression node must have query, union, table, table function type.
       */
-    QueryAnalysisPass(QueryTreeNodePtr table_expression_, bool only_analyze_ = false);
+    explicit QueryAnalysisPass(QueryTreeNodePtr table_expression_, bool only_analyze_ = false);
 
     String getName() override
     {
diff --git a/src/Backups/BackupSettings.h b/src/Backups/BackupSettings.h
index f26b992b348..10181ea464a 100644
--- a/src/Backups/BackupSettings.h
+++ b/src/Backups/BackupSettings.h
@@ -26,7 +26,7 @@ struct BackupSettings
     String password;
 
     /// S3 storage class.
-    String s3_storage_class = "";
+    String s3_storage_class;
 
     /// If this is set to true then only create queries will be written to backup,
     /// without the data of tables.
diff --git a/src/Backups/IBackup.h b/src/Backups/IBackup.h
index 5663f1ed3e8..6f366a58103 100644
--- a/src/Backups/IBackup.h
+++ b/src/Backups/IBackup.h
@@ -80,7 +80,7 @@ public:
 
     /// Returns names of entries stored in a specified directory in the backup.
     /// If `directory` is empty or '/' the functions returns entries in the backup's root.
-    virtual Strings listFiles(const String & directory, bool recursive = false) const = 0;
+    virtual Strings listFiles(const String & directory, bool recursive) const = 0;
 
     /// Checks if a specified directory contains any files.
     /// The function returns the same as `!listFiles(directory).empty()`.
@@ -108,11 +108,9 @@ public:
     virtual std::unique_ptr<SeekableReadBuffer> readFile(const SizeAndChecksum & size_and_checksum) const = 0;
 
     /// Copies a file from the backup to a specified destination disk. Returns the number of bytes written.
-    virtual size_t copyFileToDisk(const String & file_name, DiskPtr destination_disk, const String & destination_path,
-                                  WriteMode write_mode = WriteMode::Rewrite) const = 0;
+    virtual size_t copyFileToDisk(const String & file_name, DiskPtr destination_disk, const String & destination_path, WriteMode write_mode) const = 0;
 
-    virtual size_t copyFileToDisk(const SizeAndChecksum & size_and_checksum, DiskPtr destination_disk, const String & destination_path,
-                                  WriteMode write_mode = WriteMode::Rewrite) const = 0;
+    virtual size_t copyFileToDisk(const SizeAndChecksum & size_and_checksum, DiskPtr destination_disk, const String & destination_path, WriteMode write_mode) const = 0;
 
     /// Puts a new entry to the backup.
     virtual void writeFile(const BackupFileInfo & file_info, BackupEntryPtr entry) = 0;
diff --git a/src/Backups/RestorerFromBackup.cpp b/src/Backups/RestorerFromBackup.cpp
index e20e8eb66c6..ed1d5b8a103 100644
--- a/src/Backups/RestorerFromBackup.cpp
+++ b/src/Backups/RestorerFromBackup.cpp
@@ -273,7 +273,7 @@ void RestorerFromBackup::findRootPathsInBackup()
     root_paths_in_backup.push_back(root_path);
 
     /// Add shard-related part to the root path.
-    Strings shards_in_backup = backup->listFiles(root_path / "shards");
+    Strings shards_in_backup = backup->listFiles(root_path / "shards", /*recursive*/ false);
     if (shards_in_backup.empty())
     {
         if (restore_settings.shard_num_in_backup > 1)
@@ -295,7 +295,7 @@ void RestorerFromBackup::findRootPathsInBackup()
     }
 
     /// Add replica-related part to the root path.
-    Strings replicas_in_backup = backup->listFiles(root_path / "replicas");
+    Strings replicas_in_backup = backup->listFiles(root_path / "replicas", /*recursive*/ false);
     if (replicas_in_backup.empty())
     {
         if (restore_settings.replica_num_in_backup > 1)
@@ -514,7 +514,7 @@ void RestorerFromBackup::findDatabaseInBackupImpl(const String & database_name_i
         if (!metadata_path && !try_metadata_path.empty() && backup->fileExists(try_metadata_path))
             metadata_path = try_metadata_path;
 
-        Strings file_names = backup->listFiles(try_tables_metadata_path);
+        Strings file_names = backup->listFiles(try_tables_metadata_path, /*recursive*/ false);
         for (const String & file_name : file_names)
         {
             if (!file_name.ends_with(".sql"))
@@ -575,7 +575,7 @@ void RestorerFromBackup::findEverythingInBackup(const std::set<String> & except_
 
     for (const auto & root_path_in_backup : root_paths_in_backup)
     {
-        Strings file_names = backup->listFiles(root_path_in_backup / "metadata");
+        Strings file_names = backup->listFiles(root_path_in_backup / "metadata", /*recursive*/ false);
         for (String & file_name : file_names)
         {
             if (file_name.ends_with(".sql"))
diff --git a/src/Client/HedgedConnectionsFactory.h b/src/Client/HedgedConnectionsFactory.h
index ce7b553acdd..2b7ec3f3fe5 100644
--- a/src/Client/HedgedConnectionsFactory.h
+++ b/src/Client/HedgedConnectionsFactory.h
@@ -159,7 +159,7 @@ private:
     size_t requested_connections_count = 0;
 
     const size_t max_parallel_replicas = 0;
-    const bool skip_unavailable_shards = 0;
+    const bool skip_unavailable_shards = false;
 };
 
 }
diff --git a/src/Client/TestHint.h b/src/Client/TestHint.h
index 7858b7f04a4..eaf854be5df 100644
--- a/src/Client/TestHint.h
+++ b/src/Client/TestHint.h
@@ -77,12 +77,12 @@ private:
     {
         if (actual_server_error && std::find(server_errors.begin(), server_errors.end(), actual_server_error) == server_errors.end())
             return false;
-        if (!actual_server_error && server_errors.size())
+        if (!actual_server_error && !server_errors.empty())
             return false;
 
         if (actual_client_error && std::find(client_errors.begin(), client_errors.end(), actual_client_error) == client_errors.end())
             return false;
-        if (!actual_client_error && client_errors.size())
+        if (!actual_client_error && !client_errors.empty())
             return false;
 
         return true;
@@ -90,7 +90,7 @@ private:
 
     bool lostExpectedError(int actual_server_error, int actual_client_error) const
     {
-        return (server_errors.size() && !actual_server_error) || (client_errors.size() && !actual_client_error);
+        return (!server_errors.empty() && !actual_server_error) || (!client_errors.empty() && !actual_client_error);
     }
 };
 
diff --git a/src/Columns/ColumnUnique.h b/src/Columns/ColumnUnique.h
index 76bbbbacdbf..a8873140817 100644
--- a/src/Columns/ColumnUnique.h
+++ b/src/Columns/ColumnUnique.h
@@ -671,7 +671,7 @@ IColumnUnique::IndexesWithOverflow ColumnUnique<ColumnType>::uniqueInsertRangeWi
     size_t max_dictionary_size)
 {
     auto overflowed_keys = column_holder->cloneEmpty();
-    auto overflowed_keys_ptr = typeid_cast<ColumnType *>(overflowed_keys.get());
+    auto * overflowed_keys_ptr = typeid_cast<ColumnType *>(overflowed_keys.get());
     if (!overflowed_keys_ptr)
         throw Exception(ErrorCodes::LOGICAL_ERROR, "Invalid keys type for ColumnUnique.");
 
diff --git a/src/Columns/ReverseIndex.h b/src/Columns/ReverseIndex.h
index 2e59cea2c22..e2c422a0b3b 100644
--- a/src/Columns/ReverseIndex.h
+++ b/src/Columns/ReverseIndex.h
@@ -86,7 +86,7 @@ struct ReverseIndexHashTableCell
     {
         /// Careful: apparently this uses SFINAE to redefine isZero for all types
         /// except the IndexType, for which the default ZeroTraits::isZero is used.
-        static_assert(!std::is_same_v<typename std::decay<T>::type, typename std::decay<IndexType>::type>);
+        static_assert(!std::is_same_v<typename std::decay_t<T>, typename std::decay_t<IndexType>>);
         return false;
     }
 
diff --git a/src/Common/AllocatorWithMemoryTracking.h b/src/Common/AllocatorWithMemoryTracking.h
index b43870e05b2..52bfe1cc3fa 100644
--- a/src/Common/AllocatorWithMemoryTracking.h
+++ b/src/Common/AllocatorWithMemoryTracking.h
@@ -26,10 +26,10 @@ struct AllocatorWithMemoryTracking
 
     [[nodiscard]] T * allocate(size_t n)
     {
-        if (n > std::numeric_limits<size_t>::max() / sizeof(T))
+        if (n > std::numeric_limits<size_t>::max() / sizeof(T)) /// NOLINT(bugprone-sizeof-expression)
             throw std::bad_alloc();
 
-        size_t bytes = n * sizeof(T);
+        size_t bytes = n * sizeof(T); /// NOLINT(bugprone-sizeof-expression)
         auto trace = CurrentMemoryTracker::alloc(bytes);
 
         T * p = static_cast<T *>(malloc(bytes));
@@ -43,7 +43,7 @@ struct AllocatorWithMemoryTracking
 
     void deallocate(T * p, size_t n) noexcept
     {
-        size_t bytes = n * sizeof(T);
+        size_t bytes = n * sizeof(T); /// NOLINT(bugprone-sizeof-expression)
 
         free(p);
         auto trace = CurrentMemoryTracker::free(bytes);
diff --git a/src/Common/Arena.h b/src/Common/Arena.h
index ba5b9ea9205..db0e4883553 100644
--- a/src/Common/Arena.h
+++ b/src/Common/Arena.h
@@ -49,7 +49,7 @@ private:
 
         MemoryChunk() = default;
 
-        void swap(MemoryChunk & other)
+        void swap(MemoryChunk & other) noexcept
         {
             std::swap(begin, other.begin);
             std::swap(pos, other.pos);
@@ -57,12 +57,12 @@ private:
             prev.swap(other.prev);
         }
 
-        MemoryChunk(MemoryChunk && other)
+        MemoryChunk(MemoryChunk && other) noexcept
         {
             *this = std::move(other);
         }
 
-        MemoryChunk & operator=(MemoryChunk && other)
+        MemoryChunk & operator=(MemoryChunk && other) noexcept
         {
             swap(other);
             return *this;
diff --git a/src/Common/FrequencyHolder.h b/src/Common/FrequencyHolder.h
index 73675ed9814..64207dc5423 100644
--- a/src/Common/FrequencyHolder.h
+++ b/src/Common/FrequencyHolder.h
@@ -47,7 +47,6 @@ public:
         HashMap<UInt16, Float64> map;
     };
 
-public:
     using Map = HashMap<StringRef, Float64>;
     using Container = std::vector<Language>;
 
diff --git a/src/Common/HTTPConnectionPool.h b/src/Common/HTTPConnectionPool.h
index 7fd0847f5a7..a883a18ab8e 100644
--- a/src/Common/HTTPConnectionPool.h
+++ b/src/Common/HTTPConnectionPool.h
@@ -44,11 +44,12 @@ public:
     virtual const Metrics & getMetrics() const = 0;
     virtual ~IHTTPConnectionPoolForEndpoint() = default;
 
+    IHTTPConnectionPoolForEndpoint(const IHTTPConnectionPoolForEndpoint &) = delete;
+    IHTTPConnectionPoolForEndpoint & operator=(const IHTTPConnectionPoolForEndpoint &) = delete;
+
 protected:
     IHTTPConnectionPoolForEndpoint() = default;
 
-    IHTTPConnectionPoolForEndpoint(const IHTTPConnectionPoolForEndpoint &) = delete;
-    IHTTPConnectionPoolForEndpoint & operator=(const IHTTPConnectionPoolForEndpoint &) = delete;
 };
 
 enum class HTTPConnectionGroupType
@@ -70,11 +71,12 @@ public:
         static constexpr size_t warning_step = 100;
     };
 
-private:
-    HTTPConnectionPools();
     HTTPConnectionPools(const HTTPConnectionPools &) = delete;
     HTTPConnectionPools & operator=(const HTTPConnectionPools &) = delete;
 
+private:
+    HTTPConnectionPools();
+
 public:
     static HTTPConnectionPools & instance();
 
diff --git a/src/Common/HashTable/HashTable.h b/src/Common/HashTable/HashTable.h
index f23c4ca15dd..9050b7ef6d7 100644
--- a/src/Common/HashTable/HashTable.h
+++ b/src/Common/HashTable/HashTable.h
@@ -92,7 +92,8 @@ inline bool bitEquals(T && a, T && b)
     using RealT = std::decay_t<T>;
 
     if constexpr (std::is_floating_point_v<RealT>)
-        return 0 == memcmp(&a, &b, sizeof(RealT));  /// Note that memcmp with constant size is compiler builtin.
+        /// Note that memcmp with constant size is compiler builtin.
+        return 0 == memcmp(&a, &b, sizeof(RealT)); /// NOLINT
     else
         return a == b;
 }
@@ -644,7 +645,7 @@ protected:
 
         /// Copy to a new location and zero the old one.
         x.setHash(hash_value);
-        memcpy(static_cast<void*>(&buf[place_value]), &x, sizeof(x));
+        memcpy(static_cast<void*>(&buf[place_value]), &x, sizeof(x)); /// NOLINT(bugprone-undefined-memory-manipulation)
         x.setZero();
 
         /// Then the elements that previously were in collision with this can move to the old place.
diff --git a/src/Common/HostResolvePool.h b/src/Common/HostResolvePool.h
index 4f127f05253..ec4594bc8dd 100644
--- a/src/Common/HostResolvePool.h
+++ b/src/Common/HostResolvePool.h
@@ -67,8 +67,8 @@ public:
     class Entry
     {
     public:
-        explicit Entry(Entry && entry) = default;
-        explicit Entry(Entry & entry) = delete;
+        Entry(Entry && entry) = default;
+        Entry(Entry & entry) = delete;
 
         // no access as r-value
         const String * operator->() && = delete;
@@ -89,7 +89,7 @@ public:
 
         Entry(HostResolver & pool_, Poco::Net::IPAddress address_)
             : pool(pool_.getWeakFromThis())
-            , address(std::move(address_))
+            , address(address_)
             , resolved_host(address.toString())
         { }
 
@@ -126,14 +126,14 @@ protected:
     struct Record
     {
         Record(Poco::Net::IPAddress address_, Poco::Timestamp resolve_time_)
-            : address(std::move(address_))
+            : address(address_)
             , resolve_time(resolve_time_)
         {}
 
-        explicit Record(Record && rec) = default;
+        Record(Record && rec) = default;
         Record& operator=(Record && s) = default;
 
-        explicit Record(const Record & rec) = default;
+        Record(const Record & rec) = default;
         Record& operator=(const Record & s) = default;
 
         Poco::Net::IPAddress address;
@@ -198,10 +198,11 @@ class HostResolversPool
 {
 private:
     HostResolversPool() = default;
+
+public:
     HostResolversPool(const HostResolversPool &) = delete;
     HostResolversPool & operator=(const HostResolversPool &) = delete;
 
-public:
     static HostResolversPool & instance();
 
     void dropCache();
diff --git a/src/Common/MortonUtils.h b/src/Common/MortonUtils.h
index 591621f7a47..c55b36c6354 100644
--- a/src/Common/MortonUtils.h
+++ b/src/Common/MortonUtils.h
@@ -27,7 +27,7 @@
   */
 
 
-namespace
+namespace impl
 {
     /// After the most significant bit 1, set all subsequent less significant bits to 1 as well.
     inline UInt64 toMask(UInt64 n)
@@ -85,7 +85,7 @@ void intervalBinaryPartition(UInt64 first, UInt64 last, F && callback)
     /// split = 15:   00001111
 
     UInt64 diff = first ^ last;
-    UInt64 mask = toMask(diff) >> 1;
+    UInt64 mask = impl::toMask(diff) >> 1;
 
     /// The current interval represents a whole range with fixed prefix.
     if ((first & mask) == 0 && (last & mask) == mask)
diff --git a/src/Common/NetException.h b/src/Common/NetException.h
index 0ec3a7c423f..09c51949501 100644
--- a/src/Common/NetException.h
+++ b/src/Common/NetException.h
@@ -29,7 +29,7 @@ public:
     }
 
     NetException * clone() const override { return new NetException(*this); }
-    void rethrow() const override { throw *this; }
+    void rethrow() const override { throw *this; } /// NOLINT(cert-err60-cpp)
 
 private:
     const char * name() const noexcept override { return "DB::NetException"; }
diff --git a/src/Common/PODArray.h b/src/Common/PODArray.h
index af863e01fb2..02281eb776a 100644
--- a/src/Common/PODArray.h
+++ b/src/Common/PODArray.h
@@ -301,6 +301,8 @@ public:
     }
 };
 
+/// NOLINTBEGIN(bugprone-sizeof-expression)
+
 template <typename T, size_t initial_bytes, typename TAllocator, size_t pad_right_, size_t pad_left_>
 class PODArray : public PODArrayBase<sizeof(T), initial_bytes, TAllocator, pad_right_, pad_left_>
 {
@@ -755,6 +757,8 @@ public:
     }
 };
 
+/// NOLINTEND(bugprone-sizeof-expression)
+
 template <typename T, size_t initial_bytes, typename TAllocator, size_t pad_right_, size_t pad_left_>
 void swap(PODArray<T, initial_bytes, TAllocator, pad_right_, pad_left_> & lhs, PODArray<T, initial_bytes, TAllocator, pad_right_, pad_left_> & rhs) /// NOLINT
 {
diff --git a/src/Common/ProxyConfiguration.h b/src/Common/ProxyConfiguration.h
index 11a09cb5924..289ae2b6813 100644
--- a/src/Common/ProxyConfiguration.h
+++ b/src/Common/ProxyConfiguration.h
@@ -50,7 +50,7 @@ struct ProxyConfiguration
     bool tunneling = false;
     Protocol original_request_protocol = Protocol::HTTP;
 
-    bool isEmpty() const { return host.size() == 0; }
+    bool isEmpty() const { return host.empty(); }
 };
 
 }
diff --git a/src/Common/Scheduler/Nodes/DynamicResourceManager.h b/src/Common/Scheduler/Nodes/DynamicResourceManager.h
index ff736693664..4b0a3a48b61 100644
--- a/src/Common/Scheduler/Nodes/DynamicResourceManager.h
+++ b/src/Common/Scheduler/Nodes/DynamicResourceManager.h
@@ -85,7 +85,6 @@ private:
         StatePtr state; // hold state to avoid ResourceLink invalidation due to resource deregistration from SchedulerRoot
     };
 
-private:
     SchedulerRoot scheduler;
     std::mutex mutex;
     StatePtr state;
diff --git a/src/Common/Scheduler/Nodes/FairPolicy.h b/src/Common/Scheduler/Nodes/FairPolicy.h
index ce2bf729a04..0a4e55c253b 100644
--- a/src/Common/Scheduler/Nodes/FairPolicy.h
+++ b/src/Common/Scheduler/Nodes/FairPolicy.h
@@ -248,7 +248,6 @@ private:
             parent->activateChild(this);
     }
 
-private:
     /// Beginning of `items` vector is heap of active children: [0; `heap_size`).
     /// Next go inactive children in unsorted order.
     /// NOTE: we have to track vruntime of inactive children for max-min fairness.
diff --git a/src/Common/Scheduler/SchedulerRoot.h b/src/Common/Scheduler/SchedulerRoot.h
index ab3f702a422..7af42fdbbea 100644
--- a/src/Common/Scheduler/SchedulerRoot.h
+++ b/src/Common/Scheduler/SchedulerRoot.h
@@ -231,7 +231,6 @@ private:
         value->next = nullptr;
     }
 
-private:
     void schedulerThread()
     {
         while (!stop_flag.load())
@@ -253,7 +252,6 @@ private:
         request->execute();
     }
 
-private:
     TResource * current = nullptr; // round-robin pointer
     std::unordered_map<ISchedulerNode *, TResource> children; // resources by pointer
     std::atomic<bool> stop_flag = false;
diff --git a/src/Common/ZooKeeper/ZooKeeperImpl.h b/src/Common/ZooKeeper/ZooKeeperImpl.h
index d089ab7cc04..b5ab4f04b8e 100644
--- a/src/Common/ZooKeeper/ZooKeeperImpl.h
+++ b/src/Common/ZooKeeper/ZooKeeperImpl.h
@@ -291,7 +291,7 @@ private:
     class ThreadReference
     {
     public:
-        const ThreadReference & operator = (ThreadFromGlobalPool && thread_)
+        ThreadReference & operator = (ThreadFromGlobalPool && thread_)
         {
             std::lock_guard<std::mutex> l(lock);
             thread = std::move(thread_);
diff --git a/src/Common/ZooKeeper/ZooKeeperRetries.h b/src/Common/ZooKeeper/ZooKeeperRetries.h
index d8d234ba913..39782d08b33 100644
--- a/src/Common/ZooKeeper/ZooKeeperRetries.h
+++ b/src/Common/ZooKeeper/ZooKeeperRetries.h
@@ -120,7 +120,7 @@ public:
 
         iteration_succeeded = false;
         user_error.code = code;
-        user_error.message = std::move(message);
+        user_error.message = message;
         user_error.exception = exception;
         keeper_error = KeeperError{};
     }
diff --git a/src/Common/memory.h b/src/Common/memory.h
index a4c9d46e21b..a828ba7a38e 100644
--- a/src/Common/memory.h
+++ b/src/Common/memory.h
@@ -215,7 +215,7 @@ inline ALWAYS_INLINE size_t untrackMemory(void * ptr [[maybe_unused]], Allocatio
 #endif
         trace = CurrentMemoryTracker::free(actual_size);
     }
-    catch (...)
+    catch (...) /// NOLINT(bugprone-empty-catch)
     {
     }
 
diff --git a/src/Common/mysqlxx/mysqlxx/Transaction.h b/src/Common/mysqlxx/mysqlxx/Transaction.h
index 38c175d69d5..4f06042eb06 100644
--- a/src/Common/mysqlxx/mysqlxx/Transaction.h
+++ b/src/Common/mysqlxx/mysqlxx/Transaction.h
@@ -27,7 +27,7 @@ public:
             if (!finished)
                 rollback();
         }
-        catch (...)
+        catch (...) /// NOLINT(bugprone-empty-catch)
         {
         }
     }
diff --git a/src/Common/mysqlxx/mysqlxx/Types.h b/src/Common/mysqlxx/mysqlxx/Types.h
index 883eb41989e..b58ed20d740 100644
--- a/src/Common/mysqlxx/mysqlxx/Types.h
+++ b/src/Common/mysqlxx/mysqlxx/Types.h
@@ -36,7 +36,7 @@ using Int64 = int64_t;
 using UInt32 = uint32_t;
 using Int32 = int32_t;
 
-using MYSQL_LENGTH = unsigned long;
+using MYSQL_LENGTH = unsigned long; /// NOLINT
 using MYSQL_LENGTHS = MYSQL_LENGTH *;
 using MYSQL_FIELDS = MYSQL_FIELD *;
 
diff --git a/src/Common/threadPoolCallbackRunner.h b/src/Common/threadPoolCallbackRunner.h
index 2b943110273..6f7892ae4bb 100644
--- a/src/Common/threadPoolCallbackRunner.h
+++ b/src/Common/threadPoolCallbackRunner.h
@@ -57,7 +57,7 @@ template <typename Result, typename T>
 std::future<Result> scheduleFromThreadPool(T && task, ThreadPool & pool, const std::string & thread_name, Priority priority = {})
 {
     auto schedule = threadPoolCallbackRunner<Result, T>(pool, thread_name);
-    return schedule(std::move(task), priority);
+    return schedule(std::move(task), priority); /// NOLINT
 }
 
 }
diff --git a/src/Compression/CompressionCodecDeflateQpl.h b/src/Compression/CompressionCodecDeflateQpl.h
index 42d9bb69c31..86fd9051bd8 100644
--- a/src/Compression/CompressionCodecDeflateQpl.h
+++ b/src/Compression/CompressionCodecDeflateQpl.h
@@ -26,7 +26,7 @@ public:
 
     qpl_job * acquireJob(UInt32 & job_id);
     void releaseJob(UInt32 job_id);
-    const bool & isJobPoolReady() { return job_pool_ready; }
+    const bool & isJobPoolReady() const { return job_pool_ready; }
 
 private:
     bool tryLockJob(UInt32 index);
diff --git a/src/Coordination/WriteBufferFromNuraftBuffer.h b/src/Coordination/WriteBufferFromNuraftBuffer.h
index c9ca1e2a227..61b8632631a 100644
--- a/src/Coordination/WriteBufferFromNuraftBuffer.h
+++ b/src/Coordination/WriteBufferFromNuraftBuffer.h
@@ -16,7 +16,7 @@ public:
     ~WriteBufferFromNuraftBuffer() override;
 
 private:
-    void finalizeImpl() override final;
+    void finalizeImpl() final;
 
     void nextImpl() override;
 
diff --git a/src/Core/Field.h b/src/Core/Field.h
index 43f175cb476..aed5fab2106 100644
--- a/src/Core/Field.h
+++ b/src/Core/Field.h
@@ -40,6 +40,7 @@ using FieldVector = std::vector<Field, AllocatorWithMemoryTracking<Field>>;
 /// construct a Field of Array or a Tuple type. An alternative approach would be
 /// to construct both of these types from FieldVector, and have the caller
 /// specify the desired Field type explicitly.
+/// NOLINTBEGIN(modernize-type-traits)
 #define DEFINE_FIELD_VECTOR(X) \
 struct X : public FieldVector \
 { \
@@ -48,6 +49,7 @@ struct X : public FieldVector \
 
 DEFINE_FIELD_VECTOR(Array);
 DEFINE_FIELD_VECTOR(Tuple);
+/// NOLINTEND(modernize-type-traits)
 
 /// An array with the following structure: [(key1, value1), (key2, value2), ...]
 DEFINE_FIELD_VECTOR(Map); /// TODO: use map instead of vector.
diff --git a/src/Core/MySQL/MySQLReplication.h b/src/Core/MySQL/MySQLReplication.h
index 2e2023ff47f..3387d952711 100644
--- a/src/Core/MySQL/MySQLReplication.h
+++ b/src/Core/MySQL/MySQLReplication.h
@@ -546,7 +546,7 @@ namespace MySQLReplication
         virtual void setGTIDSets(GTIDSets sets) = 0;
         virtual void setChecksumSignatureLength(size_t checksum_signature_length_) = 0;
 
-        virtual ~IFlavor() override = default;
+        ~IFlavor() override = default;
     };
 
     class MySQLFlavor : public IFlavor
diff --git a/src/Core/Settings.h b/src/Core/Settings.h
index e6adb00137f..b5e519fb8b4 100644
--- a/src/Core/Settings.h
+++ b/src/Core/Settings.h
@@ -1194,7 +1194,6 @@ class IColumn;
     FORMAT_FACTORY_SETTINGS(M, ALIAS)  \
     OBSOLETE_FORMAT_SETTINGS(M, ALIAS) \
 
-/// NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
 DECLARE_SETTINGS_TRAITS_ALLOW_CUSTOM_SETTINGS(SettingsTraits, LIST_OF_SETTINGS)
 
 
@@ -1239,7 +1238,6 @@ private:
 /*
  * User-specified file format settings for File and URL engines.
  */
-/// NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
 DECLARE_SETTINGS_TRAITS(FormatFactorySettingsTraits, LIST_OF_ALL_FORMAT_SETTINGS)
 
 struct FormatFactorySettings : public BaseSettings<FormatFactorySettingsTraits>
diff --git a/src/Core/tests/gtest_charset_conv.cpp b/src/Core/tests/gtest_charset_conv.cpp
index 9b501b5f8fc..073b0dd74b4 100644
--- a/src/Core/tests/gtest_charset_conv.cpp
+++ b/src/Core/tests/gtest_charset_conv.cpp
@@ -5,14 +5,12 @@
 namespace DB
 {
 
-// NOLINTBEGIN(clang-analyzer-optin.performance.Padding)
 struct CheckResult
 {
     Int32 id;
     String name;
     bool need_convert;
 };
-// NOLINTEND(clang-analyzer-optin.performance.Padding)
 
 TEST(CharsetTest, CharsetTest)
 {
diff --git a/src/Daemon/BaseDaemon.h b/src/Daemon/BaseDaemon.h
index 952cf61d8e0..a0f47c44460 100644
--- a/src/Daemon/BaseDaemon.h
+++ b/src/Daemon/BaseDaemon.h
@@ -103,7 +103,7 @@ public:
 
     GraphiteWriter * getGraphiteWriter(const std::string & config_name = DEFAULT_GRAPHITE_CONFIG_NAME)
     {
-        if (graphite_writers.count(config_name))
+        if (graphite_writers.contains(config_name))
             return graphite_writers[config_name].get();
         return nullptr;
     }
@@ -183,7 +183,7 @@ std::optional<std::reference_wrapper<Daemon>> BaseDaemon::tryGetInstance()
     {
         ptr = dynamic_cast<Daemon *>(&Poco::Util::Application::instance());
     }
-    catch (const Poco::NullPointerException &)
+    catch (const Poco::NullPointerException &) /// NOLINT(bugprone-empty-catch)
     {
         /// if daemon doesn't exist than instance() throw NullPointerException
     }
diff --git a/src/DataTypes/NumberTraits.h b/src/DataTypes/NumberTraits.h
index cf283d3358c..59a64017af3 100644
--- a/src/DataTypes/NumberTraits.h
+++ b/src/DataTypes/NumberTraits.h
@@ -217,11 +217,13 @@ template <typename A> struct ToInteger
 
 // CLICKHOUSE-29. The same depth, different signs
 // NOTE: This case is applied for 64-bit integers only (for backward compatibility), but could be used for any-bit integers
+/// NOLINTBEGIN(misc-redundant-expression)
 template <typename A, typename B>
 constexpr bool LeastGreatestSpecialCase =
     std::is_integral_v<A> && std::is_integral_v<B>
     && (8 == sizeof(A) && sizeof(A) == sizeof(B))
     && (is_signed_v<A> ^ is_signed_v<B>);
+/// NOLINTEND(misc-redundant-expression)
 
 template <typename A, typename B>
 using ResultOfLeast = std::conditional_t<LeastGreatestSpecialCase<A, B>,
diff --git a/src/DataTypes/Serializations/SerializationCustomSimpleText.h b/src/DataTypes/Serializations/SerializationCustomSimpleText.h
index c80a57e234c..f7aea8697ff 100644
--- a/src/DataTypes/Serializations/SerializationCustomSimpleText.h
+++ b/src/DataTypes/Serializations/SerializationCustomSimpleText.h
@@ -18,7 +18,7 @@ public:
     explicit SerializationCustomSimpleText(const SerializationPtr & nested_);
 
     // Methods that subclasses must override in order to get full serialization/deserialization support.
-    virtual void serializeText(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings &) const override = 0;
+    void serializeText(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings &) const override = 0;
     /// whole = true means that buffer contains only one value, so we should read until EOF.
     /// It's needed to check if there is garbage after parsed field.
     virtual void deserializeText(IColumn & column, ReadBuffer & istr, const FormatSettings &, bool whole) const = 0;
diff --git a/src/DataTypes/Serializations/SerializationSparse.h b/src/DataTypes/Serializations/SerializationSparse.h
index 2d31fba2509..b1ed7b613f0 100644
--- a/src/DataTypes/Serializations/SerializationSparse.h
+++ b/src/DataTypes/Serializations/SerializationSparse.h
@@ -27,7 +27,7 @@ public:
 
     Kind getKind() const override { return Kind::SPARSE; }
 
-    virtual void enumerateStreams(
+    void enumerateStreams(
         EnumerateStreamsSettings & settings,
         const StreamCallback & callback,
         const SubstreamData & data) const override;
diff --git a/src/DataTypes/Serializations/SerializationVariantElement.cpp b/src/DataTypes/Serializations/SerializationVariantElement.cpp
index 053f8d22d5a..7d4487fe6da 100644
--- a/src/DataTypes/Serializations/SerializationVariantElement.cpp
+++ b/src/DataTypes/Serializations/SerializationVariantElement.cpp
@@ -205,8 +205,8 @@ void SerializationVariantElement::removeVariantFromPath(DB::ISerialization::Subs
 SerializationVariantElement::VariantSubcolumnCreator::VariantSubcolumnCreator(
     const ColumnPtr & local_discriminators_,
     const String & variant_element_name_,
-    const ColumnVariant::Discriminator global_variant_discriminator_,
-    const ColumnVariant::Discriminator local_variant_discriminator_)
+    ColumnVariant::Discriminator global_variant_discriminator_,
+    ColumnVariant::Discriminator local_variant_discriminator_)
     : local_discriminators(local_discriminators_)
     , variant_element_name(variant_element_name_)
     , global_variant_discriminator(global_variant_discriminator_)
diff --git a/src/DataTypes/Serializations/SerializationVariantElement.h b/src/DataTypes/Serializations/SerializationVariantElement.h
index c343c219cf3..aafecf43d39 100644
--- a/src/DataTypes/Serializations/SerializationVariantElement.h
+++ b/src/DataTypes/Serializations/SerializationVariantElement.h
@@ -75,8 +75,8 @@ private:
         VariantSubcolumnCreator(
             const ColumnPtr & local_discriminators_,
             const String & variant_element_name_,
-            const ColumnVariant::Discriminator global_variant_discriminator_,
-            const ColumnVariant::Discriminator local_variant_discriminator_);
+            ColumnVariant::Discriminator global_variant_discriminator_,
+            ColumnVariant::Discriminator local_variant_discriminator_);
 
         DataTypePtr create(const DataTypePtr & prev) const override;
         ColumnPtr create(const ColumnPtr & prev) const override;
diff --git a/src/Databases/DatabasesOverlay.h b/src/Databases/DatabasesOverlay.h
index b58df506f70..859063a4ac4 100644
--- a/src/Databases/DatabasesOverlay.h
+++ b/src/Databases/DatabasesOverlay.h
@@ -23,7 +23,6 @@ public:
 
     String getEngineName() const override { return "Overlay"; }
 
-public:
     bool isTableExist(const String & table_name, ContextPtr context) const override;
 
     StoragePtr tryGetTable(const String & table_name, ContextPtr context) const override;
diff --git a/src/Dictionaries/CacheDictionary.cpp b/src/Dictionaries/CacheDictionary.cpp
index 935658719db..fbb04eab3e4 100644
--- a/src/Dictionaries/CacheDictionary.cpp
+++ b/src/Dictionaries/CacheDictionary.cpp
@@ -308,7 +308,7 @@ ColumnUInt8::Ptr CacheDictionary<dictionary_key_type>::hasKeys(const Columns & k
         /// Write lock on storage
         const ProfilingScopedWriteRWLock write_lock{rw_lock, ProfileEvents::DictCacheLockWriteNs};
 
-        result_of_fetch_from_storage = cache_storage_ptr->fetchColumnsForKeys(keys, request);
+        result_of_fetch_from_storage = cache_storage_ptr->fetchColumnsForKeys(keys, request, /*default_mask*/ nullptr);
     }
 
     size_t found_keys_size = result_of_fetch_from_storage.found_keys_size;
diff --git a/src/Dictionaries/CacheDictionary.h b/src/Dictionaries/CacheDictionary.h
index c02fb91c60e..a23f64e3e3f 100644
--- a/src/Dictionaries/CacheDictionary.h
+++ b/src/Dictionaries/CacheDictionary.h
@@ -171,7 +171,7 @@ private:
         const PaddedPODArray<KeyState> & key_index_to_fetched_columns_from_storage_result,
         const MutableColumns & fetched_columns_during_update,
         const HashMap<KeyType, size_t> & found_keys_to_fetched_columns_during_update_index,
-        IColumn::Filter * const default_mask = nullptr) const;
+        IColumn::Filter * default_mask = nullptr) const;
 
     void update(CacheDictionaryUpdateUnitPtr<dictionary_key_type> update_unit_ptr);
 
diff --git a/src/Dictionaries/CacheDictionaryStorage.h b/src/Dictionaries/CacheDictionaryStorage.h
index 4cbbaa070d0..01217c58e31 100644
--- a/src/Dictionaries/CacheDictionaryStorage.h
+++ b/src/Dictionaries/CacheDictionaryStorage.h
@@ -73,7 +73,7 @@ public:
     SimpleKeysStorageFetchResult fetchColumnsForKeys(
         const PaddedPODArray<UInt64> & keys,
         const DictionaryStorageFetchRequest & fetch_request,
-        IColumn::Filter * const default_mask = nullptr) override
+        IColumn::Filter * const default_mask) override
     {
         if constexpr (dictionary_key_type == DictionaryKeyType::Simple)
             return fetchColumnsForKeysImpl<SimpleKeysStorageFetchResult>(keys, fetch_request, default_mask);
@@ -110,7 +110,7 @@ public:
     ComplexKeysStorageFetchResult fetchColumnsForKeys(
         const PaddedPODArray<StringRef> & keys,
         const DictionaryStorageFetchRequest & column_fetch_requests,
-        IColumn::Filter * const default_mask = nullptr) override
+        IColumn::Filter * const default_mask) override
     {
         if constexpr (dictionary_key_type == DictionaryKeyType::Complex)
             return fetchColumnsForKeysImpl<ComplexKeysStorageFetchResult>(keys, column_fetch_requests, default_mask);
diff --git a/src/Dictionaries/ICacheDictionaryStorage.h b/src/Dictionaries/ICacheDictionaryStorage.h
index 047d67135a6..dcd7434946f 100644
--- a/src/Dictionaries/ICacheDictionaryStorage.h
+++ b/src/Dictionaries/ICacheDictionaryStorage.h
@@ -82,7 +82,7 @@ public:
     virtual SimpleKeysStorageFetchResult fetchColumnsForKeys(
         const PaddedPODArray<UInt64> & keys,
         const DictionaryStorageFetchRequest & fetch_request,
-        IColumn::Filter * default_mask = nullptr) = 0;
+        IColumn::Filter * default_mask) = 0;
 
     /// Fetch columns for keys, this method is not write thread safe
     virtual void insertColumnsForKeys(const PaddedPODArray<UInt64> & keys, Columns columns) = 0;
@@ -100,7 +100,7 @@ public:
     virtual ComplexKeysStorageFetchResult fetchColumnsForKeys(
         const PaddedPODArray<StringRef> & keys,
         const DictionaryStorageFetchRequest & column_fetch_requests,
-        IColumn::Filter * default_mask = nullptr) = 0;
+        IColumn::Filter * default_mask) = 0;
 
     /// Fetch columns for keys, this method is not write thread safe
     virtual void insertColumnsForKeys(const PaddedPODArray<StringRef> & keys, Columns columns) = 0;
diff --git a/src/Dictionaries/SSDCacheDictionaryStorage.h b/src/Dictionaries/SSDCacheDictionaryStorage.h
index acebea676a5..73c96e0aedc 100644
--- a/src/Dictionaries/SSDCacheDictionaryStorage.h
+++ b/src/Dictionaries/SSDCacheDictionaryStorage.h
@@ -870,7 +870,7 @@ public:
     SimpleKeysStorageFetchResult fetchColumnsForKeys(
         const PaddedPODArray<UInt64> & keys,
         const DictionaryStorageFetchRequest & fetch_request,
-        IColumn::Filter * const default_mask = nullptr) override
+        IColumn::Filter * const default_mask) override
     {
         if constexpr (dictionary_key_type == DictionaryKeyType::Simple)
             return fetchColumnsForKeysImpl<SimpleKeysStorageFetchResult>(keys, fetch_request, default_mask);
@@ -907,7 +907,7 @@ public:
     ComplexKeysStorageFetchResult fetchColumnsForKeys(
         const PaddedPODArray<StringRef> & keys,
         const DictionaryStorageFetchRequest & fetch_request,
-        IColumn::Filter * const default_mask = nullptr) override
+        IColumn::Filter * const default_mask) override
     {
         if constexpr (dictionary_key_type == DictionaryKeyType::Complex)
             return fetchColumnsForKeysImpl<ComplexKeysStorageFetchResult>(keys, fetch_request, default_mask);
diff --git a/src/Disks/IDiskTransaction.h b/src/Disks/IDiskTransaction.h
index 975c41cb70b..7df1b71eb2b 100644
--- a/src/Disks/IDiskTransaction.h
+++ b/src/Disks/IDiskTransaction.h
@@ -62,8 +62,8 @@ public:
     virtual void copyFile(
         const std::string & from_file_path,
         const std::string & to_file_path,
-        const ReadSettings & read_settings = {},
-        const WriteSettings & write_settings = {}) = 0;
+        const ReadSettings & read_settings,
+        const WriteSettings & write_settings) = 0;
 
     /// Open the file for write and return WriteBufferFromFileBase object.
     virtual std::unique_ptr<WriteBufferFromFileBase> writeFile( /// NOLINT
diff --git a/src/Disks/IO/IOUringReader.h b/src/Disks/IO/IOUringReader.h
index a29781171e5..89e71e4b215 100644
--- a/src/Disks/IO/IOUringReader.h
+++ b/src/Disks/IO/IOUringReader.h
@@ -78,7 +78,7 @@ private:
 public:
     explicit IOUringReader(uint32_t entries_);
 
-    inline bool isSupported() { return is_supported; }
+    bool isSupported() const { return is_supported; }
     std::future<Result> submit(Request request) override;
     Result execute(Request /* request */) override { throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Method `execute` not implemented for IOUringReader"); }
 
diff --git a/src/Disks/IVolume.h b/src/Disks/IVolume.h
index bc6706a1829..2da896a3514 100644
--- a/src/Disks/IVolume.h
+++ b/src/Disks/IVolume.h
@@ -64,7 +64,7 @@ public:
         DiskSelectorPtr disk_selector
     );
 
-    virtual ReservationPtr reserve(UInt64 bytes) override = 0;
+    ReservationPtr reserve(UInt64 bytes) override = 0;
 
     /// This is a volume.
     bool isVolume() const override { return true; }
diff --git a/src/Disks/ObjectStorages/DiskObjectStorage.cpp b/src/Disks/ObjectStorages/DiskObjectStorage.cpp
index 16183ec20c1..696a0ef7416 100644
--- a/src/Disks/ObjectStorages/DiskObjectStorage.cpp
+++ b/src/Disks/ObjectStorages/DiskObjectStorage.cpp
@@ -204,7 +204,7 @@ void DiskObjectStorage::copyFile( /// NOLINT
             /// It may use s3-server-side copy
             auto & to_disk_object_storage = dynamic_cast<DiskObjectStorage &>(to_disk);
             auto transaction = createObjectStorageTransactionToAnotherDisk(to_disk_object_storage);
-            transaction->copyFile(from_file_path, to_file_path);
+            transaction->copyFile(from_file_path, to_file_path, /*read_settings*/ {}, /*write_settings*/ {});
             transaction->commit();
     }
     else
diff --git a/src/Disks/ObjectStorages/ObjectStorageIterator.h b/src/Disks/ObjectStorages/ObjectStorageIterator.h
index 841b0ea6664..9af2593579a 100644
--- a/src/Disks/ObjectStorages/ObjectStorageIterator.h
+++ b/src/Disks/ObjectStorages/ObjectStorageIterator.h
@@ -54,7 +54,7 @@ public:
         return batch;
     }
 
-    virtual std::optional<RelativePathsWithMetadata> getCurrrentBatchAndScheduleNext() override
+    std::optional<RelativePathsWithMetadata> getCurrrentBatchAndScheduleNext() override
     {
         return std::nullopt;
     }
diff --git a/src/Disks/ObjectStorages/S3/diskSettings.h b/src/Disks/ObjectStorages/S3/diskSettings.h
index 83bf7b179ef..e461daa99e2 100644
--- a/src/Disks/ObjectStorages/S3/diskSettings.h
+++ b/src/Disks/ObjectStorages/S3/diskSettings.h
@@ -9,14 +9,6 @@
 
 #include <IO/S3/Client.h>
 
-namespace Aws
-{
-namespace S3
-{
-class Client;
-}
-}
-
 namespace DB
 {
 
diff --git a/src/Functions/CountSubstringsImpl.h b/src/Functions/CountSubstringsImpl.h
index 8ba9ee99de8..9ff3e4e1f2a 100644
--- a/src/Functions/CountSubstringsImpl.h
+++ b/src/Functions/CountSubstringsImpl.h
@@ -47,7 +47,7 @@ struct CountSubstringsImpl
         const UInt8 * pos = begin;
 
         /// FIXME: suboptimal
-        memset(&res[0], 0, res.size() * sizeof(res[0]));
+        memset(&res[0], 0, res.size() * sizeof(res[0])); /// NOLINT(readability-container-data-pointer)
 
         if (needle.empty())
             return; // Return all zeros
diff --git a/src/Functions/CustomWeekTransforms.h b/src/Functions/CustomWeekTransforms.h
index b8d25cc30b6..75fb3c32f16 100644
--- a/src/Functions/CustomWeekTransforms.h
+++ b/src/Functions/CustomWeekTransforms.h
@@ -58,7 +58,7 @@ struct CustomWeekTransformImpl
     template <typename Transform>
     static ColumnPtr execute(const ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t /*input_rows_count*/, Transform transform = {})
     {
-        const auto op = WeekTransformer<typename FromDataType::FieldType, typename ToDataType::FieldType, Transform, is_extended_result>{std::move(transform)};
+        const auto op = WeekTransformer<typename FromDataType::FieldType, typename ToDataType::FieldType, Transform, is_extended_result>{transform};
 
         static constexpr UInt8 default_week_mode = 0;
         UInt8 week_mode = default_week_mode;
diff --git a/src/Functions/FunctionConstantBase.h b/src/Functions/FunctionConstantBase.h
index ad969268713..9b999af38b6 100644
--- a/src/Functions/FunctionConstantBase.h
+++ b/src/Functions/FunctionConstantBase.h
@@ -13,8 +13,9 @@ class FunctionConstantBase : public IFunction
 {
 public:
     template <typename U>
-    explicit FunctionConstantBase(U && constant_value_, bool is_distributed_ = false)
-        : constant_value(static_cast<T>(std::forward<U>(constant_value_))), is_distributed(is_distributed_)
+    explicit FunctionConstantBase(const U & constant_value_, bool is_distributed_ = false)
+        : constant_value(static_cast<T>(constant_value_))
+        , is_distributed(is_distributed_)
     {
     }
 
diff --git a/src/Functions/FunctionsAES.h b/src/Functions/FunctionsAES.h
index a03f0b602b9..3bb264dfaec 100644
--- a/src/Functions/FunctionsAES.h
+++ b/src/Functions/FunctionsAES.h
@@ -96,7 +96,7 @@ inline void validateCipherMode(const EVP_CIPHER * evp_cipher)
 {
     if constexpr (compatibility_mode == CompatibilityMode::MySQL)
     {
-        switch (EVP_CIPHER_mode(evp_cipher))
+        switch (EVP_CIPHER_mode(evp_cipher)) /// NOLINT(bugprone-switch-missing-default-case)
         {
             case EVP_CIPH_ECB_MODE: [[fallthrough]];
             case EVP_CIPH_CBC_MODE: [[fallthrough]];
@@ -107,7 +107,7 @@ inline void validateCipherMode(const EVP_CIPHER * evp_cipher)
     }
     else if constexpr (compatibility_mode == CompatibilityMode::OpenSSL)
     {
-        switch (EVP_CIPHER_mode(evp_cipher))
+        switch (EVP_CIPHER_mode(evp_cipher)) /// NOLINT(bugprone-switch-missing-default-case)
         {
             case EVP_CIPH_ECB_MODE: [[fallthrough]];
             case EVP_CIPH_CBC_MODE: [[fallthrough]];
diff --git a/src/Functions/FunctionsBitmap.h b/src/Functions/FunctionsBitmap.h
index 801f2ccd012..22d46fa7728 100644
--- a/src/Functions/FunctionsBitmap.h
+++ b/src/Functions/FunctionsBitmap.h
@@ -519,12 +519,12 @@ public:
                                        "but one of them has type {}.", getName(), arguments[i + 1]->getName());
 
             if (!array_type)
-                throw exception;
+                throw exception; /// NOLINT
 
             auto nested_type = array_type->getNestedType();
             WhichDataType which(nested_type);
             if (!(which.isUInt8() || which.isUInt16() || which.isUInt32() || which.isUInt64()))
-                throw exception;
+                throw exception; /// NOLINT
         }
         return arguments[0];
     }
diff --git a/src/Functions/FunctionsComparison.h b/src/Functions/FunctionsComparison.h
index 3be675f39b3..57aebc11da0 100644
--- a/src/Functions/FunctionsComparison.h
+++ b/src/Functions/FunctionsComparison.h
@@ -283,7 +283,7 @@ struct StringComparisonImpl
         size_t size = a_data.size();
 
         for (size_t i = 0, j = 0; i < size; i += 16, ++j)
-            c[j] = Op::apply(memcmp16(&a_data[i], &b_data[0]), 0);
+            c[j] = Op::apply(memcmp16(&a_data[i], &b_data[0]), 0); /// NOLINT(readability-container-data-pointer)
     }
 
     static void NO_INLINE fixed_string_vector_fixed_string_vector( /// NOLINT
diff --git a/src/Functions/FunctionsExternalDictionaries.h b/src/Functions/FunctionsExternalDictionaries.h
index 011772baab9..d3317e2dfcf 100644
--- a/src/Functions/FunctionsExternalDictionaries.h
+++ b/src/Functions/FunctionsExternalDictionaries.h
@@ -393,8 +393,8 @@ public:
                 throw Exception(ErrorCodes::UNSUPPORTED_METHOD, "Function {} does not support nullable keys", getName());
 
             // Wrap all the attribute types in Array()
-            for (auto it = attribute_types.begin(); it != attribute_types.end(); ++it)
-                *it = std::make_shared<DataTypeArray>(*it);
+            for (auto & attr_type : attribute_types)
+                attr_type = std::make_shared<DataTypeArray>(attr_type);
         }
         if (attribute_types.size() > 1)
         {
diff --git a/src/Functions/FunctionsTimeWindow.h b/src/Functions/FunctionsTimeWindow.h
index 658963cb69c..5145ae79377 100644
--- a/src/Functions/FunctionsTimeWindow.h
+++ b/src/Functions/FunctionsTimeWindow.h
@@ -73,6 +73,8 @@ struct ToStartOfTransform;
     TRANSFORM_TIME(Second)
 #undef TRANSFORM_TIME
 
+/// NOLINTBEGIN(bugprone-macro-parentheses)
+
 #define TRANSFORM_SUBSECONDS(INTERVAL_KIND, DEF_SCALE) \
 template<> \
     struct ToStartOfTransform<IntervalKind::Kind::INTERVAL_KIND> \
@@ -156,6 +158,8 @@ template <> \
     ADD_SUBSECONDS(Nanosecond, 9)
 #undef ADD_SUBSECONDS
 
+/// NOLINTEND(bugprone-macro-parentheses)
+
 template <TimeWindowFunctionName type>
 struct TimeWindowImpl
 {
diff --git a/src/Functions/GatherUtils/Selectors.h b/src/Functions/GatherUtils/Selectors.h
index 00367727a39..1f933c13ba0 100644
--- a/src/Functions/GatherUtils/Selectors.h
+++ b/src/Functions/GatherUtils/Selectors.h
@@ -126,19 +126,19 @@ struct ArrayAndValueSourceSelectorBySink : public ArraySinkSelector<ArrayAndValu
     template <typename Sink, typename ... Args>
     static void selectImpl(Sink && sink, IArraySource & array_source, IValueSource & value_source, Args && ... args)
     {
-        using SynkType = typename std::decay<Sink>::type;
-        using ArraySource = typename SynkType::CompatibleArraySource;
-        using ValueSource = typename SynkType::CompatibleValueSource;
+        using SinkType = typename std::decay_t<Sink>;
+        using ArraySource = typename SinkType::CompatibleArraySource;
+        using ValueSource = typename SinkType::CompatibleValueSource;
 
         auto check_type = [] (auto source_ptr)
         {
             if (source_ptr == nullptr)
                 throw Exception(ErrorCodes::LOGICAL_ERROR, "{} expected {} or {} or {} or {} but got {}",
                                 demangle(typeid(Base).name()),
-                                demangle(typeid(typename SynkType::CompatibleArraySource).name()),
-                                demangle(typeid(ConstSource<typename SynkType::CompatibleArraySource>).name()),
-                                demangle(typeid(typename SynkType::CompatibleValueSource).name()),
-                                demangle(typeid(ConstSource<typename SynkType::CompatibleValueSource>).name()),
+                                demangle(typeid(typename SinkType::CompatibleArraySource).name()),
+                                demangle(typeid(ConstSource<typename SinkType::CompatibleArraySource>).name()),
+                                demangle(typeid(typename SinkType::CompatibleValueSource).name()),
+                                demangle(typeid(ConstSource<typename SinkType::CompatibleValueSource>).name()),
                                 demangle(typeid(*source_ptr).name()));
         };
         auto check_type_and_call_concat = [& sink, & check_type, & args ...] (auto array_source_ptr, auto value_source_ptr)
diff --git a/src/Functions/GatherUtils/Sources.h b/src/Functions/GatherUtils/Sources.h
index 80fb9ce3900..01b63338559 100644
--- a/src/Functions/GatherUtils/Sources.h
+++ b/src/Functions/GatherUtils/Sources.h
@@ -144,6 +144,8 @@ struct NumericArraySource : public ArraySourceImpl<NumericArraySource<T>>
 #pragma clang diagnostic ignored "-Wsuggest-override"
 #pragma clang diagnostic ignored "-Wsuggest-destructor-override"
 
+/// NOLINTBEGIN(hicpp-use-override)
+
 template <typename Base>
 struct ConstSource : public Base
 {
@@ -231,6 +233,8 @@ struct ConstSource : public Base
     }
 };
 
+/// NOLINTEND(hicpp-use-override)
+
 #pragma clang diagnostic pop
 
 struct StringSource
diff --git a/src/Functions/GregorianDate.h b/src/Functions/GregorianDate.h
index 2528223443e..fb00e4276b6 100644
--- a/src/Functions/GregorianDate.h
+++ b/src/Functions/GregorianDate.h
@@ -13,7 +13,7 @@ class WriteBuffer;
 class GregorianDate
 {
 public:
-    GregorianDate() {}
+    GregorianDate() = default;
 
     void init(ReadBuffer & in);
     bool tryInit(ReadBuffer & in);
@@ -84,7 +84,7 @@ private:
 class OrdinalDate
 {
 public:
-    OrdinalDate() {}
+    OrdinalDate() = default;
 
     void init(int32_t year, uint16_t day_of_year);
     bool tryInit(int32_t year, uint16_t day_of_year);
diff --git a/src/Functions/HasSubsequenceImpl.h b/src/Functions/HasSubsequenceImpl.h
index 17955746aa2..630a2afb720 100644
--- a/src/Functions/HasSubsequenceImpl.h
+++ b/src/Functions/HasSubsequenceImpl.h
@@ -14,8 +14,6 @@ namespace ErrorCodes
     extern const int ILLEGAL_TYPE_OF_ARGUMENT;
     extern const int ILLEGAL_COLUMN;
 }
-namespace
-{
 
 using namespace GatherUtils;
 
@@ -154,5 +152,3 @@ private:
 };
 
 }
-
-}
diff --git a/src/Functions/JSONPath/Generator/GeneratorJSONPath.h b/src/Functions/JSONPath/Generator/GeneratorJSONPath.h
index de62be98d31..1016d776be0 100644
--- a/src/Functions/JSONPath/Generator/GeneratorJSONPath.h
+++ b/src/Functions/JSONPath/Generator/GeneratorJSONPath.h
@@ -35,7 +35,7 @@ public:
         }
         const auto * query = path->jsonpath_query;
 
-        for (auto child_ast : query->children)
+        for (const auto & child_ast : query->children)
         {
             if (typeid_cast<ASTJSONPathRoot *>(child_ast.get()))
             {
diff --git a/src/Functions/LowerUpperUTF8Impl.h b/src/Functions/LowerUpperUTF8Impl.h
index 460f75f9bde..7ca98166576 100644
--- a/src/Functions/LowerUpperUTF8Impl.h
+++ b/src/Functions/LowerUpperUTF8Impl.h
@@ -174,7 +174,7 @@ private:
 
     static void array(const UInt8 * src, const UInt8 * src_end, const ColumnString::Offsets & offsets, UInt8 * dst)
     {
-        auto offset_it = offsets.begin();
+        const auto * offset_it = offsets.begin();
         const UInt8 * begin = src;
 
 #ifdef __SSE2__
diff --git a/src/Functions/URL/domain.h b/src/Functions/URL/domain.h
index f38f106e9a2..87f5aeffda7 100644
--- a/src/Functions/URL/domain.h
+++ b/src/Functions/URL/domain.h
@@ -88,7 +88,7 @@ exloop: if ((scheme_end - pos) > 2 && *pos == ':' && *(pos + 1) == '/' && *(pos
     const auto * start_of_host = pos;
     for (; pos < end; ++pos)
     {
-        switch (*pos)
+        switch (*pos) /// NOLINT(bugprone-switch-missing-default-case)
         {
         case '.':
             if (has_open_bracket)
@@ -220,7 +220,7 @@ exloop: if ((scheme_end - pos) > 2 && *pos == ':' && *(pos + 1) == '/' && *(pos
     const auto * start_of_host = pos;
     for (; pos < end; ++pos)
     {
-        switch (*pos)
+        switch (*pos) /// NOLINT(bugprone-switch-missing-default-case)
         {
         case '.':
             dot_pos = pos;
diff --git a/src/Functions/UniqTheta/FunctionsUniqTheta.h b/src/Functions/UniqTheta/FunctionsUniqTheta.h
index 2d616841c7f..c312dcc09f5 100644
--- a/src/Functions/UniqTheta/FunctionsUniqTheta.h
+++ b/src/Functions/UniqTheta/FunctionsUniqTheta.h
@@ -137,8 +137,8 @@ namespace DB
 
             for (size_t i = 0; i < input_rows_count; ++i)
             {
-                const AggregateDataPtr data_ptr_0 = is_column_const[0] ? container0[0] : container0[i];
-                const AggregateDataPtr data_ptr_1 = is_column_const[1] ? container1[0] : container1[i];
+                AggregateDataPtr data_ptr_0 = is_column_const[0] ? container0[0] : container0[i];
+                AggregateDataPtr data_ptr_1 = is_column_const[1] ? container1[0] : container1[i];
 
                 col_to->insertFrom(data_ptr_0);
                 AggregateFunctionUniqThetaData & sketch_data_1 = *reinterpret_cast<AggregateFunctionUniqThetaData *>(col_to->getData()[i]);
diff --git a/src/Functions/UserDefined/UserDefinedSQLObjectsBackup.cpp b/src/Functions/UserDefined/UserDefinedSQLObjectsBackup.cpp
index b7c7e5847bd..c15958f81c9 100644
--- a/src/Functions/UserDefined/UserDefinedSQLObjectsBackup.cpp
+++ b/src/Functions/UserDefined/UserDefinedSQLObjectsBackup.cpp
@@ -88,7 +88,7 @@ restoreUserDefinedSQLObjects(RestorerFromBackup & restorer, const String & data_
     auto backup = restorer.getBackup();
     fs::path data_path_in_backup_fs{data_path_in_backup};
 
-    Strings filenames = backup->listFiles(data_path_in_backup);
+    Strings filenames = backup->listFiles(data_path_in_backup, /*recursive*/ false);
     if (filenames.empty())
         return {}; /// Nothing to restore.
 
diff --git a/src/Functions/geometryConverters.h b/src/Functions/geometryConverters.h
index dba984b4184..97162fa9dd0 100644
--- a/src/Functions/geometryConverters.h
+++ b/src/Functions/geometryConverters.h
@@ -28,9 +28,6 @@ namespace ErrorCodes
     extern const int ILLEGAL_TYPE_OF_ARGUMENT;
 }
 
-namespace
-{
-
 template <typename Point>
 using Ring = boost::geometry::model::ring<Point>;
 
@@ -374,5 +371,3 @@ static void callOnTwoGeometryDataTypes(DataTypePtr left_type, DataTypePtr right_
 }
 
 }
-
-}
diff --git a/src/Functions/stl.hpp b/src/Functions/stl.hpp
index fbfc52f959c..9d4fa30e2e3 100644
--- a/src/Functions/stl.hpp
+++ b/src/Functions/stl.hpp
@@ -1,4 +1,4 @@
-// Dump of https://github.com/ankane/stl-cpp/blob/3b1b3a3e9335cda26c8b0797d8b8d24ac8e350ad/include/stl.hpp. 
+// Dump of https://github.com/ankane/stl-cpp/blob/3b1b3a3e9335cda26c8b0797d8b8d24ac8e350ad/include/stl.hpp.
 // Added to ClickHouse source code and not referenced as a submodule because its easier maintain and modify/customize.
 
 /*!
@@ -24,12 +24,12 @@
 
 namespace stl {
 
-bool est(const float* y, size_t n, size_t len, int ideg, float xs, float* ys, size_t nleft, size_t nright, float* w, bool userw, const float* rw) {
+inline bool est(const float* y, size_t n, size_t len, int ideg, float xs, float* ys, size_t nleft, size_t nright, float* w, bool userw, const float* rw) {
     auto range = ((float) n) - 1.0;
     auto h = std::max(xs - ((float) nleft), ((float) nright) - xs);
 
     if (len > n) {
-        h += (float) ((len - n) / 2);
+        h += (float) ((len - n) / 2); /// NOLINT(bugprone-integer-division)
     }
 
     auto h9 = 0.999 * h;
@@ -89,7 +89,7 @@ bool est(const float* y, size_t n, size_t len, int ideg, float xs, float* ys, si
     }
 }
 
-void ess(const float* y, size_t n, size_t len, int ideg, size_t njump, bool userw, const float* rw, float* ys, float* res) {
+inline void ess(const float* y, size_t n, size_t len, int ideg, size_t njump, bool userw, const float* rw, float* ys, float* res) {
     if (n < 2) {
         ys[0] = y[0];
         return;
@@ -165,7 +165,7 @@ void ess(const float* y, size_t n, size_t len, int ideg, size_t njump, bool user
     }
 }
 
-void ma(const float* x, size_t n, size_t len, float* ave) {
+inline void ma(const float* x, size_t n, size_t len, float* ave) {
     auto newn = n - len + 1;
     auto flen = (float) len;
     auto v = 0.0;
@@ -189,13 +189,13 @@ void ma(const float* x, size_t n, size_t len, float* ave) {
     }
 }
 
-void fts(const float* x, size_t n, size_t np, float* trend, float* work) {
+inline void fts(const float* x, size_t n, size_t np, float* trend, float* work) {
     ma(x, n, np, trend);
     ma(trend, n - np + 1, np, work);
     ma(work, n - 2 * np + 2, 3, trend);
 }
 
-void rwts(const float* y, size_t n, const float* fit, float* rw) {
+inline void rwts(const float* y, size_t n, const float* fit, float* rw) {
     for (size_t i = 0; i < n; i++) {
         rw[i] = fabs(y[i] - fit[i]);
     }
@@ -222,7 +222,7 @@ void rwts(const float* y, size_t n, const float* fit, float* rw) {
     }
 }
 
-void ss(const float* y, size_t n, size_t np, size_t ns, int isdeg, size_t nsjump, bool userw, float* rw, float* season, float* work1, float* work2, float* work3, float* work4) {
+inline void ss(const float* y, size_t n, size_t np, size_t ns, int isdeg, size_t nsjump, bool userw, float* rw, float* season, float* work1, float* work2, float* work3, float* work4) { /// NOLINT(readability-non-const-parameter)
     for (size_t j = 1; j <= np; j++) {
         size_t k = (n - j) / np + 1;
 
@@ -253,7 +253,7 @@ void ss(const float* y, size_t n, size_t np, size_t ns, int isdeg, size_t nsjump
     }
 }
 
-void onestp(const float* y, size_t n, size_t np, size_t ns, size_t nt, size_t nl, int isdeg, int itdeg, int ildeg, size_t nsjump, size_t ntjump, size_t nljump, size_t ni, bool userw, float* rw, float* season, float* trend, float* work1, float* work2, float* work3, float* work4, float* work5) {
+inline void onestp(const float* y, size_t n, size_t np, size_t ns, size_t nt, size_t nl, int isdeg, int itdeg, int ildeg, size_t nsjump, size_t ntjump, size_t nljump, size_t ni, bool userw, float* rw, float* season, float* trend, float* work1, float* work2, float* work3, float* work4, float* work5) {
     for (size_t j = 0; j < ni; j++) {
         for (size_t i = 0; i < n; i++) {
             work1[i] = y[i] - trend[i];
@@ -272,7 +272,7 @@ void onestp(const float* y, size_t n, size_t np, size_t ns, size_t nt, size_t nl
     }
 }
 
-void stl(const float* y, size_t n, size_t np, size_t ns, size_t nt, size_t nl, int isdeg, int itdeg, int ildeg, size_t nsjump, size_t ntjump, size_t nljump, size_t ni, size_t no, float* rw, float* season, float* trend) {
+inline void stl(const float* y, size_t n, size_t np, size_t ns, size_t nt, size_t nl, int isdeg, int itdeg, int ildeg, size_t nsjump, size_t ntjump, size_t nljump, size_t ni, size_t no, float* rw, float* season, float* trend) {
     if (ns < 3) {
         throw std::invalid_argument("seasonal_length must be at least 3");
     }
@@ -335,7 +335,7 @@ void stl(const float* y, size_t n, size_t np, size_t ns, size_t nt, size_t nl, i
     }
 }
 
-float var(const std::vector<float>& series) {
+inline float var(const std::vector<float>& series) {
     auto mean = std::accumulate(series.begin(), series.end(), 0.0) / series.size();
     std::vector<float> tmp;
     tmp.reserve(series.size());
@@ -345,7 +345,7 @@ float var(const std::vector<float>& series) {
     return std::accumulate(tmp.begin(), tmp.end(), 0.0) / (series.size() - 1);
 }
 
-float strength(const std::vector<float>& component, const std::vector<float>& remainder) {
+inline float strength(const std::vector<float>& component, const std::vector<float>& remainder) {
     std::vector<float> sr;
     sr.reserve(remainder.size());
     for (size_t i = 0; i < remainder.size(); i++) {
@@ -361,11 +361,11 @@ public:
     std::vector<float> remainder;
     std::vector<float> weights;
 
-    inline float seasonal_strength() {
+    float seasonal_strength() const {
         return strength(seasonal, remainder);
     }
 
-    inline float trend_strength() {
+    float trend_strength() const {
         return strength(trend, remainder);
     }
 };
@@ -385,62 +385,62 @@ class StlParams {
     bool robust_ = false;
 
 public:
-    inline StlParams seasonal_length(size_t ns) {
+    StlParams seasonal_length(size_t ns) {
         this->ns_ = ns;
         return *this;
     }
 
-    inline StlParams trend_length(size_t nt) {
+    StlParams trend_length(size_t nt) {
         this->nt_ = nt;
         return *this;
     }
 
-    inline StlParams low_pass_length(size_t nl) {
+    StlParams low_pass_length(size_t nl) {
         this->nl_ = nl;
         return *this;
     }
 
-    inline StlParams seasonal_degree(int isdeg) {
+    StlParams seasonal_degree(int isdeg) {
         this->isdeg_ = isdeg;
         return *this;
     }
 
-    inline StlParams trend_degree(int itdeg) {
+    StlParams trend_degree(int itdeg) {
         this->itdeg_ = itdeg;
         return *this;
     }
 
-    inline StlParams low_pass_degree(int ildeg) {
+    StlParams low_pass_degree(int ildeg) {
         this->ildeg_ = ildeg;
         return *this;
     }
 
-    inline StlParams seasonal_jump(size_t nsjump) {
+    StlParams seasonal_jump(size_t nsjump) {
         this->nsjump_ = nsjump;
         return *this;
     }
 
-    inline StlParams trend_jump(size_t ntjump) {
+    StlParams trend_jump(size_t ntjump) {
         this->ntjump_ = ntjump;
         return *this;
     }
 
-    inline StlParams low_pass_jump(size_t nljump) {
+    StlParams low_pass_jump(size_t nljump) {
         this->nljump_ = nljump;
         return *this;
     }
 
-    inline StlParams inner_loops(bool ni) {
+    StlParams inner_loops(bool ni) {
         this->ni_ = ni;
         return *this;
     }
 
-    inline StlParams outer_loops(bool no) {
+    StlParams outer_loops(bool no) {
         this->no_ = no;
         return *this;
     }
 
-    inline StlParams robust(bool robust) {
+    StlParams robust(bool robust) {
         this->robust_ = robust;
         return *this;
     }
@@ -449,11 +449,11 @@ public:
     StlResult fit(const std::vector<float>& y, size_t np);
 };
 
-StlParams params() {
+inline StlParams params() {
     return StlParams();
 }
 
-StlResult StlParams::fit(const float* y, size_t n, size_t np) {
+inline StlResult StlParams::fit(const float* y, size_t n, size_t np) {
     if (n < 2 * np) {
         throw std::invalid_argument("series has less than two periods");
     }
@@ -506,7 +506,7 @@ StlResult StlParams::fit(const float* y, size_t n, size_t np) {
     return res;
 }
 
-StlResult StlParams::fit(const std::vector<float>& y, size_t np) {
+inline StlResult StlParams::fit(const std::vector<float>& y, size_t np) {
     return StlParams::fit(y.data(), y.size(), np);
 }
 
diff --git a/src/IO/Archives/IArchiveWriter.h b/src/IO/Archives/IArchiveWriter.h
index c8f0c609da1..a3b06e6c4be 100644
--- a/src/IO/Archives/IArchiveWriter.h
+++ b/src/IO/Archives/IArchiveWriter.h
@@ -36,10 +36,10 @@ public:
 
     /// Sets compression method and level.
     /// Changing them will affect next file in the archive.
-    virtual void setCompression(const String & /* compression_method */, int /* compression_level */ = kDefaultCompressionLevel) {}
+    virtual void setCompression(const String & /*compression_method*/, int /*compression_level*/) {}
 
     /// Sets password. If the password is not empty it will enable encryption in the archive.
-    virtual void setPassword(const String & /* password */) {}
+    virtual void setPassword(const String & /*password*/) {}
 };
 
 }
diff --git a/src/IO/BrotliWriteBuffer.h b/src/IO/BrotliWriteBuffer.h
index d4cda7b270c..c68743ca13f 100644
--- a/src/IO/BrotliWriteBuffer.h
+++ b/src/IO/BrotliWriteBuffer.h
@@ -21,10 +21,10 @@ public:
         WriteBufferT && out_,
         int compression_level,
         size_t buf_size = DBMS_DEFAULT_BUFFER_SIZE,
-        char * existing_memory = nullptr,
+        char * existing_memory = nullptr, /// NOLINT(readability-non-const-parameter)
         size_t alignment = 0,
         bool compress_empty_ = true)
-    : WriteBufferWithOwnMemoryDecorator(std::move(out_), buf_size, existing_memory, alignment)
+    : WriteBufferWithOwnMemoryDecorator(std::move(out_), buf_size, existing_memory, alignment) /// NOLINT(bugprone-move-forwarding-reference)
     , brotli(std::make_unique<BrotliStateWrapper>())
     , in_available(0)
     , in_data(nullptr)
diff --git a/src/IO/Bzip2WriteBuffer.h b/src/IO/Bzip2WriteBuffer.h
index a685d4efa75..7808f8987cc 100644
--- a/src/IO/Bzip2WriteBuffer.h
+++ b/src/IO/Bzip2WriteBuffer.h
@@ -25,10 +25,10 @@ public:
         WriteBufferT && out_,
         int compression_level,
         size_t buf_size = DBMS_DEFAULT_BUFFER_SIZE,
-        char * existing_memory = nullptr,
+        char * existing_memory = nullptr, /// NOLINT(readability-non-const-parameter)
         size_t alignment = 0,
         bool compress_empty_ = true)
-    : WriteBufferWithOwnMemoryDecorator(std::move(out_), buf_size, existing_memory, alignment)
+    : WriteBufferWithOwnMemoryDecorator(std::move(out_), buf_size, existing_memory, alignment) /// NOLINT(bugprone-move-forwarding-reference)
     , compress_empty(compress_empty_)
     {
         memset(&stream, 0, sizeof(stream));
diff --git a/src/IO/ConnectionTimeouts.h b/src/IO/ConnectionTimeouts.h
index 2b2ab0e7ab8..49305f42d85 100644
--- a/src/IO/ConnectionTimeouts.h
+++ b/src/IO/ConnectionTimeouts.h
@@ -71,6 +71,7 @@ APPLY_FOR_ALL_CONNECTION_TIMEOUT_MEMBERS(DECLARE_BUILDER_FOR_MEMBER)
     ConnectionTimeouts & withConnectionTimeout(Poco::Timespan span);
 };
 
+/// NOLINTBEGIN(bugprone-macro-parentheses)
 #define DEFINE_BUILDER_FOR_MEMBER(member, setter_func) \
     inline ConnectionTimeouts & ConnectionTimeouts::setter_func(size_t seconds) \
     { \
@@ -83,6 +84,7 @@ APPLY_FOR_ALL_CONNECTION_TIMEOUT_MEMBERS(DECLARE_BUILDER_FOR_MEMBER)
     } \
 
     APPLY_FOR_ALL_CONNECTION_TIMEOUT_MEMBERS(DEFINE_BUILDER_FOR_MEMBER)
+/// NOLINTEND(bugprone-macro-parentheses)
 
 #undef DEFINE_BUILDER_FOR_MEMBER
 
diff --git a/src/IO/HTTPCommon.h b/src/IO/HTTPCommon.h
index e27269e2559..63dffcf6878 100644
--- a/src/IO/HTTPCommon.h
+++ b/src/IO/HTTPCommon.h
@@ -34,7 +34,7 @@ public:
     {}
 
     HTTPException * clone() const override { return new HTTPException(*this); }
-    void rethrow() const override { throw *this; }
+    void rethrow() const override { throw *this; } /// NOLINT(cert-err60-cpp)
 
     Poco::Net::HTTPResponse::HTTPStatus getHTTPStatus() const { return http_status; }
 
diff --git a/src/IO/LZMADeflatingWriteBuffer.h b/src/IO/LZMADeflatingWriteBuffer.h
index 797b85cd400..a3bcad7603c 100644
--- a/src/IO/LZMADeflatingWriteBuffer.h
+++ b/src/IO/LZMADeflatingWriteBuffer.h
@@ -19,10 +19,10 @@ public:
         WriteBufferT && out_,
         int compression_level,
         size_t buf_size = DBMS_DEFAULT_BUFFER_SIZE,
-        char * existing_memory = nullptr,
+        char * existing_memory = nullptr, /// NOLINT(readability-non-const-parameter)
         size_t alignment = 0,
         bool compress_empty_ = true)
-    : WriteBufferWithOwnMemoryDecorator(std::move(out_), buf_size, existing_memory, alignment), compress_empty(compress_empty_)
+    : WriteBufferWithOwnMemoryDecorator(std::move(out_), buf_size, existing_memory, alignment), compress_empty(compress_empty_) /// NOLINT(bugprone-move-forwarding-reference)
     {
         initialize(compression_level);
     }
diff --git a/src/IO/Lz4DeflatingWriteBuffer.h b/src/IO/Lz4DeflatingWriteBuffer.h
index b37d61fa732..6efd092afd0 100644
--- a/src/IO/Lz4DeflatingWriteBuffer.h
+++ b/src/IO/Lz4DeflatingWriteBuffer.h
@@ -19,10 +19,10 @@ public:
         WriteBufferT && out_,
         int compression_level,
         size_t buf_size = DBMS_DEFAULT_BUFFER_SIZE,
-        char * existing_memory = nullptr,
+        char * existing_memory = nullptr, /// NOLINT(readability-non-const-parameter)
         size_t alignment = 0,
         bool compress_empty_ = true)
-    : WriteBufferWithOwnMemoryDecorator(std::move(out_), buf_size, existing_memory, alignment)
+    : WriteBufferWithOwnMemoryDecorator(std::move(out_), buf_size, existing_memory, alignment) /// NOLINT(bugprone-move-forwarding-reference)
     , tmp_memory(buf_size)
     , compress_empty(compress_empty_)
     {
diff --git a/src/IO/ReadBufferFromFileBase.h b/src/IO/ReadBufferFromFileBase.h
index 296edf9c689..9870d8bbe43 100644
--- a/src/IO/ReadBufferFromFileBase.h
+++ b/src/IO/ReadBufferFromFileBase.h
@@ -58,7 +58,7 @@ public:
     /// I.e. it can be read using open() or mmap(). If this buffer is a "view" into a subrange of the
     /// file, *out_view_offset is set to the start of that subrange, i.e. the difference between actual
     /// file offset and what getPosition() returns.
-    virtual bool isRegularLocalFile(size_t * /* out_view_offset */ = nullptr) { return false; }
+    virtual bool isRegularLocalFile(size_t * /*out_view_offsee*/) { return false; }
 
 protected:
     std::optional<size_t> file_size;
diff --git a/src/IO/ReadSettings.h b/src/IO/ReadSettings.h
index c937f77708c..6a0cac35878 100644
--- a/src/IO/ReadSettings.h
+++ b/src/IO/ReadSettings.h
@@ -63,7 +63,6 @@ enum class RemoteFSReadMethod
 class MMappedFileCache;
 class PageCache;
 
-/// NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
 struct ReadSettings
 {
     /// Method to use reading from local filesystem.
diff --git a/src/IO/ReadWriteBufferFromHTTP.h b/src/IO/ReadWriteBufferFromHTTP.h
index 1b7437ea0c6..224aac809a4 100644
--- a/src/IO/ReadWriteBufferFromHTTP.h
+++ b/src/IO/ReadWriteBufferFromHTTP.h
@@ -210,10 +210,11 @@ class BuilderRWBufferFromHTTP
     bool delay_initialization = true;
 
 public:
-    BuilderRWBufferFromHTTP(Poco::URI uri_)
+    explicit BuilderRWBufferFromHTTP(Poco::URI uri_)
         : uri(uri_)
     {}
 
+/// NOLINTBEGIN(bugprone-macro-parentheses)
 #define setterMember(name, member) \
     BuilderRWBufferFromHTTP & name(decltype(BuilderRWBufferFromHTTP::member) arg_##member) \
     { \
@@ -235,6 +236,7 @@ public:
     setterMember(withDelayInit, delay_initialization)
     setterMember(withSkipNotFound, http_skip_not_found_url)
 #undef setterMember
+/// NOLINTEND(bugprone-macro-parentheses)
 
     ReadWriteBufferFromHTTPPtr create(const Poco::Net::HTTPBasicCredentials & credentials_)
     {
diff --git a/src/IO/S3/PocoHTTPClient.h b/src/IO/S3/PocoHTTPClient.h
index a93a4dfbaf7..ebbddbb2c7e 100644
--- a/src/IO/S3/PocoHTTPClient.h
+++ b/src/IO/S3/PocoHTTPClient.h
@@ -95,7 +95,7 @@ public:
 
     void SetResponseBody(std::string & response_body) /// NOLINT
     {
-        auto stream = Aws::New<std::stringstream>("http result buf", response_body); // STYLE_CHECK_ALLOW_STD_STRING_STREAM
+        auto * stream = Aws::New<std::stringstream>("http result buf", response_body); // STYLE_CHECK_ALLOW_STD_STRING_STREAM
         stream->exceptions(std::ios::failbit);
         body_stream = Aws::Utils::Stream::ResponseStream(std::move(stream));
     }
diff --git a/src/IO/S3/tests/TestPocoHTTPServer.h b/src/IO/S3/tests/TestPocoHTTPServer.h
index a26e811d646..35ceb5e1632 100644
--- a/src/IO/S3/tests/TestPocoHTTPServer.h
+++ b/src/IO/S3/tests/TestPocoHTTPServer.h
@@ -22,7 +22,7 @@ class MockRequestHandler : public Poco::Net::HTTPRequestHandler
 
 public:
     explicit MockRequestHandler(Poco::Net::MessageHeader & last_request_header_)
-    : Poco::Net::HTTPRequestHandler(), last_request_header(last_request_header_)
+    : last_request_header(last_request_header_)
     {
     }
 
@@ -38,20 +38,18 @@ class HTTPRequestHandlerFactory : public Poco::Net::HTTPRequestHandlerFactory
 {
     Poco::Net::MessageHeader & last_request_header;
 
-    virtual Poco::Net::HTTPRequestHandler * createRequestHandler(const Poco::Net::HTTPServerRequest &) override
+    Poco::Net::HTTPRequestHandler * createRequestHandler(const Poco::Net::HTTPServerRequest &) override
     {
         return new MockRequestHandler(last_request_header);
     }
 
 public:
     explicit HTTPRequestHandlerFactory(Poco::Net::MessageHeader & last_request_header_)
-    : Poco::Net::HTTPRequestHandlerFactory(), last_request_header(last_request_header_)
+    : last_request_header(last_request_header_)
     {
     }
 
-    virtual ~HTTPRequestHandlerFactory() override
-    {
-    }
+    ~HTTPRequestHandlerFactory() override = default;
 };
 
 class TestPocoHTTPServer
diff --git a/src/IO/SeekableReadBuffer.h b/src/IO/SeekableReadBuffer.h
index 798833e1a9b..808efe9e6d0 100644
--- a/src/IO/SeekableReadBuffer.h
+++ b/src/IO/SeekableReadBuffer.h
@@ -82,7 +82,7 @@ public:
     ///    (e.g. next() or supportsReadAt()).
     ///  * Performance: there's no buffering. Each readBigAt() call typically translates into actual
     ///    IO operation (e.g. HTTP request). Don't use it for small adjacent reads.
-    virtual size_t readBigAt(char * /*to*/, size_t /*n*/, size_t /*offset*/, const std::function<bool(size_t m)> & /*progress_callback*/ = nullptr) const
+    virtual size_t readBigAt(char * /*to*/, size_t /*n*/, size_t /*offset*/, const std::function<bool(size_t m)> & /*progress_callback*/) const
         { throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Method readBigAt() not implemented"); }
 
     /// Checks if readBigAt() is allowed. May be slow, may throw (e.g. it may do an HTTP request or an fstat).
diff --git a/src/IO/WriteBufferFromArena.h b/src/IO/WriteBufferFromArena.h
index 8e9276496b5..f901f5bff77 100644
--- a/src/IO/WriteBufferFromArena.h
+++ b/src/IO/WriteBufferFromArena.h
@@ -66,7 +66,7 @@ private:
 
     /// it is super strange,
     /// but addition next call changes the data in serializeValueIntoArena result
-    virtual void finalizeImpl() override { /* no op */ }
+    void finalizeImpl() override { /* no op */ }
 };
 
 }
diff --git a/src/IO/ZlibDeflatingWriteBuffer.h b/src/IO/ZlibDeflatingWriteBuffer.h
index f01c41c7d13..35760b3e246 100644
--- a/src/IO/ZlibDeflatingWriteBuffer.h
+++ b/src/IO/ZlibDeflatingWriteBuffer.h
@@ -27,10 +27,10 @@ public:
             CompressionMethod compression_method,
             int compression_level,
             size_t buf_size = DBMS_DEFAULT_BUFFER_SIZE,
-            char * existing_memory = nullptr,
+            char * existing_memory = nullptr, /// NOLINT(readability-non-const-parameter)
             size_t alignment = 0,
             bool compress_empty_ = true)
-    : WriteBufferWithOwnMemoryDecorator(std::move(out_), buf_size, existing_memory, alignment), compress_empty(compress_empty_)
+    : WriteBufferWithOwnMemoryDecorator(std::move(out_), buf_size, existing_memory, alignment), compress_empty(compress_empty_) /// NOLINT(bugprone-move-forwarding-reference)
     {
         zstr.zalloc = nullptr;
         zstr.zfree = nullptr;
@@ -60,8 +60,8 @@ private:
     /// Flush all pending data and write zlib footer to the underlying buffer.
     /// After the first call to this function, subsequent calls will have no effect and
     /// an attempt to write to this buffer will result in exception.
-    virtual void finalizeBefore() override;
-    virtual void finalizeAfter() override;
+    void finalizeBefore() override;
+    void finalizeAfter() override;
 
     z_stream zstr;
     bool compress_empty = true;
diff --git a/src/IO/ZstdDeflatingWriteBuffer.h b/src/IO/ZstdDeflatingWriteBuffer.h
index 15c3869062f..9d1c677e725 100644
--- a/src/IO/ZstdDeflatingWriteBuffer.h
+++ b/src/IO/ZstdDeflatingWriteBuffer.h
@@ -20,10 +20,10 @@ public:
         int compression_level,
         int window_log = 0,
         size_t buf_size = DBMS_DEFAULT_BUFFER_SIZE,
-        char * existing_memory = nullptr,
+        char * existing_memory = nullptr, /// NOLINT(readability-non-const-parameter)
         size_t alignment = 0,
         bool compress_empty_ = true)
-    : WriteBufferWithOwnMemoryDecorator(std::move(out_), buf_size, existing_memory, alignment), compress_empty(compress_empty_)
+    : WriteBufferWithOwnMemoryDecorator(std::move(out_), buf_size, existing_memory, alignment), compress_empty(compress_empty_) /// NOLINT(bugprone-move-forwarding-reference)
     {
         initialize(compression_level, window_log);
     }
diff --git a/src/IO/readDecimalText.h b/src/IO/readDecimalText.h
index 8b4405ee2e9..f3b08065696 100644
--- a/src/IO/readDecimalText.h
+++ b/src/IO/readDecimalText.h
@@ -38,7 +38,7 @@ inline bool readDigits(ReadBuffer & buf, T & x, uint32_t & digits, int32_t & exp
         return false;
     }
 
-    switch (*buf.position())
+    switch (*buf.position()) /// NOLINT(bugprone-switch-missing-default-case)
     {
         case '-':
             sign = -1;
diff --git a/src/Interpreters/AddDefaultDatabaseVisitor.h b/src/Interpreters/AddDefaultDatabaseVisitor.h
index e36f22e8ba1..356bffa75e9 100644
--- a/src/Interpreters/AddDefaultDatabaseVisitor.h
+++ b/src/Interpreters/AddDefaultDatabaseVisitor.h
@@ -163,7 +163,7 @@ private:
         if (identifier.compound())
             return;
         /// There is temporary table with such name, should not be rewritten.
-        if (external_tables.count(identifier.shortName()))
+        if (external_tables.contains(identifier.shortName()))
             return;
 
         auto qualified_identifier = std::make_shared<ASTTableIdentifier>(database_name, identifier.name());
diff --git a/src/Interpreters/AggregateFunctionOfGroupByKeysVisitor.h b/src/Interpreters/AggregateFunctionOfGroupByKeysVisitor.h
index ab01cc6a0b6..d8fae7e80ad 100644
--- a/src/Interpreters/AggregateFunctionOfGroupByKeysVisitor.h
+++ b/src/Interpreters/AggregateFunctionOfGroupByKeysVisitor.h
@@ -37,7 +37,7 @@ struct KeepAggregateFunctionMatcher
             return;
         }
 
-        if (!data.group_by_keys.count(function_node.getColumnName()))
+        if (!data.group_by_keys.contains(function_node.getColumnName()))
         {
             Visitor(data).visit(function_node.arguments);
         }
@@ -46,7 +46,7 @@ struct KeepAggregateFunctionMatcher
     static void visit(ASTIdentifier & ident, Data & data)
     {
         /// if variable of a function is not in GROUP BY keys, this function should not be deleted
-        if (!data.group_by_keys.count(ident.getColumnName()))
+        if (!data.group_by_keys.contains(ident.getColumnName()))
             data.keep_aggregator = true;
     }
 
diff --git a/src/Interpreters/AggregationCommon.h b/src/Interpreters/AggregationCommon.h
index ced29c2f862..ab078d1c5e5 100644
--- a/src/Interpreters/AggregationCommon.h
+++ b/src/Interpreters/AggregationCommon.h
@@ -94,7 +94,7 @@ void fillFixedBatch(size_t keys_size, const ColumnRawPtrs & key_columns, const S
             if constexpr (std::endian::native == std::endian::big)
                 offset_to = sizeof(Key) - sizeof(T) - offset;
             T * dest = reinterpret_cast<T *>(reinterpret_cast<char *>(out.data()) + offset_to);
-            fillFixedBatch<T, sizeof(Key) / sizeof(T)>(num_rows, reinterpret_cast<const T *>(source), dest);
+            fillFixedBatch<T, sizeof(Key) / sizeof(T)>(num_rows, reinterpret_cast<const T *>(source), dest); /// NOLINT(bugprone-sizeof-expression)
             offset += sizeof(T);
         }
     }
diff --git a/src/Interpreters/ArrayJoinedColumnsVisitor.h b/src/Interpreters/ArrayJoinedColumnsVisitor.h
index f16751c4561..86db342073a 100644
--- a/src/Interpreters/ArrayJoinedColumnsVisitor.h
+++ b/src/Interpreters/ArrayJoinedColumnsVisitor.h
@@ -75,7 +75,7 @@ private:
             if (nested_table_alias == nested_table_name && !ast->as<ASTIdentifier>())
                 throw Exception(ErrorCodes::ALIAS_REQUIRED, "No alias for non-trivial value in ARRAY JOIN: {}", nested_table_name);
 
-            if (data.array_join_alias_to_name.count(nested_table_alias) || data.aliases.count(nested_table_alias))
+            if (data.array_join_alias_to_name.contains(nested_table_alias) || data.aliases.contains(nested_table_alias))
                 throw Exception(ErrorCodes::MULTIPLE_EXPRESSIONS_FOR_ALIAS, "Duplicate alias in ARRAY JOIN: {}", nested_table_alias);
 
             data.array_join_alias_to_name[nested_table_alias] = nested_table_name;
@@ -100,18 +100,18 @@ private:
 
         auto split = Nested::splitName(node.name());  /// ParsedParams, Key1
 
-        if (array_join_alias_to_name.count(node.name()))
+        if (array_join_alias_to_name.contains(node.name()))
         {
             /// ARRAY JOIN was written with an array column. Example: SELECT K1 FROM ... ARRAY JOIN ParsedParams.Key1 AS K1
             array_join_result_to_source[node.name()] = array_join_alias_to_name[node.name()];    /// K1 -> ParsedParams.Key1
         }
-        else if (array_join_alias_to_name.count(split.first) && !split.second.empty())
+        else if (array_join_alias_to_name.contains(split.first) && !split.second.empty())
         {
             /// ARRAY JOIN was written with a nested table. Example: SELECT PP.KEY1 FROM ... ARRAY JOIN ParsedParams AS PP
             array_join_result_to_source[node.name()]    /// PP.Key1 -> ParsedParams.Key1
                 = Nested::concatenateName(array_join_alias_to_name[split.first], split.second);
         }
-        else if (array_join_name_to_alias.count(node.name()))
+        else if (array_join_name_to_alias.contains(node.name()))
         {
             /** Example: SELECT ParsedParams.Key1 FROM ... ARRAY JOIN ParsedParams.Key1 AS PP.Key1.
             * That is, the query uses the original array, replicated by itself.
@@ -119,7 +119,7 @@ private:
             array_join_result_to_source[    /// PP.Key1 -> ParsedParams.Key1
                 array_join_name_to_alias[node.name()]] = node.name();
         }
-        else if (array_join_name_to_alias.count(split.first) && !split.second.empty())
+        else if (array_join_name_to_alias.contains(split.first) && !split.second.empty())
         {
             /** Example: SELECT ParsedParams.Key1 FROM ... ARRAY JOIN ParsedParams AS PP.
             */
diff --git a/src/Interpreters/AsynchronousInsertQueue.h b/src/Interpreters/AsynchronousInsertQueue.h
index 5076701d0b0..9d3c38d0a4c 100644
--- a/src/Interpreters/AsynchronousInsertQueue.h
+++ b/src/Interpreters/AsynchronousInsertQueue.h
@@ -282,7 +282,7 @@ private:
 public:
     auto getQueueLocked(size_t shard_num) const
     {
-        auto & shard = queue_shards[shard_num];
+        const auto & shard = queue_shards[shard_num];
         std::unique_lock lock(shard.mutex);
         return std::make_pair(std::ref(shard.queue), std::move(lock));
     }
diff --git a/src/Interpreters/BackupLog.h b/src/Interpreters/BackupLog.h
index ee6a4c214ee..e17b9b69cfd 100644
--- a/src/Interpreters/BackupLog.h
+++ b/src/Interpreters/BackupLog.h
@@ -23,7 +23,7 @@ struct BackupLogElement
 
     std::chrono::system_clock::time_point event_time{};
     Decimal64 event_time_usec{};
-    BackupOperationInfo info{};
+    BackupOperationInfo info{}; /// NOLINT(bugprone-throw-keyword-missing)
 
     static std::string name() { return "BackupLog"; }
     static ColumnsDescription getColumnsDescription();
diff --git a/src/Interpreters/Context.h b/src/Interpreters/Context.h
index 43df8d6adf2..dbd9bbd1ff8 100644
--- a/src/Interpreters/Context.h
+++ b/src/Interpreters/Context.h
@@ -129,7 +129,6 @@ using ActionLocksManagerPtr = std::shared_ptr<ActionLocksManager>;
 class ShellCommand;
 class ICompressionCodec;
 class AccessControl;
-class Credentials;
 class GSSAcceptorContext;
 struct SettingsConstraintsAndProfileIDs;
 class SettingsProfileElements;
@@ -164,7 +163,6 @@ using OrdinaryBackgroundExecutorPtr = std::shared_ptr<OrdinaryBackgroundExecutor
 struct PartUUIDs;
 using PartUUIDsPtr = std::shared_ptr<PartUUIDs>;
 class KeeperDispatcher;
-class Session;
 struct WriteSettings;
 
 class IInputFormat;
diff --git a/src/Interpreters/DirectJoin.h b/src/Interpreters/DirectJoin.h
index ef8d12a1b8f..019e32c3130 100644
--- a/src/Interpreters/DirectJoin.h
+++ b/src/Interpreters/DirectJoin.h
@@ -31,28 +31,24 @@ public:
         const Block & right_sample_block_with_storage_column_names_);
 
     std::string getName() const override { return "DirectKeyValueJoin"; }
-    virtual const TableJoin & getTableJoin() const override { return *table_join; }
+    const TableJoin & getTableJoin() const override { return *table_join; }
 
-    virtual bool addBlockToJoin(const Block &, bool) override;
-    virtual void checkTypesOfKeys(const Block &) const override;
+    bool addBlockToJoin(const Block &, bool) override;
+    void checkTypesOfKeys(const Block &) const override;
 
     /// Join the block with data from left hand of JOIN to the right hand data (that was previously built by calls to addBlockToJoin).
     /// Could be called from different threads in parallel.
-    virtual void joinBlock(Block & block, std::shared_ptr<ExtraBlock> &) override;
+    void joinBlock(Block & block, std::shared_ptr<ExtraBlock> &) override;
 
-    virtual size_t getTotalRowCount() const override { return 0; }
+    size_t getTotalRowCount() const override { return 0; }
 
-    virtual size_t getTotalByteCount() const override { return 0; }
+    size_t getTotalByteCount() const override { return 0; }
 
-    virtual bool alwaysReturnsEmptySet() const override { return false; }
+    bool alwaysReturnsEmptySet() const override { return false; }
 
-    virtual bool isFilled() const override { return true; }
+    bool isFilled() const override { return true; }
 
-    virtual IBlocksStreamPtr
-    getNonJoinedBlocks(const Block &, const Block &, UInt64) const override
-    {
-        return nullptr;
-    }
+    IBlocksStreamPtr getNonJoinedBlocks(const Block &, const Block &, UInt64) const override { return nullptr; }
 
 private:
     std::shared_ptr<TableJoin> table_join;
diff --git a/src/Interpreters/GetAggregatesVisitor.h b/src/Interpreters/GetAggregatesVisitor.h
index 863c4f81a1b..e1d22e4de82 100644
--- a/src/Interpreters/GetAggregatesVisitor.h
+++ b/src/Interpreters/GetAggregatesVisitor.h
@@ -68,7 +68,7 @@ private:
                                 node.getColumnName(), String(data.assert_no_aggregates));
 
             String column_name = node.getColumnName();
-            if (data.uniq_names.count(column_name))
+            if (data.uniq_names.contains(column_name))
                 return;
 
             data.uniq_names.insert(column_name);
@@ -81,7 +81,7 @@ private:
                                 node.getColumnName(), String(data.assert_no_windows));
 
             String column_name = node.getColumnName();
-            if (data.uniq_names.count(column_name))
+            if (data.uniq_names.contains(column_name))
                 return;
 
             data.uniq_names.insert(column_name);
diff --git a/src/Interpreters/GroupByFunctionKeysVisitor.h b/src/Interpreters/GroupByFunctionKeysVisitor.h
index b1d40320a45..9b082291bfb 100644
--- a/src/Interpreters/GroupByFunctionKeysVisitor.h
+++ b/src/Interpreters/GroupByFunctionKeysVisitor.h
@@ -38,7 +38,7 @@ struct KeepFunctionMatcher
             return;
         }
 
-        if (!data.key_names_to_keep.count(function_node->getColumnName()))
+        if (!data.key_names_to_keep.contains(function_node->getColumnName()))
         {
             Visitor(data).visit(function_node->arguments);
         }
@@ -46,7 +46,7 @@ struct KeepFunctionMatcher
 
     static void visit(ASTIdentifier * ident, Data & data)
     {
-        if (!data.key_names_to_keep.count(ident->shortName()))
+        if (!data.key_names_to_keep.contains(ident->shortName()))
         {
             /// if variable of a function is not in GROUP BY keys, this function should not be deleted
             data.keep_key = true;
diff --git a/src/Interpreters/HashJoin.h b/src/Interpreters/HashJoin.h
index 29bb9070009..3e11517edad 100644
--- a/src/Interpreters/HashJoin.h
+++ b/src/Interpreters/HashJoin.h
@@ -253,6 +253,7 @@ public:
     template <typename Mapped>
     struct MapsTemplate
     {
+/// NOLINTBEGIN(bugprone-macro-parentheses)
         using MappedType = Mapped;
         std::unique_ptr<FixedHashMap<UInt8, Mapped>>                  key8;
         std::unique_ptr<FixedHashMap<UInt16, Mapped>>                 key16;
@@ -341,6 +342,7 @@ public:
 
             UNREACHABLE();
         }
+/// NOLINTEND(bugprone-macro-parentheses)
     };
 
     using MapsOne = MapsTemplate<RowRef>;
diff --git a/src/Interpreters/MonotonicityCheckVisitor.h b/src/Interpreters/MonotonicityCheckVisitor.h
index cc386825024..e1df45ed36b 100644
--- a/src/Interpreters/MonotonicityCheckVisitor.h
+++ b/src/Interpreters/MonotonicityCheckVisitor.h
@@ -41,7 +41,7 @@ public:
             /// if GROUP BY contains the same function ORDER BY shouldn't be optimized
             const auto hash = ast_function.getTreeHash(/*ignore_aliases=*/ true);
             const auto key = toString(hash);
-            if (group_by_function_hashes.count(key))
+            if (group_by_function_hashes.contains(key))
                 return false;
 
             /// if ORDER BY contains aggregate function or window functions, it
diff --git a/src/Interpreters/RedundantFunctionsInOrderByVisitor.h b/src/Interpreters/RedundantFunctionsInOrderByVisitor.h
index 60c9fcf2a24..516e6f0a9d4 100644
--- a/src/Interpreters/RedundantFunctionsInOrderByVisitor.h
+++ b/src/Interpreters/RedundantFunctionsInOrderByVisitor.h
@@ -61,7 +61,7 @@ public:
 
             /// Allow known identifiers: they are present in ORDER BY before current item
             if (auto * identifier = arg->as<ASTIdentifier>())
-                if (data.keys.count(getIdentifierName(identifier)))
+                if (data.keys.contains(getIdentifierName(identifier)))
                     continue;
 
             /// Reject erase others
diff --git a/src/Interpreters/SessionLog.h b/src/Interpreters/SessionLog.h
index 74e72c54bcc..5bacb9677c0 100644
--- a/src/Interpreters/SessionLog.h
+++ b/src/Interpreters/SessionLog.h
@@ -37,7 +37,7 @@ struct SessionLogElement
     SessionLogElement(const UUID & auth_id_, Type type_);
     SessionLogElement(const SessionLogElement &) = default;
     SessionLogElement & operator=(const SessionLogElement &) = default;
-    SessionLogElement(SessionLogElement &&) = default;
+    SessionLogElement(SessionLogElement &&) = default; /// NOLINT(performance-noexcept-move-constructor,hicpp-noexcept-move)
     SessionLogElement & operator=(SessionLogElement &&) = default;
 
     UUID auth_id;
diff --git a/src/Interpreters/SetVariants.h b/src/Interpreters/SetVariants.h
index 71187c9f109..ff527102080 100644
--- a/src/Interpreters/SetVariants.h
+++ b/src/Interpreters/SetVariants.h
@@ -80,7 +80,7 @@ protected:
 
         for (const auto & col : key_columns)
         {
-            if (auto * nullable = checkAndGetColumn<ColumnNullable>(*col))
+            if (const auto * nullable = checkAndGetColumn<ColumnNullable>(*col))
             {
                 actual_columns.push_back(&nullable->getNestedColumn());
                 null_maps.push_back(&nullable->getNullMapColumn());
@@ -96,7 +96,7 @@ protected:
     /// Return the columns which actually contain the values of the keys.
     /// For a given key column, if it is nullable, we return its nested
     /// column. Otherwise we return the key column itself.
-    inline const ColumnRawPtrs & getActualColumns() const
+    const ColumnRawPtrs & getActualColumns() const
     {
         return actual_columns;
     }
diff --git a/src/Interpreters/TranslateQualifiedNamesVisitor.h b/src/Interpreters/TranslateQualifiedNamesVisitor.h
index 73e45fc7ea0..00c85d08873 100644
--- a/src/Interpreters/TranslateQualifiedNamesVisitor.h
+++ b/src/Interpreters/TranslateQualifiedNamesVisitor.h
@@ -35,7 +35,7 @@ public:
             , has_columns(has_columns_)
         {}
 
-        bool hasColumn(const String & name) const { return source_columns.count(name); }
+        bool hasColumn(const String & name) const { return source_columns.contains(name); }
         bool hasTable() const { return !tables.empty(); }
         bool processAsterisks() const { return hasTable() && has_columns; }
         bool unknownColumn(size_t table_pos, const ASTIdentifier & identifier) const;
diff --git a/src/Interpreters/TreeCNFConverter.h b/src/Interpreters/TreeCNFConverter.h
index 3cc8b05d6c6..8258412f1a6 100644
--- a/src/Interpreters/TreeCNFConverter.h
+++ b/src/Interpreters/TreeCNFConverter.h
@@ -58,7 +58,7 @@ public:
         for (const auto & or_group : statements)
         {
             OrGroup filtered_group;
-            for (auto ast : or_group)
+            for (const auto & ast : or_group)
             {
                 if (predicate_is_unknown(ast))
                     filtered_group.insert(ast);
diff --git a/src/Interpreters/joinDispatch.h b/src/Interpreters/joinDispatch.h
index ca2fcd27cda..324d6a4d434 100644
--- a/src/Interpreters/joinDispatch.h
+++ b/src/Interpreters/joinDispatch.h
@@ -113,10 +113,9 @@ inline bool joinDispatch(JoinKind kind, JoinStrictness strictness, std::vector<c
         {
             using MapType = typename MapGetter<KINDS[i], STRICTNESSES[j]>::Map;
             std::vector<const MapType *> v;
+            v.resize(mapsv.size());
             for (const auto & el : mapsv)
-            {
                 v.push_back(&std::get<MapType>(*el));
-            }
 
             func(
                 std::integral_constant<JoinKind, KINDS[i]>(),
diff --git a/src/Loggers/OwnFormattingChannel.h b/src/Loggers/OwnFormattingChannel.h
index da7cde315f9..00300fe99ff 100644
--- a/src/Loggers/OwnFormattingChannel.h
+++ b/src/Loggers/OwnFormattingChannel.h
@@ -16,11 +16,11 @@ class OwnFormattingChannel : public Poco::Channel, public ExtendedLogChannel
 public:
     explicit OwnFormattingChannel(
         Poco::AutoPtr<OwnPatternFormatter> pFormatter_ = nullptr, Poco::AutoPtr<Poco::Channel> pChannel_ = nullptr)
-        : pFormatter(std::move(pFormatter_)), pChannel(std::move(pChannel_)), priority(Poco::Message::PRIO_TRACE)
+        : pFormatter(pFormatter_), pChannel(pChannel_), priority(Poco::Message::PRIO_TRACE)
     {
     }
 
-    void setChannel(Poco::AutoPtr<Poco::Channel> pChannel_) { pChannel = std::move(pChannel_); }
+    void setChannel(Poco::AutoPtr<Poco::Channel> pChannel_) { pChannel = pChannel_; }
 
     void setLevel(Poco::Message::Priority priority_) { priority = priority_; }
 
diff --git a/src/Processors/Executors/PullingAsyncPipelineExecutor.h b/src/Processors/Executors/PullingAsyncPipelineExecutor.h
index 361bcc0155c..618a7e790ab 100644
--- a/src/Processors/Executors/PullingAsyncPipelineExecutor.h
+++ b/src/Processors/Executors/PullingAsyncPipelineExecutor.h
@@ -58,7 +58,6 @@ private:
 
     void cancelWithExceptionHandling(CancelFunc && cancel_func);
 
-private:
     QueryPipeline & pipeline;
     std::shared_ptr<LazyOutputFormat> lazy_format;
     std::unique_ptr<Data> data;
diff --git a/src/Processors/Formats/IRowOutputFormat.h b/src/Processors/Formats/IRowOutputFormat.h
index 3a648f00eba..6083e1a6bc8 100644
--- a/src/Processors/Formats/IRowOutputFormat.h
+++ b/src/Processors/Formats/IRowOutputFormat.h
@@ -50,13 +50,13 @@ protected:
     virtual void writeFieldDelimiter() {}       /// delimiter between values
     virtual void writeRowStartDelimiter() {}    /// delimiter before each row
     virtual void writeRowEndDelimiter() {}      /// delimiter after each row
-    virtual void writePrefix() override {}      /// delimiter before resultset
-    virtual void writeSuffix() override {}      /// delimiter after resultset
+    void writePrefix() override {}      /// delimiter before resultset
+    void writeSuffix() override {}      /// delimiter after resultset
     virtual void writeBeforeTotals() {}
     virtual void writeAfterTotals() {}
     virtual void writeBeforeExtremes() {}
     virtual void writeAfterExtremes() {}
-    virtual void finalizeImpl() override {}  /// Write something after resultset, totals end extremes.
+    void finalizeImpl() override {}  /// Write something after resultset, totals end extremes.
 
     bool haveWrittenData() { return !first_row || getRowsReadBefore() != 0; }
 
diff --git a/src/Processors/Formats/Impl/ArrowBufferedStreams.cpp b/src/Processors/Formats/Impl/ArrowBufferedStreams.cpp
index 83d7a8b7bbd..c6e951ada6a 100644
--- a/src/Processors/Formats/Impl/ArrowBufferedStreams.cpp
+++ b/src/Processors/Formats/Impl/ArrowBufferedStreams.cpp
@@ -154,7 +154,7 @@ arrow::Result<int64_t> RandomAccessFileFromRandomAccessReadBuffer::GetSize()
 
 arrow::Result<int64_t> RandomAccessFileFromRandomAccessReadBuffer::ReadAt(int64_t position, int64_t nbytes, void* out)
 {
-    return in.readBigAt(reinterpret_cast<char*>(out), nbytes, position);
+    return in.readBigAt(reinterpret_cast<char*>(out), nbytes, position, nullptr);
 }
 
 arrow::Result<std::shared_ptr<arrow::Buffer>> RandomAccessFileFromRandomAccessReadBuffer::ReadAt(int64_t position, int64_t nbytes)
diff --git a/src/Processors/Formats/Impl/AvroRowInputFormat.h b/src/Processors/Formats/Impl/AvroRowInputFormat.h
index a8364df6e80..78dfe65fa5e 100644
--- a/src/Processors/Formats/Impl/AvroRowInputFormat.h
+++ b/src/Processors/Formats/Impl/AvroRowInputFormat.h
@@ -183,7 +183,7 @@ public:
     class SchemaRegistry;
 
 private:
-    virtual bool readRow(MutableColumns & columns, RowReadExtension & ext) override;
+    bool readRow(MutableColumns & columns, RowReadExtension & ext) override;
     void readPrefix() override;
 
     bool allowSyncAfterError() const override { return true; }
diff --git a/src/Processors/Formats/Impl/AvroRowOutputFormat.h b/src/Processors/Formats/Impl/AvroRowOutputFormat.h
index c526936b383..5d308d78966 100644
--- a/src/Processors/Formats/Impl/AvroRowOutputFormat.h
+++ b/src/Processors/Formats/Impl/AvroRowOutputFormat.h
@@ -48,16 +48,16 @@ class AvroRowOutputFormat final : public IRowOutputFormat
 {
 public:
     AvroRowOutputFormat(WriteBuffer & out_, const Block & header_, const FormatSettings & settings_);
-    virtual ~AvroRowOutputFormat() override;
+    ~AvroRowOutputFormat() override;
 
     String getName() const override { return "AvroRowOutputFormat"; }
 
 private:
     void write(const Columns & columns, size_t row_num) override;
     void writeField(const IColumn &, const ISerialization &, size_t) override {}
-    virtual void writePrefix() override;
-    virtual void finalizeImpl() override;
-    virtual void resetFormatterImpl() override;
+    void writePrefix() override;
+    void finalizeImpl() override;
+    void resetFormatterImpl() override;
 
     void createFileWriter();
 
diff --git a/src/Processors/Formats/Impl/ConstantExpressionTemplate.h b/src/Processors/Formats/Impl/ConstantExpressionTemplate.h
index 71d0d0f7134..11165d5c449 100644
--- a/src/Processors/Formats/Impl/ConstantExpressionTemplate.h
+++ b/src/Processors/Formats/Impl/ConstantExpressionTemplate.h
@@ -92,7 +92,6 @@ private:
     bool parseLiteralAndAssertType(
         ReadBuffer & istr, const TokenIterator & token_iterator, const IDataType * type, size_t column_idx, const Settings & settings);
 
-private:
     TemplateStructurePtr structure;
     MutableColumns columns;
 
diff --git a/src/Processors/Formats/Impl/ParallelFormattingOutputFormat.h b/src/Processors/Formats/Impl/ParallelFormattingOutputFormat.h
index 50a73646359..b04c1b0c16e 100644
--- a/src/Processors/Formats/Impl/ParallelFormattingOutputFormat.h
+++ b/src/Processors/Formats/Impl/ParallelFormattingOutputFormat.h
@@ -154,7 +154,7 @@ public:
     void setException(const String & exception_message_) override { exception_message = exception_message_; }
 
 private:
-    void consume(Chunk chunk) override final
+    void consume(Chunk chunk) final
     {
         addChunk(std::move(chunk), ProcessingUnitType::PLAIN, /*can_throw_exception*/ true);
     }
diff --git a/src/Processors/Formats/Impl/ParquetBlockOutputFormat.h b/src/Processors/Formats/Impl/ParquetBlockOutputFormat.h
index 3db90f4299b..422bae5c315 100644
--- a/src/Processors/Formats/Impl/ParquetBlockOutputFormat.h
+++ b/src/Processors/Formats/Impl/ParquetBlockOutputFormat.h
@@ -48,10 +48,10 @@ private:
             set(b);
         }
 
-        MemoryToken(MemoryToken && t)
+        MemoryToken(MemoryToken && t) /// NOLINT
           : parent(std::exchange(t.parent, nullptr)), bytes(std::exchange(t.bytes, 0)) {}
 
-        MemoryToken & operator=(MemoryToken && t)
+        MemoryToken & operator=(MemoryToken && t) /// NOLINT
         {
             parent = std::exchange(t.parent, nullptr);
             bytes = std::exchange(t.bytes, 0);
diff --git a/src/Processors/Formats/Impl/TabSeparatedRowOutputFormat.h b/src/Processors/Formats/Impl/TabSeparatedRowOutputFormat.h
index 9facba2052a..a514323873e 100644
--- a/src/Processors/Formats/Impl/TabSeparatedRowOutputFormat.h
+++ b/src/Processors/Formats/Impl/TabSeparatedRowOutputFormat.h
@@ -34,14 +34,14 @@ public:
 
 protected:
     void writeField(const IColumn & column, const ISerialization & serialization, size_t row_num) override;
-    void writeFieldDelimiter() override final;
+    void writeFieldDelimiter() final;
     void writeRowEndDelimiter() override;
 
     bool supportTotals() const override { return true; }
     bool supportExtremes() const override { return true; }
 
-    void writeBeforeTotals() override final;
-    void writeBeforeExtremes() override final;
+    void writeBeforeTotals() final;
+    void writeBeforeExtremes() final;
 
     void writePrefix() override;
     void writeLine(const std::vector<String> & values);
diff --git a/src/Processors/Formats/RowInputFormatWithNamesAndTypes.h b/src/Processors/Formats/RowInputFormatWithNamesAndTypes.h
index d0457990714..b7d9507151e 100644
--- a/src/Processors/Formats/RowInputFormatWithNamesAndTypes.h
+++ b/src/Processors/Formats/RowInputFormatWithNamesAndTypes.h
@@ -175,7 +175,7 @@ public:
     void transformTypesIfNeeded(DataTypePtr & type, DataTypePtr & new_type) override;
 
 protected:
-    virtual std::optional<DataTypes> readRowAndGetDataTypes() override;
+    std::optional<DataTypes> readRowAndGetDataTypes() override;
 
     virtual std::optional<DataTypes> readRowAndGetDataTypesImpl()
     {
diff --git a/src/Processors/Merges/Algorithms/AggregatingSortedAlgorithm.h b/src/Processors/Merges/Algorithms/AggregatingSortedAlgorithm.h
index 72a1f4871d8..aa221573151 100644
--- a/src/Processors/Merges/Algorithms/AggregatingSortedAlgorithm.h
+++ b/src/Processors/Merges/Algorithms/AggregatingSortedAlgorithm.h
@@ -47,7 +47,7 @@ public:
         bool created = false;
 
         SimpleAggregateDescription(
-            AggregateFunctionPtr function_, const size_t column_number_,
+            AggregateFunctionPtr function_, size_t column_number_,
             DataTypePtr nested_type_, DataTypePtr real_type_);
 
         void createState();
diff --git a/src/Processors/Merges/Algorithms/IMergingAlgorithm.h b/src/Processors/Merges/Algorithms/IMergingAlgorithm.h
index d55ceb78af4..6e352c3f104 100644
--- a/src/Processors/Merges/Algorithms/IMergingAlgorithm.h
+++ b/src/Processors/Merges/Algorithms/IMergingAlgorithm.h
@@ -31,7 +31,7 @@ public:
 
         IColumn::Permutation * permutation = nullptr;
 
-        void swap(Input & other)
+        void swap(Input & other) noexcept
         {
             chunk.swap(other.chunk);
             std::swap(skip_last_row, other.skip_last_row);
diff --git a/src/Processors/Merges/Algorithms/RowRef.h b/src/Processors/Merges/Algorithms/RowRef.h
index ee64224d44d..af379ec59f6 100644
--- a/src/Processors/Merges/Algorithms/RowRef.h
+++ b/src/Processors/Merges/Algorithms/RowRef.h
@@ -181,7 +181,7 @@ struct RowRefWithOwnedChunk
 
     UInt64 source_stream_index = 0;
 
-    void swap(RowRefWithOwnedChunk & other)
+    void swap(RowRefWithOwnedChunk & other) /// NOLINT(performance-noexcept-swap)
     {
         owned_chunk.swap(other.owned_chunk);
         std::swap(all_columns, other.all_columns);
diff --git a/src/Processors/Transforms/MergeJoinTransform.h b/src/Processors/Transforms/MergeJoinTransform.h
index 793de00db40..959550067f7 100644
--- a/src/Processors/Transforms/MergeJoinTransform.h
+++ b/src/Processors/Transforms/MergeJoinTransform.h
@@ -230,9 +230,9 @@ public:
     explicit MergeJoinAlgorithm(JoinPtr table_join, const Blocks & input_headers, size_t max_block_size_);
 
     const char * getName() const override { return "MergeJoinAlgorithm"; }
-    virtual void initialize(Inputs inputs) override;
-    virtual void consume(Input & input, size_t source_num) override;
-    virtual Status merge() override;
+    void initialize(Inputs inputs) override;
+    void consume(Input & input, size_t source_num) override;
+    Status merge() override;
 
     void logElapsed(double seconds);
 
diff --git a/src/Processors/Transforms/PasteJoinTransform.h b/src/Processors/Transforms/PasteJoinTransform.h
index 04cb5486cd5..6a7e65ee27c 100644
--- a/src/Processors/Transforms/PasteJoinTransform.h
+++ b/src/Processors/Transforms/PasteJoinTransform.h
@@ -32,9 +32,9 @@ public:
     explicit PasteJoinAlgorithm(JoinPtr table_join, const Blocks & input_headers, size_t max_block_size_);
 
     const char * getName() const override { return "PasteJoinAlgorithm"; }
-    virtual void initialize(Inputs inputs) override;
-    virtual void consume(Input & input, size_t source_num) override;
-    virtual Status merge() override;
+    void initialize(Inputs inputs) override;
+    void consume(Input & input, size_t source_num) override;
+    Status merge() override;
 
     void logElapsed(double seconds);
 
diff --git a/src/QueryPipeline/QueryPipelineBuilder.h b/src/QueryPipeline/QueryPipelineBuilder.h
index 5d273df7068..f0b2ead687e 100644
--- a/src/QueryPipeline/QueryPipelineBuilder.h
+++ b/src/QueryPipeline/QueryPipelineBuilder.h
@@ -188,7 +188,7 @@ public:
         concurrency_control = concurrency_control_;
     }
 
-    bool getConcurrencyControl()
+    bool getConcurrencyControl() const
     {
         return concurrency_control;
     }
diff --git a/src/Server/GRPCServer.cpp b/src/Server/GRPCServer.cpp
index f21991e8d58..dfae812c620 100644
--- a/src/Server/GRPCServer.cpp
+++ b/src/Server/GRPCServer.cpp
@@ -618,7 +618,6 @@ namespace
 
 
     /// Handles a connection after a responder is started (i.e. after getting a new call).
-// NOLINTBEGIN(clang-analyzer-optin.performance.Padding)
     class Call
     {
     public:
@@ -724,7 +723,6 @@ namespace
 
         ThreadFromGlobalPool call_thread;
     };
-// NOLINTEND(clang-analyzer-optin.performance.Padding)
 
     Call::Call(CallType call_type_, std::unique_ptr<BaseResponder> responder_, IServer & iserver_, LoggerRawPtr log_)
         : call_type(call_type_), responder(std::move(responder_)), iserver(iserver_), log(log_)
diff --git a/src/Server/HTTP/HTTPServerResponse.h b/src/Server/HTTP/HTTPServerResponse.h
index 6c5be008bf8..8edb785e7c5 100644
--- a/src/Server/HTTP/HTTPServerResponse.h
+++ b/src/Server/HTTP/HTTPServerResponse.h
@@ -90,7 +90,7 @@ public:
         resizeIfNeeded(buf_size);
     }
 
-    bool isChunked()
+    bool isChunked() const
     {
         return chunked;
     }
@@ -103,7 +103,7 @@ public:
         resizeIfNeeded(length);
     }
 
-    size_t isFixedLength()
+    size_t isFixedLength() const
     {
         return chunked ? 0 : fixed_length;
     }
@@ -116,7 +116,7 @@ public:
         resizeIfNeeded(buf_size);
     }
 
-    bool isPlain()
+    bool isPlain() const
     {
         return !(isChunked() || isFixedLength());
     }
diff --git a/src/Server/HTTPHandler.h b/src/Server/HTTPHandler.h
index 0e30b466694..39cef0e7112 100644
--- a/src/Server/HTTPHandler.h
+++ b/src/Server/HTTPHandler.h
@@ -32,7 +32,7 @@ class HTTPHandler : public HTTPRequestHandler
 {
 public:
     HTTPHandler(IServer & server_, const std::string & name, const std::optional<String> & content_type_override_);
-    virtual ~HTTPHandler() override;
+    ~HTTPHandler() override;
 
     void handleRequest(HTTPServerRequest & request, HTTPServerResponse & response, const ProfileEvents::Event & write_event) override;
 
diff --git a/src/Storages/DataLakes/S3MetadataReader.h b/src/Storages/DataLakes/S3MetadataReader.h
index cae7dd1fa3d..c29a66b3813 100644
--- a/src/Storages/DataLakes/S3MetadataReader.h
+++ b/src/Storages/DataLakes/S3MetadataReader.h
@@ -6,11 +6,11 @@
 
 #include <Storages/StorageS3.h>
 
-class ReadBuffer;
-
 namespace DB
 {
 
+class ReadBuffer;
+
 struct S3DataLakeMetadataReadHelper
 {
     static std::shared_ptr<ReadBuffer> createReadBuffer(
diff --git a/src/Storages/FileLog/FileLogSource.h b/src/Storages/FileLog/FileLogSource.h
index 281b109ff4b..3ac2b407e10 100644
--- a/src/Storages/FileLog/FileLogSource.h
+++ b/src/Storages/FileLog/FileLogSource.h
@@ -30,7 +30,7 @@ public:
 
     void onFinish();
 
-    virtual ~FileLogSource() override;
+    ~FileLogSource() override;
 
 protected:
     Chunk generate() override;
diff --git a/src/Storages/Hive/HiveFile.h b/src/Storages/Hive/HiveFile.h
index 1f5e31f1d54..601c7f2a310 100644
--- a/src/Storages/Hive/HiveFile.h
+++ b/src/Storages/Hive/HiveFile.h
@@ -65,7 +65,7 @@ public:
         {ORC_INPUT_FORMAT, FileFormat::ORC},
     };
 
-    static inline bool isFormatClass(const String & format_class) { return VALID_HDFS_FORMATS.count(format_class) > 0; }
+    static inline bool isFormatClass(const String & format_class) { return VALID_HDFS_FORMATS.contains(format_class); }
     static inline FileFormat toFileFormat(const String & format_class)
     {
         if (isFormatClass(format_class))
diff --git a/src/Storages/IStorage.cpp b/src/Storages/IStorage.cpp
index 9852220241f..b532abc9074 100644
--- a/src/Storages/IStorage.cpp
+++ b/src/Storages/IStorage.cpp
@@ -305,7 +305,7 @@ void IStorage::backupData(BackupEntriesCollector &, const String &, const std::o
 void IStorage::restoreDataFromBackup(RestorerFromBackup & restorer, const String & data_path_in_backup, const std::optional<ASTs> &)
 {
     /// If an inherited class doesn't override restoreDataFromBackup() that means it doesn't backup any data.
-    auto filenames = restorer.getBackup()->listFiles(data_path_in_backup);
+    auto filenames = restorer.getBackup()->listFiles(data_path_in_backup, /*recursive*/ false);
     if (!filenames.empty())
         throw Exception(ErrorCodes::CANNOT_RESTORE_TABLE, "Cannot restore table {}: Folder {} in backup must be empty",
                         getStorageID().getFullTableName(), data_path_in_backup);
diff --git a/src/Storages/Kafka/KafkaConsumer.h b/src/Storages/Kafka/KafkaConsumer.h
index 9cc78d42856..f160d1c0855 100644
--- a/src/Storages/Kafka/KafkaConsumer.h
+++ b/src/Storages/Kafka/KafkaConsumer.h
@@ -184,7 +184,7 @@ private:
     std::atomic<UInt64> last_rebalance_timestamp_usec = 0;
     std::atomic<UInt64> num_rebalance_assignments = 0;
     std::atomic<UInt64> num_rebalance_revocations = 0;
-    std::atomic<bool> in_use = 0;
+    std::atomic<bool> in_use = false;
     /// Last used time (for TTL)
     std::atomic<UInt64> last_used_usec = 0;
 
diff --git a/src/Storages/Kafka/parseSyslogLevel.cpp b/src/Storages/Kafka/parseSyslogLevel.cpp
index f4358a13efe..43630a5001f 100644
--- a/src/Storages/Kafka/parseSyslogLevel.cpp
+++ b/src/Storages/Kafka/parseSyslogLevel.cpp
@@ -4,7 +4,7 @@
 /// Must be in a separate compilation unit due to macros overlaps:
 /// - syslog (LOG_DEBUG/...)
 /// - logger_useful.h (LOG_DEBUG(...)/...)
-std::pair<Poco::Message::Priority, DB::LogsLevel> parseSyslogLevel(const int level)
+std::pair<Poco::Message::Priority, DB::LogsLevel> parseSyslogLevel(int level)
 {
     using DB::LogsLevel;
     using Poco::Message;
diff --git a/src/Storages/Kafka/parseSyslogLevel.h b/src/Storages/Kafka/parseSyslogLevel.h
index f0fb4968631..a004fc3d29f 100644
--- a/src/Storages/Kafka/parseSyslogLevel.h
+++ b/src/Storages/Kafka/parseSyslogLevel.h
@@ -4,4 +4,4 @@
 #include <Poco/Message.h>
 #include <Common/CurrentThread.h>
 
-std::pair<Poco::Message::Priority, DB::LogsLevel> parseSyslogLevel(const int level);
+std::pair<Poco::Message::Priority, DB::LogsLevel> parseSyslogLevel(int level);
diff --git a/src/Storages/MergeTree/ColumnSizeEstimator.h b/src/Storages/MergeTree/ColumnSizeEstimator.h
index e512415ff05..1307a5f493e 100644
--- a/src/Storages/MergeTree/ColumnSizeEstimator.h
+++ b/src/Storages/MergeTree/ColumnSizeEstimator.h
@@ -23,9 +23,9 @@ public:
         : map(std::move(map_))
     {
         for (const auto & name : key_columns)
-            if (!map.count(name)) map[name] = 0;
+            if (!map.contains(name)) map[name] = 0;
         for (const auto & name : ordinary_columns)
-            if (!map.count(name)) map[name] = 0;
+            if (!map.contains(name)) map[name] = 0;
 
         for (const auto & name : key_columns)
             sum_index_columns += map.at(name);
diff --git a/src/Storages/MergeTree/IMergeTreeDataPart.h b/src/Storages/MergeTree/IMergeTreeDataPart.h
index 8bd32e777bc..57243335238 100644
--- a/src/Storages/MergeTree/IMergeTreeDataPart.h
+++ b/src/Storages/MergeTree/IMergeTreeDataPart.h
@@ -218,7 +218,6 @@ public:
 
     const MergeTreeData & storage;
 
-public:
     const String & name;    // const ref to private mutable_name
     MergeTreePartInfo info;
 
diff --git a/src/Storages/MergeTree/LeaderElection.h b/src/Storages/MergeTree/LeaderElection.h
index 3bd486fd54a..b7dc9c31655 100644
--- a/src/Storages/MergeTree/LeaderElection.h
+++ b/src/Storages/MergeTree/LeaderElection.h
@@ -19,7 +19,7 @@ namespace zkutil
   * For now, every replica can become leader if there is no leader among replicas with old version.
   */
 
-void checkNoOldLeaders(LoggerPtr log, ZooKeeper & zookeeper, const String path)
+inline void checkNoOldLeaders(LoggerPtr log, ZooKeeper & zookeeper, const String path)
 {
     /// Previous versions (before 21.12) used to create ephemeral sequential node path/leader_election-
     /// Replica with the lexicographically smallest node name becomes leader (before 20.6) or enables multi-leader mode (since 20.6)
diff --git a/src/Storages/MergeTree/MarkRange.h b/src/Storages/MergeTree/MarkRange.h
index f31d6a2a73b..1d9d0a1e27e 100644
--- a/src/Storages/MergeTree/MarkRange.h
+++ b/src/Storages/MergeTree/MarkRange.h
@@ -33,7 +33,7 @@ struct MarkRange
 
 struct MarkRanges : public std::deque<MarkRange>
 {
-    using std::deque<MarkRange>::deque;
+    using std::deque<MarkRange>::deque; /// NOLINT(modernize-type-traits)
 
     size_t getNumberOfMarks() const;
 
diff --git a/src/Storages/MergeTree/MergeTreeData.cpp b/src/Storages/MergeTree/MergeTreeData.cpp
index aacac5366a9..ba30c13049b 100644
--- a/src/Storages/MergeTree/MergeTreeData.cpp
+++ b/src/Storages/MergeTree/MergeTreeData.cpp
@@ -5435,7 +5435,7 @@ void MergeTreeData::restorePartsFromBackup(RestorerFromBackup & restorer, const
         partition_ids = getPartitionIDsFromQuery(*partitions, restorer.getContext());
 
     auto backup = restorer.getBackup();
-    Strings part_names = backup->listFiles(data_path_in_backup);
+    Strings part_names = backup->listFiles(data_path_in_backup, /*recursive*/ false);
     boost::remove_erase(part_names, "mutations");
 
     bool restore_broken_parts_as_detached = restorer.getRestoreSettings().restore_broken_parts_as_detached;
@@ -5516,7 +5516,7 @@ void MergeTreeData::restorePartFromBackup(std::shared_ptr<RestoredPartsHolder> r
         if (filename.ends_with(IMergeTreeDataPart::TXN_VERSION_METADATA_FILE_NAME))
             continue;
 
-        size_t file_size = backup->copyFileToDisk(part_path_in_backup_fs / filename, disk, temp_part_dir / filename);
+        size_t file_size = backup->copyFileToDisk(part_path_in_backup_fs / filename, disk, temp_part_dir / filename, WriteMode::Rewrite);
         reservation->update(reservation->getSize() - file_size);
     }
 
diff --git a/src/Storages/MergeTree/MergeTreeData.h b/src/Storages/MergeTree/MergeTreeData.h
index c864fce4659..8305c7c6ce9 100644
--- a/src/Storages/MergeTree/MergeTreeData.h
+++ b/src/Storages/MergeTree/MergeTreeData.h
@@ -1372,7 +1372,7 @@ protected:
                 latest_fail_time_us = static_cast<size_t>(Poco::Timestamp().epochMicroseconds());
             }
 
-            bool partCanBeMutated()
+            bool partCanBeMutated() const
             {
                 if (max_postpone_time_ms == 0)
                     return true;
diff --git a/src/Storages/MergeTree/MergeTreeMutationStatus.h b/src/Storages/MergeTree/MergeTreeMutationStatus.h
index b6f62e1218f..4bc9549872c 100644
--- a/src/Storages/MergeTree/MergeTreeMutationStatus.h
+++ b/src/Storages/MergeTree/MergeTreeMutationStatus.h
@@ -13,6 +13,7 @@ namespace DB
 
 struct MergeTreeMutationStatus
 {
+/// NOLINTBEGIN(readability-redundant-string-init)
     String id = "";
     String command = "";
     time_t create_time = 0;
@@ -30,6 +31,7 @@ struct MergeTreeMutationStatus
 
     /// FIXME: currently unused, but would be much better to report killed mutations with this flag.
     bool is_killed = false;
+/// NOLINTEND(readability-redundant-string-init)
 };
 
 /// Check mutation status and throw exception in case of error during mutation
diff --git a/src/Storages/MergeTree/RPNBuilder.h b/src/Storages/MergeTree/RPNBuilder.h
index d750c02d3e1..f8924ff6186 100644
--- a/src/Storages/MergeTree/RPNBuilder.h
+++ b/src/Storages/MergeTree/RPNBuilder.h
@@ -226,7 +226,7 @@ private:
                       * - in this case `n - 1` elements are added (where `n` is the number of arguments).
                       */
                     if (argument_index != 0 || element.function == RPNElement::FUNCTION_NOT)
-                        rpn_elements.emplace_back(std::move(element));
+                        rpn_elements.emplace_back(std::move(element)); /// NOLINT(bugprone-use-after-move,hicpp-invalid-access-moved)
                 }
 
                 if (arguments_size == 0 && function_node.getFunctionName() == "indexHint")
diff --git a/src/Storages/MergeTree/RangesInDataPart.h b/src/Storages/MergeTree/RangesInDataPart.h
index 0bc5829c82e..e275f2c27e7 100644
--- a/src/Storages/MergeTree/RangesInDataPart.h
+++ b/src/Storages/MergeTree/RangesInDataPart.h
@@ -67,7 +67,7 @@ struct RangesInDataPart
 
 struct RangesInDataParts: public std::vector<RangesInDataPart>
 {
-    using std::vector<RangesInDataPart>::vector;
+    using std::vector<RangesInDataPart>::vector; /// NOLINT(modernize-type-traits)
 
     RangesInDataPartsDescription getDescriptions() const;
 
diff --git a/src/Storages/MergeTree/ReplicatedMergeTreeQuorumAddedParts.h b/src/Storages/MergeTree/ReplicatedMergeTreeQuorumAddedParts.h
index f0f737cb1e6..81045460ab7 100644
--- a/src/Storages/MergeTree/ReplicatedMergeTreeQuorumAddedParts.h
+++ b/src/Storages/MergeTree/ReplicatedMergeTreeQuorumAddedParts.h
@@ -66,7 +66,7 @@ struct ReplicatedMergeTreeQuorumAddedParts
     }
 
     /// Read added blocks when node in ZooKeeper supports only one partition.
-    PartitionIdToPartName readV1(ReadBuffer & in)
+    PartitionIdToPartName readV1(ReadBuffer & in) const
     {
         PartitionIdToPartName parts_in_quorum;
 
diff --git a/src/Storages/MergeTree/checkDataPart.cpp b/src/Storages/MergeTree/checkDataPart.cpp
index aea0020f89d..2d7727b57cb 100644
--- a/src/Storages/MergeTree/checkDataPart.cpp
+++ b/src/Storages/MergeTree/checkDataPart.cpp
@@ -56,7 +56,7 @@ bool isNotEnoughMemoryErrorCode(int code)
         || code == ErrorCodes::CANNOT_MREMAP;
 }
 
-bool isRetryableException(const std::exception_ptr exception_ptr)
+bool isRetryableException(std::exception_ptr exception_ptr)
 {
     try
     {
diff --git a/src/Storages/MergeTree/checkDataPart.h b/src/Storages/MergeTree/checkDataPart.h
index d0e48b6f80a..ada89a54dcc 100644
--- a/src/Storages/MergeTree/checkDataPart.h
+++ b/src/Storages/MergeTree/checkDataPart.h
@@ -13,6 +13,6 @@ IMergeTreeDataPart::Checksums checkDataPart(
     std::function<bool()> is_cancelled = []{ return false; });
 
 bool isNotEnoughMemoryErrorCode(int code);
-bool isRetryableException(const std::exception_ptr exception_ptr);
+bool isRetryableException(std::exception_ptr exception_ptr);
 
 }
diff --git a/src/Storages/RabbitMQ/RabbitMQProducer.cpp b/src/Storages/RabbitMQ/RabbitMQProducer.cpp
index 7ad83213b9b..f0fbc8c5c06 100644
--- a/src/Storages/RabbitMQ/RabbitMQProducer.cpp
+++ b/src/Storages/RabbitMQ/RabbitMQProducer.cpp
@@ -27,9 +27,9 @@ RabbitMQProducer::RabbitMQProducer(
     const RabbitMQConfiguration & configuration_,
     const Names & routing_keys_,
     const String & exchange_name_,
-    const AMQP::ExchangeType exchange_type_,
-    const size_t channel_id_base_,
-    const bool persistent_,
+    AMQP::ExchangeType exchange_type_,
+    size_t channel_id_base_,
+    bool persistent_,
     std::atomic<bool> & shutdown_called_,
     LoggerPtr log_)
     : AsynchronousMessageProducer(log_)
diff --git a/src/Storages/RabbitMQ/RabbitMQProducer.h b/src/Storages/RabbitMQ/RabbitMQProducer.h
index a790eda0d08..e43518aec06 100644
--- a/src/Storages/RabbitMQ/RabbitMQProducer.h
+++ b/src/Storages/RabbitMQ/RabbitMQProducer.h
@@ -20,9 +20,9 @@ public:
         const RabbitMQConfiguration & configuration_,
         const Names & routing_keys_,
         const String & exchange_name_,
-        const AMQP::ExchangeType exchange_type_,
-        const size_t channel_id_base_,
-        const bool persistent_,
+        AMQP::ExchangeType exchange_type_,
+        size_t channel_id_base_,
+        bool persistent_,
         std::atomic<bool> & shutdown_called_,
         LoggerPtr log_);
 
diff --git a/src/Storages/S3Queue/StorageS3Queue.h b/src/Storages/S3Queue/StorageS3Queue.h
index bdd3ab7b687..fe86759ca62 100644
--- a/src/Storages/S3Queue/StorageS3Queue.h
+++ b/src/Storages/S3Queue/StorageS3Queue.h
@@ -14,11 +14,6 @@
 #include <Storages/StorageFactory.h>
 
 
-namespace Aws::S3
-{
-class Client;
-}
-
 namespace DB
 {
 class S3QueueFilesMetadata;
diff --git a/src/Storages/StorageInMemoryMetadata.h b/src/Storages/StorageInMemoryMetadata.h
index 69cd3422a7d..afc3bc81ef6 100644
--- a/src/Storages/StorageInMemoryMetadata.h
+++ b/src/Storages/StorageInMemoryMetadata.h
@@ -72,8 +72,8 @@ struct StorageInMemoryMetadata
     StorageInMemoryMetadata(const StorageInMemoryMetadata & other);
     StorageInMemoryMetadata & operator=(const StorageInMemoryMetadata & other);
 
-    StorageInMemoryMetadata(StorageInMemoryMetadata && other) = default; /// NOLINT
-    StorageInMemoryMetadata & operator=(StorageInMemoryMetadata && other) = default; /// NOLINT
+    StorageInMemoryMetadata(StorageInMemoryMetadata && other) = default; /// NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    StorageInMemoryMetadata & operator=(StorageInMemoryMetadata && other) = default; /// NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
 
     /// NOTE: Thread unsafe part. You should not modify same StorageInMemoryMetadata
     /// structure from different threads. It should be used as MultiVersion
diff --git a/src/Storages/StorageMongoDBSocketFactory.h b/src/Storages/StorageMongoDBSocketFactory.h
index 5fc423c63cb..2dc9cbddf8a 100644
--- a/src/Storages/StorageMongoDBSocketFactory.h
+++ b/src/Storages/StorageMongoDBSocketFactory.h
@@ -9,7 +9,7 @@ namespace DB
 class StorageMongoDBSocketFactory : public Poco::MongoDB::Connection::SocketFactory
 {
 public:
-    virtual Poco::Net::StreamSocket createSocket(const std::string & host, int port, Poco::Timespan connectTimeout, bool secure) override;
+    Poco::Net::StreamSocket createSocket(const std::string & host, int port, Poco::Timespan connectTimeout, bool secure) override;
 
 private:
     static Poco::Net::StreamSocket createPlainSocket(const std::string & host, int port, Poco::Timespan connectTimeout);
diff --git a/src/Storages/StorageS3.h b/src/Storages/StorageS3.h
index 7c5db76aadf..f570a7e3a58 100644
--- a/src/Storages/StorageS3.h
+++ b/src/Storages/StorageS3.h
@@ -26,11 +26,6 @@
 #include <Storages/prepareReadingFromFormat.h>
 #include <IO/S3/BlobStorageLogWriter.h>
 
-namespace Aws::S3
-{
-    class Client;
-}
-
 namespace DB
 {
 
diff --git a/src/Storages/StorageView.cpp b/src/Storages/StorageView.cpp
index 673ca61cd50..db568a1d5ab 100644
--- a/src/Storages/StorageView.cpp
+++ b/src/Storages/StorageView.cpp
@@ -110,7 +110,7 @@ StorageView::StorageView(
     const ASTCreateQuery & query,
     const ColumnsDescription & columns_,
     const String & comment,
-    const bool is_parameterized_view_)
+    bool is_parameterized_view_)
     : IStorage(table_id_)
 {
     StorageInMemoryMetadata storage_metadata;
diff --git a/src/Storages/StorageView.h b/src/Storages/StorageView.h
index 4d265eed86b..053fca807d5 100644
--- a/src/Storages/StorageView.h
+++ b/src/Storages/StorageView.h
@@ -16,7 +16,7 @@ public:
         const ASTCreateQuery & query,
         const ColumnsDescription & columns_,
         const String & comment,
-        const bool is_parameterized_view_=false);
+        bool is_parameterized_view_ = false);
 
     std::string getName() const override { return "View"; }
     bool isView() const override { return true; }
@@ -45,7 +45,7 @@ public:
         replaceWithSubquery(select_query, metadata_snapshot->getSelectQuery().inner_query->clone(), view_name, parameterized_view);
     }
 
-    static void replaceWithSubquery(ASTSelectQuery & outer_query, ASTPtr view_query, ASTPtr & view_name, const bool parameterized_view);
+    static void replaceWithSubquery(ASTSelectQuery & outer_query, ASTPtr view_query, ASTPtr & view_name, bool parameterized_view);
     static ASTPtr restoreViewName(ASTSelectQuery & select_query, const ASTPtr & view_name);
 
 protected:
diff --git a/src/Storages/System/StorageSystemPartsBase.h b/src/Storages/System/StorageSystemPartsBase.h
index 0527a99b841..10d1a3a2e0e 100644
--- a/src/Storages/System/StorageSystemPartsBase.h
+++ b/src/Storages/System/StorageSystemPartsBase.h
@@ -94,7 +94,7 @@ protected:
         // nullptr means table was dropped while acquiring the lock
         return info.table_lock != nullptr;
     }
-protected:
+
     String query_id;
     Settings settings;
 
diff --git a/src/Storages/System/StorageSystemTimeZones.h b/src/Storages/System/StorageSystemTimeZones.h
index 160e8854e3e..3f9db2f53e2 100644
--- a/src/Storages/System/StorageSystemTimeZones.h
+++ b/src/Storages/System/StorageSystemTimeZones.h
@@ -17,7 +17,6 @@ public:
 
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
 
-public:
     std::string getName() const override { return "SystemTimeZones"; }
 
     static ColumnsDescription getColumnsDescription();