Что такое агрегирующая функция?

Что такое агрегирующая функция

Агрегирующая функция (aggregate function) — это функция, которая обрабатывает множество строк из таблицы и возвращает одно единственное значение. Это фундаментальная концепция в SQL и обработке данных, которую разработчик Java должен хорошо понимать при работе с базами данных.

Определение и основная идея

Агрегирующая функция берёт набор значений из одного или нескольких столбцов и выполняет вычисление, возвращая результат — обычно число или значение. Эти функции используются для:

• Подсчёта элементов
• Вычисления сумм
• Поиска максимальных и минимальных значений
• Вычисления средних значений
• Конкатенации строк

Основные агрегирующие функции SQL

// Примеры SQL запросов с агрегирующими функциями

// COUNT — подсчёт количества строк
// SELECT COUNT(*) FROM users; // общее количество пользователей
// SELECT COUNT(email) FROM users; // количество не-NULL значений в email

// SUM — сумма значений
// SELECT SUM(salary) FROM employees; // общая зарплата всех сотрудников
// SELECT SUM(amount) FROM orders WHERE status='completed'; // сумма выполненных заказов

// AVG — среднее значение
// SELECT AVG(salary) FROM employees; // средняя зарплата
// SELECT AVG(rating) FROM products; // средний рейтинг товаров

// MIN и MAX — минимальное и максимальное значение
// SELECT MIN(price), MAX(price) FROM products; // диапазон цен
// SELECT MIN(created_at), MAX(created_at) FROM posts; // период публикаций

// STRING_AGG или GROUP_CONCAT — конкатенация строк
// SELECT STRING_AGG(name, ', ') FROM users; // список имён через запятую

Использование в Java с помощью Stream API

Java предоставляет удобные методы для работы с агрегирующими функциями через Stream API:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

// count() — количество элементов
long count = numbers.stream().count(); // 10

// sum() — сумма элементов
int sum = numbers.stream()
    .mapToInt(Integer::intValue)
    .sum(); // 55

// average() — среднее значение
OptionalDouble average = numbers.stream()
    .mapToInt(Integer::intValue)
    .average(); // 5.5

// min() и max() — минимум и максимум
OptionalInt min = numbers.stream()
    .mapToInt(Integer::intValue)
    .min(); // 1

OptionalInt max = numbers.stream()
    .mapToInt(Integer::intValue)
    .max(); // 10

// Сбор в единое значение
int resultSum = numbers.stream()
    .reduce(0, Integer::sum); // 55

Optional<Integer> product = numbers.stream()
    .reduce((a, b) -> a * b); // 3628800

Практический пример с объектами

public class Employee {
    private String name;
    private BigDecimal salary;
    private String department;
    private LocalDate hireDate;
    
    // конструктор, getters, setters
}

List<Employee> employees = Arrays.asList(
    new Employee("Alice", new BigDecimal("50000"), "IT", LocalDate.of(2020, 1, 15)),
    new Employee("Bob", new BigDecimal("60000"), "IT", LocalDate.of(2019, 3, 20)),
    new Employee("Charlie", new BigDecimal("45000"), "HR", LocalDate.of(2021, 6, 10)),
    new Employee("Diana", new BigDecimal("55000"), "HR", LocalDate.of(2020, 9, 5))
);

// 1. COUNT — количество сотрудников
long totalEmployees = employees.stream().count(); // 4

// 2. SUM — общая зарплата
BigDecimal totalSalary = employees.stream()
    .map(Employee::getSalary)
    .reduce(BigDecimal.ZERO, BigDecimal::add); // 210000

// 3. AVG — средняя зарплата
BigDecimal avgSalary = employees.stream()
    .map(Employee::getSalary)
    .reduce(BigDecimal.ZERO, BigDecimal::add)
    .divide(new BigDecimal(employees.size()), 2, RoundingMode.HALF_UP); // 52500

// 4. MIN и MAX
Optional<BigDecimal> minSalary = employees.stream()
    .map(Employee::getSalary)
    .min(BigDecimal::compareTo); // 45000

Optional<BigDecimal> maxSalary = employees.stream()
    .map(Employee::getSalary)
    .max(BigDecimal::compareTo); // 60000

// 5. Агрегирование по группам (GROUP BY эквивалент)
Map<String, Long> countByDepartment = employees.stream()
    .collect(Collectors.groupingBy(
        Employee::getDepartment,
        Collectors.counting()
    ));
// {IT=2, HR=2}

Map<String, BigDecimal> totalSalaryByDepartment = employees.stream()
    .collect(Collectors.groupingBy(
        Employee::getDepartment,
        Collectors.reducing(
            BigDecimal.ZERO,
            Employee::getSalary,
            BigDecimal::add
        )
    ));
// {IT=110000, HR=100000}

GROUP BY и HAVING с агрегирующими функциями

В SQL часто используется GROUP BY для группировки данных перед агрегированием:

// SQL эквивалент:
// SELECT department, COUNT(*) as count, AVG(salary) as avg_salary
// FROM employees
// GROUP BY department
// HAVING COUNT(*) > 1
// ORDER BY avg_salary DESC

var departmentStats = employees.stream()
    .collect(Collectors.groupingBy(
        Employee::getDepartment,
        Collectors.collectingAndThen(
            Collectors.toList(),
            list -> Map.of(
                "count", (long) list.size(),
                "avgSalary", list.stream()
                    .map(Employee::getSalary)
                    .reduce(BigDecimal.ZERO, BigDecimal::add)
                    .divide(new BigDecimal(list.size()), 2, RoundingMode.HALF_UP)
            )
        )
    ))
    .entrySet().stream()
    .filter(e -> ((Long) e.getValue().get("count")) > 1)
    .sorted((a, b) -> ((BigDecimal) b.getValue().get("avgSalary"))
        .compareTo((BigDecimal) a.getValue().get("avgSalary")))
    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

Агрегирующие функции в JPA/Hibernate

При использовании Spring Data JPA можно писать запросы с агрегирующими функциями:

public interface EmployeeRepository extends JpaRepository<Employee, Long> {
    
    // Количество сотрудников в отделе
    @Query("SELECT COUNT(e) FROM Employee e WHERE e.department = ?1")
    long countByDepartment(String department);
    
    // Средняя зарплата по отделу
    @Query("SELECT AVG(e.salary) FROM Employee e WHERE e.department = ?1")
    BigDecimal averageSalaryByDepartment(String department);
    
    // Максимальная зарплата
    @Query("SELECT MAX(e.salary) FROM Employee e")
    BigDecimal maxSalary();
    
    // Сложный запрос с GROUP BY
    @Query("SELECT new map(e.department as department, " +
           "COUNT(e) as count, " +
           "AVG(e.salary) as avgSalary) " +
           "FROM Employee e " +
           "GROUP BY e.department")
    List<Map<String, Object>> departmentStats();
}

Важные моменты

1. NULL значения — агрегирующие функции обычно игнорируют NULL (кроме COUNT(*))

List<Integer> numbersWithNull = Arrays.asList(1, 2, null, 4, 5);
int sum = numbersWithNull.stream()
    .filter(Objects::nonNull)
    .mapToInt(Integer::intValue)
    .sum(); // 12 (null игнорируется)

1. GROUP BY — часто используется для группировки перед агрегированием

2. HAVING — используется для фильтрации результатов после агрегирования

3. Производительность — агрегирующие функции обычно выполняются на уровне БД, что эффективнее, чем агрегирование в памяти

Заключение

Агрегирующие функции — это мощный инструмент для анализа и обобщения данных. Они критически важны при разработке приложений, которые работают с большими объёмами данных. Понимание того, как они работают как в SQL, так и в Java Stream API, позволяет разработчику писать эффективный и понятный код для обработки данных.