Fix for clang-19

2024-11-22 15:42:02 +00:00 · 2024-03-22 22:12:59 +01:00 · 2024-03-22 22:12:59 +01:00 · a56c113c83
commit a56c113c83
parent 14c616e696
30 changed files with 42 additions and 69 deletions
--- a/src/AggregateFunctions/AggregateFunctionQuantile.cpp
+++ b/src/AggregateFunctions/AggregateFunctionQuantile.cpp
@ -116,9 +116,6 @@ template <template <typename, bool> class Function>
 AggregateFunctionPtr createAggregateFunctionQuantile(
    const std::string & name, const DataTypes & argument_types, const Array & params, const Settings *)
 {
-    /// Second argument type check doesn't depend on the type of the first one.
-    Function<void, true>::assertSecondArg(argument_types);
-
    const DataTypePtr & argument_type = argument_types[0];
    WhichDataType which(argument_type);

--- a/src/AggregateFunctions/AggregateFunctionQuantile.h
+++ b/src/AggregateFunctions/AggregateFunctionQuantile.h
@ -91,6 +91,21 @@ public:
        if (!returns_many && levels.size() > 1)
            throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH, "Aggregate function {} requires one level parameter or less", getName());

+        if constexpr (has_second_arg)
+        {
+            assertBinary(Name::name, argument_types_);
+            if (!isUInt(argument_types_[1]))
+                throw Exception(
+                    ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
+                    "Second argument (weight) for function {} must be unsigned integer, but it has type {}",
+                    Name::name,
+                    argument_types_[1]->getName());
+        }
+        else
+        {
+            assertUnary(Name::name, argument_types_);
+        }
+
        if constexpr (is_quantile_ddsketch)
        {
            if (params.empty())
@ -272,22 +287,6 @@ public:
                static_cast<ColVecType &>(to).getData().push_back(data.get(level));
        }
    }
-
-    static void assertSecondArg(const DataTypes & types)
-    {
-        if constexpr (has_second_arg)
-        {
-            assertBinary(Name::name, types);
-            if (!isUInt(types[1]))
-                throw Exception(
-                    ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
-                    "Second argument (weight) for function {} must be unsigned integer, but it has type {}",
-                    Name::name,
-                    types[1]->getName());
-        }
-        else
-            assertUnary(Name::name, types);
-    }
 };

 struct NameQuantile { static constexpr auto name = "quantile"; };
--- a/src/AggregateFunctions/AggregateFunctionQuantileBFloat16.cpp
+++ b/src/AggregateFunctions/AggregateFunctionQuantileBFloat16.cpp
@ -26,9 +26,6 @@ template <template <typename, bool> class Function>
 AggregateFunctionPtr createAggregateFunctionQuantile(
    const std::string & name, const DataTypes & argument_types, const Array & params, const Settings *)
 {
-    /// Second argument type check doesn't depend on the type of the first one.
-    Function<void, true>::assertSecondArg(argument_types);
-
    const DataTypePtr & argument_type = argument_types[0];
    WhichDataType which(argument_type);

--- a/src/AggregateFunctions/AggregateFunctionQuantileBFloat16Weighted.cpp
+++ b/src/AggregateFunctions/AggregateFunctionQuantileBFloat16Weighted.cpp
@ -26,9 +26,6 @@ template <template <typename, bool> class Function>
 AggregateFunctionPtr createAggregateFunctionQuantile(
    const std::string & name, const DataTypes & argument_types, const Array & params, const Settings *)
 {
-    /// Second argument type check doesn't depend on the type of the first one.
-    Function<void, true>::assertSecondArg(argument_types);
-
    const DataTypePtr & argument_type = argument_types[0];
    WhichDataType which(argument_type);

--- a/src/AggregateFunctions/AggregateFunctionQuantileDD.cpp
+++ b/src/AggregateFunctions/AggregateFunctionQuantileDD.cpp
@ -27,9 +27,6 @@ template <template <typename, bool> class Function>
 AggregateFunctionPtr createAggregateFunctionQuantile(
    const std::string & name, const DataTypes & argument_types, const Array & params, const Settings *)
 {
-    /// Second argument type check doesn't depend on the type of the first one.
-    Function<void, true>::assertSecondArg(argument_types);
-
    const DataTypePtr & argument_type = argument_types[0];
    WhichDataType which(argument_type);

--- a/src/AggregateFunctions/AggregateFunctionQuantileDeterministic.cpp
+++ b/src/AggregateFunctions/AggregateFunctionQuantileDeterministic.cpp
@ -116,9 +116,6 @@ template <template <typename, bool> class Function>
 AggregateFunctionPtr createAggregateFunctionQuantile(
    const std::string & name, const DataTypes & argument_types, const Array & params, const Settings *)
 {
-    /// Second argument type check doesn't depend on the type of the first one.
-    Function<void, true>::assertSecondArg(argument_types);
-
    const DataTypePtr & argument_type = argument_types[0];
    WhichDataType which(argument_type);

--- a/src/AggregateFunctions/AggregateFunctionQuantileExact.cpp
+++ b/src/AggregateFunctions/AggregateFunctionQuantileExact.cpp
@ -27,9 +27,6 @@ template <template <typename, bool> class Function>
 AggregateFunctionPtr createAggregateFunctionQuantile(
    const std::string & name, const DataTypes & argument_types, const Array & params, const Settings *)
 {
-    /// Second argument type check doesn't depend on the type of the first one.
-    Function<void, true>::assertSecondArg(argument_types);
-
    const DataTypePtr & argument_type = argument_types[0];
    WhichDataType which(argument_type);

--- a/src/AggregateFunctions/AggregateFunctionQuantileExactExclusive.cpp
+++ b/src/AggregateFunctions/AggregateFunctionQuantileExactExclusive.cpp
@ -26,9 +26,6 @@ template <template <typename, bool> class Function>
 AggregateFunctionPtr createAggregateFunctionQuantile(
    const std::string & name, const DataTypes & argument_types, const Array & params, const Settings *)
 {
-    /// Second argument type check doesn't depend on the type of the first one.
-    Function<void, true>::assertSecondArg(argument_types);
-
    const DataTypePtr & argument_type = argument_types[0];
    WhichDataType which(argument_type);

--- a/src/AggregateFunctions/AggregateFunctionQuantileExactHigh.cpp
+++ b/src/AggregateFunctions/AggregateFunctionQuantileExactHigh.cpp
@ -27,9 +27,6 @@ template <template <typename, bool> class Function>
 AggregateFunctionPtr createAggregateFunctionQuantile(
    const std::string & name, const DataTypes & argument_types, const Array & params, const Settings *)
 {
-    /// Second argument type check doesn't depend on the type of the first one.
-    Function<void, true>::assertSecondArg(argument_types);
-
    const DataTypePtr & argument_type = argument_types[0];
    WhichDataType which(argument_type);

@ -39,12 +36,12 @@ AggregateFunctionPtr createAggregateFunctionQuantile(
 #undef DISPATCH
    if (which.idx == TypeIndex::Date) return std::make_shared<Function<DataTypeDate::FieldType, false>>(argument_types, params);
    if (which.idx == TypeIndex::DateTime) return std::make_shared<Function<DataTypeDateTime::FieldType, false>>(argument_types, params);
+    if (which.idx == TypeIndex::DateTime64) return std::make_shared<Function<DateTime64, false>>(argument_types, params);

    if (which.idx == TypeIndex::Decimal32) return std::make_shared<Function<Decimal32, false>>(argument_types, params);
    if (which.idx == TypeIndex::Decimal64) return std::make_shared<Function<Decimal64, false>>(argument_types, params);
    if (which.idx == TypeIndex::Decimal128) return std::make_shared<Function<Decimal128, false>>(argument_types, params);
    if (which.idx == TypeIndex::Decimal256) return std::make_shared<Function<Decimal256, false>>(argument_types, params);
-    if (which.idx == TypeIndex::DateTime64) return std::make_shared<Function<DateTime64, false>>(argument_types, params);

    throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "Illegal type {} of argument for aggregate function {}",
                    argument_type->getName(), name);
--- a/src/AggregateFunctions/AggregateFunctionQuantileExactInclusive.cpp
+++ b/src/AggregateFunctions/AggregateFunctionQuantileExactInclusive.cpp
@ -26,9 +26,6 @@ template <template <typename, bool> class Function>
 AggregateFunctionPtr createAggregateFunctionQuantile(
    const std::string & name, const DataTypes & argument_types, const Array & params, const Settings *)
 {
-    /// Second argument type check doesn't depend on the type of the first one.
-    Function<void, true>::assertSecondArg(argument_types);
-
    const DataTypePtr & argument_type = argument_types[0];
    WhichDataType which(argument_type);

--- a/src/AggregateFunctions/AggregateFunctionQuantileExactLow.cpp
+++ b/src/AggregateFunctions/AggregateFunctionQuantileExactLow.cpp
@ -26,9 +26,6 @@ template <template <typename, bool> class Function>
 AggregateFunctionPtr createAggregateFunctionQuantile(
    const std::string & name, const DataTypes & argument_types, const Array & params, const Settings *)
 {
-    /// Second argument type check doesn't depend on the type of the first one.
-    Function<void, true>::assertSecondArg(argument_types);
-
    const DataTypePtr & argument_type = argument_types[0];
    WhichDataType which(argument_type);

--- a/src/AggregateFunctions/AggregateFunctionQuantileExactWeighted.cpp
+++ b/src/AggregateFunctions/AggregateFunctionQuantileExactWeighted.cpp
@ -216,9 +216,6 @@ template <template <typename, bool> class Function>
 AggregateFunctionPtr createAggregateFunctionQuantile(
    const std::string & name, const DataTypes & argument_types, const Array & params, const Settings *)
 {
-    /// Second argument type check doesn't depend on the type of the first one.
-    Function<void, true>::assertSecondArg(argument_types);
-
    const DataTypePtr & argument_type = argument_types[0];
    WhichDataType which(argument_type);

--- a/src/AggregateFunctions/AggregateFunctionQuantileGK.cpp
+++ b/src/AggregateFunctions/AggregateFunctionQuantileGK.cpp
@ -503,9 +503,6 @@ template <template <typename, bool> class Function>
 AggregateFunctionPtr createAggregateFunctionQuantile(
    const std::string & name, const DataTypes & argument_types, const Array & params, const Settings *)
 {
-    /// Second argument type check doesn't depend on the type of the first one.
-    Function<void, true>::assertSecondArg(argument_types);
-
    const DataTypePtr & argument_type = argument_types[0];
    WhichDataType which(argument_type);

--- a/src/AggregateFunctions/AggregateFunctionQuantileInterpolatedWeighted.cpp
+++ b/src/AggregateFunctions/AggregateFunctionQuantileInterpolatedWeighted.cpp
@ -320,9 +320,6 @@ template <template <typename, bool> class Function>
 AggregateFunctionPtr createAggregateFunctionQuantile(
    const std::string & name, const DataTypes & argument_types, const Array & params, const Settings *)
 {
-    /// Second argument type check doesn't depend on the type of the first one.
-    Function<void, true>::assertSecondArg(argument_types);
-
    const DataTypePtr & argument_type = argument_types[0];
    WhichDataType which(argument_type);

--- a/src/AggregateFunctions/AggregateFunctionQuantileTDigest.cpp
+++ b/src/AggregateFunctions/AggregateFunctionQuantileTDigest.cpp
@ -26,9 +26,6 @@ template <template <typename, bool> class Function>
 AggregateFunctionPtr createAggregateFunctionQuantile(
    const std::string & name, const DataTypes & argument_types, const Array & params, const Settings *)
 {
-    /// Second argument type check doesn't depend on the type of the first one.
-    Function<void, true>::assertSecondArg(argument_types);
-
    const DataTypePtr & argument_type = argument_types[0];
    WhichDataType which(argument_type);

--- a/src/AggregateFunctions/AggregateFunctionQuantileTDigestWeighted.cpp
+++ b/src/AggregateFunctions/AggregateFunctionQuantileTDigestWeighted.cpp
@ -26,9 +26,6 @@ template <template <typename, bool> class Function>
 AggregateFunctionPtr createAggregateFunctionQuantile(
    const std::string & name, const DataTypes & argument_types, const Array & params, const Settings *)
 {
-    /// Second argument type check doesn't depend on the type of the first one.
-    Function<void, true>::assertSecondArg(argument_types);
-
    const DataTypePtr & argument_type = argument_types[0];
    WhichDataType which(argument_type);

--- a/src/AggregateFunctions/AggregateFunctionQuantileTiming.cpp
+++ b/src/AggregateFunctions/AggregateFunctionQuantileTiming.cpp
@ -26,9 +26,6 @@ template <template <typename, bool> class Function>
 AggregateFunctionPtr createAggregateFunctionQuantile(
    const std::string & name, const DataTypes & argument_types, const Array & params, const Settings *)
 {
-    /// Second argument type check doesn't depend on the type of the first one.
-    Function<void, true>::assertSecondArg(argument_types);
-
    const DataTypePtr & argument_type = argument_types[0];
    WhichDataType which(argument_type);

--- a/src/AggregateFunctions/AggregateFunctionQuantileTimingWeighted.cpp
+++ b/src/AggregateFunctions/AggregateFunctionQuantileTimingWeighted.cpp
@ -26,9 +26,6 @@ template <template <typename, bool> class Function>
 AggregateFunctionPtr createAggregateFunctionQuantile(
    const std::string & name, const DataTypes & argument_types, const Array & params, const Settings *)
 {
-    /// Second argument type check doesn't depend on the type of the first one.
-    Function<void, true>::assertSecondArg(argument_types);
-
    const DataTypePtr & argument_type = argument_types[0];
    WhichDataType which(argument_type);

--- a/src/Interpreters/PreparedSets.cpp
+++ b/src/Interpreters/PreparedSets.cpp
@ -122,6 +122,8 @@ FutureSetFromSubquery::FutureSetFromSubquery(
    set_and_key->set = std::make_shared<Set>(size_limits, settings.use_index_for_in_with_subqueries_max_values, settings.transform_null_in);
 }

+FutureSetFromSubquery::~FutureSetFromSubquery() = default;
+
 SetPtr FutureSetFromSubquery::get() const
 {
    if (set_and_key->set != nullptr && set_and_key->set->isCreated())
--- a/src/Interpreters/PreparedSets.h
+++ b/src/Interpreters/PreparedSets.h
@ -9,11 +9,12 @@
 #include <Storages/IStorage_fwd.h>
 #include <Interpreters/Context_fwd.h>
 #include <Interpreters/SetKeys.h>
-#include <Processors/QueryPlan/QueryPlan.h>

 namespace DB
 {

+class QueryPlan;
+
 class Set;
 using SetPtr = std::shared_ptr<Set>;
 struct SetKeyColumns;
@ -107,6 +108,8 @@ public:
        QueryTreeNodePtr query_tree_,
        const Settings & settings);

+    ~FutureSetFromSubquery() override;
+
    SetPtr get() const override;
    DataTypes getTypes() const override;
    SetPtr buildOrderedSetInplace(const ContextPtr & context) override;
--- a/src/Server/MySQLHandler.cpp
+++ b/src/Server/MySQLHandler.cpp
@ -192,6 +192,8 @@ MySQLHandler::MySQLHandler(
    settings_replacements.emplace("NET_READ_TIMEOUT", "receive_timeout");
 }

+MySQLHandler::~MySQLHandler() = default;
+
 void MySQLHandler::run()
 {
    setThreadName("MySQLHandler");
--- a/src/Server/MySQLHandler.h
+++ b/src/Server/MySQLHandler.h
@ -46,6 +46,8 @@ public:
        const ProfileEvents::Event & read_event_ = ProfileEvents::end(),
        const ProfileEvents::Event & write_event_ = ProfileEvents::end());

+    ~MySQLHandler() override;
+
    void run() final;

 protected:
--- a/src/Storages/HDFS/StorageHDFS.cpp
+++ b/src/Storages/HDFS/StorageHDFS.cpp
@ -624,6 +624,8 @@ HDFSSource::HDFSSource(
    initialize();
 }

+HDFSSource::~HDFSSource() = default;
+
 bool HDFSSource::initialize()
 {
    bool skip_empty_files = getContext()->getSettingsRef().hdfs_skip_empty_files;
--- a/src/Storages/HDFS/StorageHDFS.h
+++ b/src/Storages/HDFS/StorageHDFS.h
@ -153,6 +153,8 @@ public:
        std::shared_ptr<IteratorWrapper> file_iterator_,
        bool need_only_count_);

+    ~HDFSSource() override;
+
    String getName() const override;

    Chunk generate() override;
--- a/src/Storages/Kafka/StorageKafka.cpp
+++ b/src/Storages/Kafka/StorageKafka.cpp
@ -386,6 +386,8 @@ StorageKafka::StorageKafka(
    });
 }

+StorageKafka::~StorageKafka() = default;
+
 VirtualColumnsDescription StorageKafka::createVirtuals(StreamingHandleErrorMode handle_error_mode)
 {
    VirtualColumnsDescription desc;
--- a/src/Storages/Kafka/StorageKafka.h
+++ b/src/Storages/Kafka/StorageKafka.h
@ -42,6 +42,8 @@ public:
        std::unique_ptr<KafkaSettings> kafka_settings_,
        const String & collection_name_);

+    ~StorageKafka() override;
+
    std::string getName() const override { return "Kafka"; }

    bool noPushingToViews() const override { return true; }
--- a/src/Storages/RocksDB/StorageEmbeddedRocksDB.cpp
+++ b/src/Storages/RocksDB/StorageEmbeddedRocksDB.cpp
@ -197,6 +197,8 @@ StorageEmbeddedRocksDB::StorageEmbeddedRocksDB(const StorageID & table_id_,
    initDB();
 }

+StorageEmbeddedRocksDB::~StorageEmbeddedRocksDB() = default;
+
 void StorageEmbeddedRocksDB::truncate(const ASTPtr &, const StorageMetadataPtr & , ContextPtr, TableExclusiveLockHolder &)
 {
    std::lock_guard lock(rocksdb_ptr_mx);
--- a/src/Storages/RocksDB/StorageEmbeddedRocksDB.h
+++ b/src/Storages/RocksDB/StorageEmbeddedRocksDB.h
@ -39,6 +39,8 @@ public:
        String rocksdb_dir_ = "",
        bool read_only_ = false);

+    ~StorageEmbeddedRocksDB() override;
+
    std::string getName() const override { return "EmbeddedRocksDB"; }

    void read(
--- a/src/Storages/StorageURL.cpp
+++ b/src/Storages/StorageURL.cpp
@ -387,6 +387,8 @@ StorageURLSource::StorageURLSource(
    };
 }

+StorageURLSource::~StorageURLSource() = default;
+
 Chunk StorageURLSource::generate()
 {
    while (true)
--- a/src/Storages/StorageURL.h
+++ b/src/Storages/StorageURL.h
@ -181,6 +181,8 @@ public:
        bool glob_url = false,
        bool need_only_count_ = false);

+    ~StorageURLSource() override;
+
    String getName() const override { return name; }

    void setKeyCondition(const ActionsDAGPtr & filter_actions_dag, ContextPtr context_) override