text: // Copyright 2022 PingCAP, Ltd.
  //
  // Licensed under the Apache License, Version 2.0 (the "License");
  // you may not use this file except in compliance with the License.
  // You may obtain a copy of the License at
  //
  //     http://www.apache.org/licenses/LICENSE-2.0
  //
  // Unless required by applicable law or agreed to in writing, software
  // distributed under the License is distributed on an "AS IS" BASIS,
  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  // See the License for the specific language governing permissions and
  // limitations under the License.
  
  #include <AggregateFunctions/AggregateFunctionCombinatorFactory.h>
  #include <AggregateFunctions/AggregateFunctionFactory.h>
  #include <AggregateFunctions/registerAggregateFunctions.h>
  
  
  namespace DB
  {
  void registerAggregateFunctionAvg(AggregateFunctionFactory &);
  void registerAggregateFunctionCount(AggregateFunctionFactory &);
  void registerAggregateFunctionGroupArray(AggregateFunctionFactory &);
  void registerAggregateFunctionGroupUniqArray(AggregateFunctionFactory &);
  void registerAggregateFunctionGroupArrayInsertAt(AggregateFunctionFactory &);
  void registerAggregateFunctionsQuantile(AggregateFunctionFactory &);
  void registerAggregateFunctionsSequenceMatch(AggregateFunctionFactory &);
  void registerAggregateFunctionsMinMaxAny(AggregateFunctionFactory &);
  void registerAggregateFunctionsStatisticsStable(AggregateFunctionFactory &);
  void registerAggregateFunctionsStatisticsSimple(AggregateFunctionFactory &);
  void registerAggregateFunctionSum(AggregateFunctionFactory &);
  void registerAggregateFunctionSumMap(AggregateFunctionFactory &);
  void registerAggregateFunctionsUniq(AggregateFunctionFactory &);
  void registerAggregateFunctionUniqUpTo(AggregateFunctionFactory &);
  void registerAggregateFunctionTopK(AggregateFunctionFactory &);
  void registerAggregateFunctionsBitwise(AggregateFunctionFactory &);
  void registerAggregateFunctionsMaxIntersections(AggregateFunctionFactory &);
  
  void registerAggregateFunctionCombinatorIf(AggregateFunctionCombinatorFactory &);
  void registerAggregateFunctionCombinatorArray(AggregateFunctionCombinatorFactory &);
  void registerAggregateFunctionCombinatorForEach(AggregateFunctionCombinatorFactory &);
  void registerAggregateFunctionCombinatorState(AggregateFunctionCombinatorFactory &);
  void registerAggregateFunctionCombinatorMerge(AggregateFunctionCombinatorFactory &);
  void registerAggregateFunctionCombinatorNull(AggregateFunctionCombinatorFactory &);
  
  
  void registerAggregateFunctions()
  {
      {
          auto & factory = AggregateFunctionFactory::instance();
  
          registerAggregateFunctionAvg(factory);
          registerAggregateFunctionCount(factory);
          registerAggregateFunctionGroupArray(factory);
          registerAggregateFunctionGroupUniqArray(factory);
          registerAggregateFunctionGroupArrayInsertAt(factory);
          registerAggregateFunctionsQuantile(factory);
          registerAggregateFunctionsSequenceMatch(factory);
          registerAggregateFunctionsMinMaxAny(factory);
          registerAggregateFunctionsStatisticsStable(factory);
          registerAggregateFunctionsStatisticsSimple(factory);
          registerAggregateFunctionSum(factory);
          registerAggregateFunctionSumMap(factory);
          registerAggregateFunctionsUniq(factory);
          registerAggregateFunctionUniqUpTo(factory);
          registerAggregateFunctionTopK(factory);
          registerAggregateFunctionsBitwise(factory);
          registerAggregateFunctionsMaxIntersections(factory);
      }
  
      {
          auto & factory = AggregateFunctionCombinatorFactory::instance();
  
          registerAggregateFunctionCombinatorIf(factory);
          registerAggregateFunctionCombinatorArray(factory);
          registerAggregateFunctionCombinatorForEach(factory);
          registerAggregateFunctionCombinatorState(factory);
          registerAggregateFunctionCombinatorMerge(factory);
          registerAggregateFunctionCombinatorNull(factory);
      }
  }
  
  } // namespace DB
  