Merge branch 'clang-19-2' into underscore_digit_groups

src/AggregateFunctions/AggregateFunctionCount.cpp

@@ -5,6 +5,12 @@
 
 namespace DB
 {
+
+namespace ErrorCodes
+{
+    extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
+}
+
 struct Settings;
 
 AggregateFunctionPtr AggregateFunctionCount::getOwnNullAdapter(
@@ -19,7 +25,9 @@ namespace
 AggregateFunctionPtr createAggregateFunctionCount(const std::string & name, const DataTypes & argument_types, const Array & parameters, const Settings *)
 {
     assertNoParameters(name, parameters);
-    assertArityAtMost<1>(name, argument_types);
+
+    if (argument_types.size() > 1)
+        throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH, "Aggregate function {} requires zero or one argument", name);
 
     return std::make_shared<AggregateFunctionCount>(argument_types);
 }

src/AggregateFunctions/AggregateFunctionQuantile.cpp

@@ -14,6 +14,7 @@ struct Settings;
 
 namespace ErrorCodes
 {
+    extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
     extern const int ILLEGAL_TYPE_OF_ARGUMENT;
     extern const int NOT_IMPLEMENTED;
 }
@@ -116,8 +117,8 @@ 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);
+    if (argument_types.empty())
+        throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH, "Aggregate function {} requires at least one argument", name);
 
     const DataTypePtr & argument_type = argument_types[0];
     WhichDataType which(argument_type);

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"; };

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);
 

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);
 

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);
 

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);
 

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);
 

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);
 

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);

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);
 

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);
 

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);
 

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);
 

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);
 

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);
 

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);
 

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);
 

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);
 

src/AggregateFunctions/FactoryHelpers.h

@@ -33,21 +33,4 @@ inline void assertBinary(const std::string & name, const DataTypes & argument_ty
         throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH, "Aggregate function {} requires two arguments", name);
 }
 
-template<std::size_t maximal_arity>
-inline void assertArityAtMost(const std::string & name, const DataTypes & argument_types)
-{
-    if (argument_types.size() <= maximal_arity)
-        return;
-
-    if constexpr (maximal_arity == 0)
-        throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH, "Aggregate function {} cannot have arguments", name);
-
-    if constexpr (maximal_arity == 1)
-        throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH, "Aggregate function {} requires zero or one argument",
-                        name);
-
-    throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH, "Aggregate function {} requires at most {} arguments",
-                    name, maximal_arity);
-}
-
 }

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())

src/Interpreters/PreparedSets.h

@@ -108,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;

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");

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:

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;

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;

src/Storages/Kafka/StorageKafka.cpp

@@ -386,6 +386,8 @@ StorageKafka::StorageKafka(
     });
 }
 
+StorageKafka::~StorageKafka() = default;
+
 VirtualColumnsDescription StorageKafka::createVirtuals(StreamingHandleErrorMode handle_error_mode)
 {
     VirtualColumnsDescription desc;

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; }

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);

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(

src/Storages/StorageURL.cpp

@@ -387,6 +387,8 @@ StorageURLSource::StorageURLSource(
     };
 }
 
+StorageURLSource::~StorageURLSource() = default;
+
 Chunk StorageURLSource::generate()
 {
     while (true)

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