# CountIf

`CountIf` считает общее количество строк в таблице, которые соответствуют условию. `CountIf` считает каждую строку, а не только уникальные строки.

Синтаксис: `CountIf(условие)`.

Например: в таблице ниже `CountIf([Plan] = "Basic")` вернет 3.

| ID  | Plan        |
|-----|-------------|
| 1   | Basic       |
| 2   | Basic       |
| 3   | Basic       |
| 4   | Business    |
| 5   | Premium     |

> [Функции агрегации](../expressions-list.md#aggregations) вроде `CountIf` должны быть добавлены в [**Summarize** menu](../../query-builder/introduction.md#summarizing-and-grouping-by) > **Custom Expression** (прокрутите вниз в меню, если это необходимо).

## Параметры

`CountIf` принимает [функцию](../expressions-list.md#functions) или [условное выражение](../expressions.md#conditional-operators), которое возвращает логическое значение (`true` или `false`).

## Множественные условия

Мы будем использовать следующие примеры данных, чтобы показать вам `CountIf` с [обязательными](#required-conditions), [необязательными](#optional-conditions) и [смешанными](#some-required-and-some-optional-conditions) условиями.

| ID  | Plan        | Active Subscription |
|-----|-------------| --------------------|
| 1   | Basic       | true                |
| 2   | Basic       | true                |
| 3   | Basic       | false               |
| 4   | Business    | false               |
| 5   | Premium     | true                |

### Требуемые условия

Для подсчета общего количества строк в таблице, которые соответствуют нескольким обязательным условиям, объедините условия с помощью оператора `AND`:

```
CountIf(([Plan] = "Basic" AND [Active Subscription] = true))
```

Это выражение вернет 2 на приведенных выше примерах данных (общее количество базовых планов с активной подпиской).

### Опциональные условия

Для подсчета общего количества строк в таблице, которые соответствуют нескольким необязательным условиям, объедините условия с помощью оператора `OR`:

```
CountIf(([Plan] = "Basic" OR [Active Subscription] = true))
```

Возвращает 4 на примере данных: есть три базовых плана, плюс один премиум-план с активной подпиской.

### Некоторые обязательные и некоторые необязательные условия

Чтобы совместить обязательные и необязательные условия, сгруппируйте условия с помощью скобок:

```
CountIf(([Plan] = "Basic" OR [Plan] = "Business") AND [Active Subscription] = "false")
```

Возвращает 2 на примере данных: есть только два базовых или бизнес-плана, которые не имеют активной подписки.

> Подсказка: сделайте это привычкой, чтобы помещать скобки вокруг ваших групп `AND` и `OR`, чтобы избежать ситуации, когда обязательные условия становятся необязательными (или наоборот).

## Условные подсчеты по группам

В общем случае, чтобы получить условный подсчет для категории или группы, например, количество неактивных подписок на план, вам нужно:

1. Написать `CountIf` выражение с вашими условиями.
2Добавьте столбец [**Group by**](../../query-builder/introduction.md#summarizing-and-grouping-by) в конструктор запросов.

На примере следующих данных:

| ID  | Plan        | Active Subscription |
|-----|-------------| --------------------|
| 1   | Basic       | true                |
| 2   | Basic       | true                |
| 3   | Basic       | false               |
| 4   | Business    | false               |
| 5   | Premium     | true                |

Подсчет общего количества неактивных подписок по плану:

```
CountIf([Active Subscription] = false)
```

Как альтернативный вариант если ваш столбец **Active Subscription** содержит `null` (пустые) значения, которые представляют неактивные планы, вы можете использовать:

```
CountIf([Payment], [Plan] != true)
```

> The "not equal" operator `!=` should be written as !=.
> Оператор "не равно" `!=` должен быть записан как !=.

Чтобы просмотреть ваши условные подсчеты по плану, установите столбец **Group by** на "Plan".

| Plan      | Total Inactive Subscriptions |
|-----------|------------------------------|
| Basic     | 1                            |
| Business  | 1                            |
| Premium   | 0                            |

> Подсказка: при совместной работе с другими людьми полезно использовать фильтр `OR`, даже если фильтр `!=` короче. Включающий фильтр `OR` облегчает понимание того, какие категории (например, планы) включены в ваш условный подсчет.

## Поддерживаемые типы данных

| [Типы данных](https://www.metabase.com/learn/databases/data-types-overview#examples-of-data-types) | Работают с `CountIf` |
|---------------------------------------------------------------------------------------------------|----------------------|
| String                                                                                            | ❌                    |
| Number                                                                                            | ❌                    |
| Timestamp                                                                                         | ❌                    |
| Boolean                                                                                           | ✅                    |
| JSON                                                                                              | ❌                    |


`CountIf`  принимает [функцию](../expressions-list.md#functions) или [условное выражение](../expressions.md#conditional-operators), которое возвращает логическое значение (`true` или `false`).

## Связанные функции


**GlarusBI**
- [case](#case)
- [CumulativeCount](#cumulativecount)

**Другие инструменты**
- [SQL](#sql)
- [Spreadsheets](#spreadsheets)
- [Python](#python)

### case

Вы можете объединить [`Count`](../expressions-list.md#count) с [`case`](./case.md):

```
Count(case([Plan] = "Basic", [ID]))
```

чтобы сделать тоже самое, что и `CountIf`:

```
CountIf([Plan] = "Basic")
```

Версия `case` позволяет вам считать другой столбец, когда условие не выполняется. Например, если у вас есть данные из разных источников:

| ID: Source A  | Plan: Source A | ID: Source B  | Plan: Source B       |
|---------------|----------------|---------------| ---------------------|
| 1             | Basic          |               |                      |
|               |                | B             | basic                |
|               |                | C             | basic                |
| 4             | Business       | D             | business             |
| 5             | Premium        | E             | premium              |

Для подсчета общего количества базовых планов в обоих источниках вы можете создать выражение `case`:

- Посчитать все строки в "ID: Source A" где "Plan: Source A = "Basic"
- Посчитать все строки в "ID: Source B" где "Plan: Source B = "basic"

```
Count(case([Plan: Source A] = "Basic", [ID: Source A],
            case([Plan: Source B] = "basic", [ID: Source B])))
```

### CumulativeCount

`CountIf` не делает накопительные подсчеты. Вам нужно объединить [CumulativeCount](../expressions-list.md#cumulativecount) с [`case`](./case.md).

В нашем примере данных есть временной ряд:

| ID  | Plan        | Активная подписка | Дата создания             |
|-----|-------------|-------------------|----------------------------|
| 1   | Basic       | true              | October 1, 2020            |
| 2   | Basic       | true              | October 1, 2020            |
| 3   | Basic       | false             | October 1, 2020            |
| 4   | Business    | false             | November 1, 2020           |
| 5   | Premium     | true              | November 1, 2020           |

И, допустим, мы хотим получить накопительный подсчет активных планов, как показано ниже:

| Месяц создания | Общее количество активных планов на дату                            |
|----------------|---------------------------------------------------------------------|
| October 2020   | 2                                                                   |
| November 2020  | 3                                                                   |

Создайте агрегацию из **Summarize** > **Custom expression**:

```
CumulativeCount(case([Active Subscription] = true, [ID]))
```

Вам также нужно установить столбец **Group by** на "Дата создания: месяц".

### SQL

Когда вы выполняете запрос с помощью [конструктора запросов](https://www.metabase.com/glossary/query_builder), GlarusBI преобразует ваши настройки конструктора запросов (фильтры, сводки и т. д.) в SQL-запрос и запускает этот запрос в вашей базе данных для получения результатов.

В нашем [примере](#multiple-conditions) данные хранятся в базе данных PostgreSQL, SQL-запрос:

```sql

```sql
SELECT COUNT(CASE WHEN plan = "Basic" THEN id END) AS total_basic_plans
FROM accounts
```

является эквивалентом выражения GlarusBI:

```
CountIf([Plan] = "Basic")
```

Если вы хотите получить [условные подсчеты, разбитые по группам](#conditional-counts-by-group), SQL-запрос:

```sql
SELECT
    plan,
    COUNT(CASE WHEN active_subscription = false THEN id END) AS total_inactive_subscriptions
FROM accounts
GROUP BY
    plan
```

Часть `SELECT` SQL-запроса соответствует выражению GlarusBI:

```
CountIf([Active Subscription] = false)
```

Часть `GROUP BY` SQL-запроса соответствует GlarusBI [**Group by**](../../query-builder/introduction.md#summarizing-and-grouping-by) установленному на столбец "План".

### Электронные таблицы

If our [sample data](#multiple-conditions) is in a spreadsheet where "ID" is in column A, the spreadsheet formula:
В нашем [примере](#multiple-conditions) данные хранятся в электронной таблице, где "ID" находится в столбце A, формула электронной таблицы:

```
=CountIf(B:B, "Basic")
```

производит тот же результат, что и выражение GlarusBI:

```
CountIf([Plan] = "Basic")
```

### Python

If our [sample data](#multiple-conditions) is in a `pandas` dataframe column called `df`, the Python code:
В нашем [примере](#multiple-conditions) данные хранятся в столбце `pandas` `df`, код Python:

```python
len(df[df['Plan'] == "Basic"])
```

использует ту же логику, что и выражение GlarusBI:

```
CountIf([Plan] = "Basic")
```

Чтобы получить [условный подсчет с группирующим столбцом](#conditional-counts-by-group):

```python
## Добавьте свои условия

    df_filtered = df[df['Active subscription'] == false]

## Группируйте по столбцу и подсчитывайте строки в каждой группе

    len(df_filtered.groupby('Plan'))
```

Код Python выше будет производить тот же результат, что и выражение GlarusBI `CountIf` (с установленным столбцом [**Group by**](../../query-builder/introduction.md#summarizing-and-grouping-by) на "План").

```
CountIf([Active Subscription] = false)
```

## Дополнительная информация

- [Документация по кастомным выражениям](../expressions.md)
- [Руководство по кастомным выражениям. Документация Metabase](https://www.metabase.com/learn/questions/custom-expressions)