{
  "skill_name": "composing-1c-queries",
  "evals": [
    {
      "id": "accumulation-balances",
      "prompt": "Составь запрос для получения остатков товаров на складах из регистра накопления ТоварыНаСкладах (виртуальная таблица Остатки). Нужны поля Номенклатура, Склад и остаток количества. Фильтр по параметру &Дата.",
      "expected_output": "Корректный запрос к виртуальной таблице РегистрНакопления.ТоварыНаСкладах.Остатки с параметром даты, полями с псевдонимами КАК, информативными псевдонимами таблиц.",
      "expectations": [
        "Запрос использует ключевое слово ВЫБРАТЬ и ИЗ",
        "Виртуальная таблица вызвана с параметром даты: .Остатки(&Дата",
        "Каждое поле имеет псевдоним через КАК",
        "Псевдоним таблицы информативный (не однобуквенный)",
        "Параметры используют префикс & (например &Дата)",
        "Запрос не содержит конкатенацию строк в тексте запроса"
      ],
      "expect": [
        "ВЫБРАТЬ",
        "РегистрНакопления\\.ТоварыНаСкладах\\.Остатки",
        "\\bКАК\\b"
      ],
      "forbid": [
        "\\bSELECT\\b",
        "\\bFROM\\b"
      ],
      "should_activate": true
    },
    {
      "id": "documents-by-period",
      "prompt": "Напиши запрос для поиска всех проведённых документов ПоступлениеТоваровУслуг за период с &НачДата по &КонДата, у которых контрагент равен &Контрагент. Нужны: ссылка на документ, дата, номер, сумма документа.",
      "expected_output": "Запрос к таблице Документ.ПоступлениеТоваровУслуг с условием по дате, контрагенту и признаку проведения, с псевдонимами полей.",
      "expectations": [
        "Запрос обращается к таблице Документ.ПоступлениеТоваровУслуг",
        "Условие ГДЕ включает фильтр по периоду через &НачДата и &КонДата",
        "Условие ГДЕ включает фильтр по &Контрагент",
        "Присутствует условие на проведённость (Проведён = ИСТИНА или аналог)",
        "Поля Ссылка, Дата, Номер имеют псевдонимы через КАК"
      ],
      "expect": [
        "ВЫБРАТЬ",
        "Документ\\.ПоступлениеТоваровУслуг",
        "&НачДата",
        "&КонДата",
        "Проведен"
      ],
      "forbid": [
        "\\bSELECT\\b",
        "\\bWHERE\\b"
      ],
      "should_activate": true
    },
    {
      "id": "temp-table-join",
      "prompt": "Составь запрос с временными таблицами: сначала отобрать номенклатуру из справочника Номенклатура где пометка удаления = Ложь, затем соединить с остатками из РегистрНакопления.ТоварыНаСкладах.Остатки. Итоговый запрос должен вернуть Номенклатура, Наименование, КоличествоОстаток.",
      "expected_output": "Пакетный запрос: первый запрос создаёт временную таблицу с ПОМЕСТИТЬ, индексирует её, второй запрос соединяет с виртуальной таблицей остатков. Промежуточная переменная для результата запроса.",
      "expectations": [
        "Первый запрос использует ПОМЕСТИТЬ для создания временной таблицы",
        "Временная таблица имеет ИНДЕКСИРОВАТЬ ПО для поля соединения",
        "Второй запрос использует ЛЕВОЕ СОЕДИНЕНИЕ или ВНУТРЕННЕЕ СОЕДИНЕНИЕ с временной таблицей",
        "Запросы разделены точкой с запятой (;)",
        "Условие на пометку удаления присутствует в первом запросе",
        "Все поля имеют псевдонимы через КАК"
      ],
      "expect": [
        "ПОМЕСТИТЬ",
        "Справочник\\.Номенклатура",
        "СОЕДИНЕНИЕ|ПО\\s"
      ],
      "forbid": [
        "\\bSELECT\\b",
        "\\bJOIN\\b"
      ],
      "should_activate": true
    }
  ]
}

# Functions and Expressions

Complete reference of functions and expression syntax available in 1C query language.

## Contents

- [Type casting (ВЫРАЗИТЬ)](#type-casting-выразить)
- [Aggregate functions](#aggregate-functions)
- [Date and time functions](#date-and-time-functions)
- [String functions](#string-functions)
- [Type functions](#type-functions)
- [Logical and NULL functions](#logical-and-null-functions)
- [Math functions](#math-functions)
- [Trigonometric functions](#trigonometric-functions)
- [Special functions](#special-functions)
- [Arithmetic operators](#arithmetic-operators)
- [Constants and literals](#constants-and-literals)

---

## Type Casting (ВЫРАЗИТЬ)

Explicitly converts a value to a specific type. **Essential for compound-type fields.**

```
ВЫРАЗИТЬ(<expression> КАК <type>)
```

Examples:
```
// Narrow compound reference to specific type:
ВЫРАЗИТЬ(Регистратор КАК Документ.РеализацияТоваровУслуг)

// Cast number to specific precision:
ВЫРАЗИТЬ(Сумма КАК ЧИСЛО(15, 2))

// Cast to string:
ВЫРАЗИТЬ(Код КАК СТРОКА(10))

// Cast to boolean:
ВЫРАЗИТЬ(Значение КАК БУЛЕВО)

// Cast to date:
ВЫРАЗИТЬ(Значение КАК ДАТА)
```

Primitive types for casting: `ЧИСЛО(<length>, <precision>)`, `СТРОКА(<length>)`, `БУЛЕВО`, `ДАТА`.

---

## Aggregate Functions

Used with `СГРУППИРОВАТЬ ПО`, `ИМЕЮЩИЕ`, `ИТОГИ`, and `УПОРЯДОЧИТЬ ПО`.

| Function | Description | Example |
|----------|-------------|---------|
| `СУММА(<field>)` | Sum | `СУММА(Количество)` |
| `СРЕДНЕЕ(<field>)` | Average | `СРЕДНЕЕ(Цена)` |
| `МИНИМУМ(<field>)` | Minimum value | `МИНИМУМ(Дата)` |
| `МАКСИМУМ(<field>)` | Maximum value | `МАКСИМУМ(Дата)` |
| `КОЛИЧЕСТВО(*)` | Count all rows | `КОЛИЧЕСТВО(*)` |
| `КОЛИЧЕСТВО(<field>)` | Count non-NULL values | `КОЛИЧЕСТВО(Контрагент)` |
| `КОЛИЧЕСТВО(РАЗЛИЧНЫЕ <field>)` | Count distinct values | `КОЛИЧЕСТВО(РАЗЛИЧНЫЕ Контрагент)` |

**Rule:** Do not use grouping fields inside aggregate functions (except nested table fields).

---

## Date and Time Functions

### Component extraction

| Function | Returns | Example |
|----------|---------|---------|
| `ГОД(<date>)` | Year | `ГОД(Дата)` → 2024 |
| `КВАРТАЛ(<date>)` | Quarter (1-4) | `КВАРТАЛ(Дата)` → 1 |
| `МЕСЯЦ(<date>)` | Month (1-12) | `МЕСЯЦ(Дата)` → 3 |
| `ДЕНЬГОДА(<date>)` | Day of year (1-366) | `ДЕНЬГОДА(Дата)` |
| `ДЕНЬ(<date>)` | Day of month (1-31) | `ДЕНЬ(Дата)` → 15 |
| `ДЕНЬНЕДЕЛИ(<date>)` | Day of week (1=Mon..7=Sun) | `ДЕНЬНЕДЕЛИ(Дата)` |
| `ЧАС(<date>)` | Hour (0-23) | `ЧАС(Дата)` |
| `МИНУТА(<date>)` | Minute (0-59) | `МИНУТА(Дата)` |
| `СЕКУНДА(<date>)` | Second (0-59) | `СЕКУНДА(Дата)` |

### Period boundaries

| Function | Description |
|----------|-------------|
| `НАЧАЛОПЕРИОДА(<date>, <period>)` | Start of period. `<period>`: МИНУТА, ЧАС, ДЕНЬ, НЕДЕЛЯ, МЕСЯЦ, КВАРТАЛ, ГОД, ДЕКАДА, ПОЛУГОДИЕ |
| `КОНЕЦПЕРИОДА(<date>, <period>)` | End of period (same period options) |

```
НАЧАЛОПЕРИОДА(Дата, МЕСЯЦ)    // first day of month
КОНЕЦПЕРИОДА(Дата, КВАРТАЛ)    // last moment of quarter
```

### Date arithmetic

| Function | Description |
|----------|-------------|
| `ДОБАВИТЬКДАТЕ(<date>, <period>, <count>)` | Add N periods to date |
| `РАЗНОСТЬДАТ(<date1>, <date2>, <period>)` | Difference between dates in periods |

```
ДОБАВИТЬКДАТЕ(Дата, МЕСЯЦ, 3)         // add 3 months
ДОБАВИТЬКДАТЕ(Дата, ДЕНЬ, -7)          // subtract 7 days
РАЗНОСТЬДАТ(ДатаНач, ДатаКон, ДЕНЬ)   // days between dates
```

Period options: `СЕКУНДА`, `МИНУТА`, `ЧАС`, `ДЕНЬ`, `МЕСЯЦ`, `КВАРТАЛ`, `ГОД`.

---

## String Functions

| Function | Description | Example |
|----------|-------------|---------|
| `ПОДСТРОКА(<str>, <start>, <length>)` | Substring (1-based) | `ПОДСТРОКА(Код, 1, 3)` |
| `ДЛИНАСТРОКИ(<str>)` | String length | `ДЛИНАСТРОКИ(Наименование)` |
| `ЛЕВ(<str>, <n>)` | Left N characters | `ЛЕВ(Код, 5)` |
| `ПРАВ(<str>, <n>)` | Right N characters | `ПРАВ(Код, 3)` |
| `СТРЗАМЕНИТЬ(<str>, <find>, <replace>)` | Replace substring | `СТРЗАМЕНИТЬ(Имя, " ", "_")` |
| `СОКРЛ(<str>)` | Trim leading spaces | `СОКРЛ(Код)` |
| `СОКРП(<str>)` | Trim trailing spaces | `СОКРП(Код)` |
| `СОКРЛП(<str>)` | Trim both sides | `СОКРЛП(Код)` |
| `ВРЕГ(<str>)` | Uppercase | `ВРЕГ(Наименование)` |
| `НРЕГ(<str>)` | Lowercase | `НРЕГ(Наименование)` |

**Note:** `ПОДСТРОКА` in WHERE main condition prevents index usage. Use only in additional conditions.

---

## Type Functions

| Function | Description | Example |
|----------|-------------|---------|
| `ТИПЗНАЧЕНИЯ(<expr>)` | Returns the type of a value | `ТИПЗНАЧЕНИЯ(Ссылка)` |
| `ТИП(<type_name>)` | Returns a type object for comparison | `ТИП("Справочник.Контрагенты")` |
| `ССЫЛКА` | Type check operator for references | `Рег ССЫЛКА Документ.Реализация` |
| `ПРЕДСТАВЛЕНИЕ(<expr>)` | Human-readable string of a reference | `ПРЕДСТАВЛЕНИЕ(Контрагент)` |
| `УНИКАЛЬНЫЙИДЕНТИФИКАТОР(<ref>)` | UUID of a reference as string | `УНИКАЛЬНЫЙИДЕНТИФИКАТОР(Ссылка)` |

```
// Filter by value type:
ГДЕ ТИПЗНАЧЕНИЯ(Субконто1) = ТИП("Справочник.Контрагенты")
```

---

## Logical and NULL Functions

| Function | Description |
|----------|-------------|
| `ЕСТЬNULL(<expr>, <default>)` | Returns `<default>` if `<expr>` is NULL (like SQL COALESCE for two args) |

```
ЕСТЬNULL(Ост.КоличествоОстаток, 0)
```

**ВЫБОР (CASE):** See [query-syntax-reference.md](query-syntax-reference.md#выбор-case).

---

## Math Functions

| Function | Description |
|----------|-------------|
| `ОКР(<number>, <precision>)` | Round to N decimal places |
| `ЦЕЛ(<number>)` | Truncate to integer (floor toward zero) |

```
ОКР(Сумма / Количество, 2)   // round to 2 decimals
ЦЕЛ(Сумма / 100)             // integer part
```

**Arithmetic precision:** At least 8 decimal places. Results may vary slightly across DBMS.

---

## Trigonometric Functions

Standard math functions - same semantics as in most languages.

| Function | Description |
|----------|-------------|
| `SIN(<x>)` | Sine (radians) |
| `COS(<x>)` | Cosine |
| `TAN(<x>)` | Tangent |
| `ASIN(<x>)` | Arcsine |
| `ACOS(<x>)` | Arccosine |
| `ATAN(<x>)` | Arctangent |

---

## Special Functions

| Function | Description |
|----------|-------------|
| `EXP(<x>)` | e^x |
| `LOG(<x>)` | Natural logarithm |
| `LOG10(<x>)` | Base-10 logarithm |
| `POW(<base>, <exp>)` | Power |
| `SQRT(<x>)` | Square root |
| `АВТОНОМЕРЗАПИСИ()` | Auto row number in result |
| `РАЗМЕРХРАНИМЫХДАННЫХ(<field>)` | Storage size of a field in bytes |
| `СГРУППИРОВАНОПО(<field>)` | TRUE if current row was grouped by this field (for grouping sets) |

---

## Arithmetic Operators

`+`, `-`, `*`, `/` - standard arithmetic. Precision: at least 8 decimal places.

**In WHERE:** Only use in additional conditions (prevents index use in main condition).

---

## Constants and Literals

| Type | Syntax | Example |
|------|--------|---------|
| Boolean | `ИСТИНА` / `ЛОЖЬ` | `ГДЕ Проведен = ИСТИНА` |
| Number | Decimal literal | `1000`, `3.14` |
| String | Double quotes | `"Текст"` |
| String with quotes | Escape `"` by doubling | `"Компания ""Рога и Копыта"""` |
| Date | `ДАТАВРЕМЯ(<Y>, <M>, <D> [, <H>, <Min>, <S>])` | `ДАТАВРЕМЯ(2024, 1, 15)` |
| NULL | `NULL` | `ЕСТЬNULL(X, 0)` |
| Undefined | `НЕОПРЕДЕЛЕНО` | |
| Enum/predefined | `ЗНАЧЕНИЕ(...)` | `ЗНАЧЕНИЕ(Перечисление.Типы.Оптовая)` |
| Empty reference | `ЗНАЧЕНИЕ(Справочник.X.ПустаяСсылка)` | |

**Parameters:** `&Name` - external values passed to query. Always prefer parameters over string concatenation.

# Optimization and Caveats

1C-specific query optimization rules. These differ from generic SQL and are critical for production performance.

## Contents

- [Index-aware filtering (main vs additional conditions)](#index-aware-filtering)
- [ИЛИ (OR) performance trap](#или-or-performance-trap)
- [Compound-type dereferencing](#compound-type-dereferencing)
- [Virtual table parameters](#virtual-table-parameters)
- [Accounting register virtual table specifics](#accounting-register-virtual-table-specifics)
- [Nested joins prohibition](#nested-joins-prohibition)
- [Temporary table best practices](#temporary-table-best-practices)
- [RLS impact](#rls-impact)
- [Subquery restrictions](#subquery-restrictions)
- [DBMS portability](#dbms-portability)

---

## Index-Aware Filtering

1C query optimizer splits WHERE conditions into two categories:

### Main condition (основное условие)
- **Used for index lookup** - determines which index range to scan
- Must be the most restrictive part of the filter
- Allowed operators: `=`, `>`, `<`, `>=`, `<=`, `ПОДОБНО`, `МЕЖДУ`, `В`
- Combined with other main conditions using `И` only
- **Forbidden in main condition:** `ИЛИ`, `ВЫБОР`, arithmetic expressions, function calls (like `ПОДСТРОКА`), `НЕ`

### Additional condition (дополнительное условие)
- Applied **after** index scan - filters rows one by one
- Can use any operators, `ИЛИ`, `ВЫБОР`, arithmetic, functions
- Combined with the main condition using `И`

### Strategy
Structure your WHERE as: `<main_condition> И <additional_condition>`

```
// Main: indexed field with =
// Additional: complex logic
ГДЕ Организация = &Орг                              // main (indexed)
    И (Сумма > 1000 ИЛИ ПометкаУдаления = ИСТИНА)   // additional
```

If a query is slow, check if conditions prevent index use. Fix by:
1. Using `ВЫРАЗИТЬ` to narrow compound types
2. Moving complex logic to additional condition
3. Rewriting with temporary tables

---

## ИЛИ (OR) Performance Trap

`ИЛИ` in the main condition **prevents index use** on all fields involved.

**Allowed only when:**
- Applied to the **last or only** field of an index
- AND can be replaced with `В (...)`:

```
// BAD - breaks index on both Контрагент and Организация:
ГДЕ Контрагент = &К1 ИЛИ Организация = &Орг

// GOOD - use В instead:
ГДЕ Контрагент В (&К1, &К2, &К3)

// GOOD - split into UNION ALL:
ВЫБРАТЬ ... ГДЕ Контрагент = &К1
ОБЪЕДИНИТЬ ВСЕ
ВЫБРАТЬ ... ГДЕ Организация = &Орг
```

When replacing `ИЛИ` with `ОБЪЕДИНИТЬ ВСЕ`, verify that the result is equivalent (no missing/duplicate rows).

---

## Compound-Type Dereferencing

When a field has a composite reference type (can point to multiple tables), accessing sub-fields through dots creates implicit JOINs to **every** possible target table.

**Impact:**
- Query complexity explodes (many extra joins)
- Performance degrades severely, especially with RLS
- Behavior varies across DBMS

**Solutions:**

1. **ВЫРАЗИТЬ (CAST):** Narrow to specific type before dereferencing:
   ```
   ВЫРАЗИТЬ(Регистратор КАК Документ.Реализация).Номер
   ```

2. **ССЫЛКА + ВЫБОР:** Handle multiple types explicitly:
   ```
   ВЫБОР
       КОГДА Рег ССЫЛКА Документ.Реализация
           ТОГДА ВЫРАЗИТЬ(Рег КАК Документ.Реализация).Контрагент
       КОГДА Рег ССЫЛКА Документ.Поступление
           ТОГДА ВЫРАЗИТЬ(Рег КАК Документ.Поступление).Контрагент
   КОНЕЦ
   ```

3. **Temporary tables:** Pre-filter by type, then join:
   ```
   ВЫБРАТЬ Регистратор КАК Док ПОМЕСТИТЬ ВТ_Реализации
   ИЗ РегистрНакопления.Товары
   ГДЕ Регистратор ССЫЛКА Документ.Реализация;

   ВЫБРАТЬ ВЫРАЗИТЬ(ВТ.Док КАК Документ.Реализация).Контрагент
   ИЗ ВТ_Реализации КАК ВТ
   ```

4. **Denormalization:** For frequently accessed related data, add a dedicated field to the source table (configuration-level change).

---

## Virtual Table Parameters

Virtual tables (Остатки, Обороты, СрезПоследних, etc.) accept parameters that act as **pre-filters** at the storage engine level.

**CRITICAL: Always pass conditions into virtual table parameters, NOT into WHERE.**

```
// BAD - full table scan, then filter:
ВЫБРАТЬ * ИЗ РегистрНакопления.Товары.Остатки() КАК Ост
ГДЕ Ост.Склад = &Склад

// GOOD - pre-filtered at storage level:
ВЫБРАТЬ * ИЗ РегистрНакопления.Товары.Остатки(, Склад = &Склад) КАК Ост
```

**Parameter rules:**
- Use simple expressions only: `Dimension = Value`
- Multiple conditions separated by commas (implicit AND)
- NO subqueries inside parameters (use temp table + `В (ВЫБРАТЬ ... ИЗ ВТ)` pattern)
- NO joins inside parameters
- For Остатки without date parameter - returns current (latest) balances

---

## Accounting Register Virtual Table Specifics

Accounting register virtual tables have different parameter semantics from accumulation registers.

### Субконто parameter vs Условие

The `Субконто` parameter accepts виды субконто references (types from plan of characteristic types), NOT values. To filter by subconto values, use the `Условие` parameter:

```
// BAD - subconto VALUE in Субконто parameter position:
.Остатки(&Период, , &Контрагент, )

// GOOD - виды субконто in Субконто (parameter 3), VALUE in Условие (parameter 4):
.Остатки(&Период, , &ВидыСубконто, Субконто1 = &Контрагент)
```

Параметры `.Остатки()` (4): Период, УсловиеСчета, Субконто, Условие. Не путать с регистром накопления, где у `.Остатки()` другая сигнатура.

### Счет conditions in УсловиеСчета, not WHERE

```
// BAD - full table scan, then filter:
ВЫБРАТЬ * ИЗ РегистрБухгалтерии.Хозрасчетный.Остатки() КАК Ост
ГДЕ Ост.Счет = &Счет

// GOOD - pre-filtered at storage level via УсловиеСчета (parameter 2):
ВЫБРАТЬ * ИЗ РегистрБухгалтерии.Хозрасчетный.Остатки(, Счет = &Счет, , ) КАК Ост
```

Use `Счет В ИЕРАРХИИ(&Счет)` to include all sub-accounts of a parent account.

### Parameter distribution across virtual tables

Each virtual table has its own parameter set. Do not mix them. Параметры по счету (`УсловиеСчета`/`УсловиеКорСчета`/`УсловиеСчетаДт`/`УсловиеСчетаКт`) - отдельные позиционные параметры, не часть `Условие`:

- `Остатки` - 4 параметра, `УсловиеСчета` на позиции 2
- `Обороты` - 8 параметров (`УсловиеСчета` на 4, `УсловиеКорСчета` на 7, `КорСубконто` на 8)
- `ОстаткиИОбороты` - 7 параметров, есть `МетодДополненияПериодов` (4) и `УсловиеСчета` (5)
- `ОборотыДтКт` - 8 параметров с раздельными `УсловиеСчетаДт`/`СубконтоДт` и `УсловиеСчетаКт`/`СубконтоКт`
- `ДвиженияССубконто` - 5 параметров, отдельного `УсловиеСчета` нет - фильтр по счету идет через `Условие` (3-й параметр)

See the parameter table in the main skill file for exact positional order.

---

## Nested Joins Prohibition

**Never nest joins** - i.e., do not join to a subquery that itself contains joins.

```
// BAD - nested join:
ЛЕВОЕ СОЕДИНЕНИЕ (
    ВЫБРАТЬ ... ИЗ Т1 ВНУТРЕННЕЕ СОЕДИНЕНИЕ Т2 ПО ...
) КАК Подзапрос
ПО ...

// GOOD - use temp table:
ВЫБРАТЬ ... ПОМЕСТИТЬ ВТ ИЗ Т1 ВНУТРЕННЕЕ СОЕДИНЕНИЕ Т2 ПО ...;
... ЛЕВОЕ СОЕДИНЕНИЕ ВТ ПО ...
```

**Also avoid:**
- Joining to subqueries with `В` that contain joins
- Complex conditions in `ПО` (join ON clause) - especially subqueries

Replace all such patterns with sequential queries using temporary tables.

---

## Temporary Table Best Practices

**When to use:**
- Replace nested joins or subqueries in conditions
- Pre-filter large datasets before joining
- Break complex multi-join queries into steps
- Store intermediate results for reuse in batch queries

**Rules:**
- `ИНДЕКСИРОВАТЬ ПО <field>` - always add when table has >1000 rows and is used in JOIN or `В` subquery
- Minimize data volume: select only needed fields
- Minimize row count: apply filters early
- **Never create/drop temp tables in a loop** - pre-compute or batch-process instead
- Don't copy a temp table just to rename it - use the original
- For very large datasets, process in portions rather than loading everything into one temp table

---

## RLS Impact

Row-Level Security (RLS) adds implicit conditions to every query. When RLS rules contain subqueries or joins:

- Query plan becomes significantly more complex
- Compound-type dereferencing cost multiplies
- Joins become slower

**Mitigation:**
- Avoid roles with contradictory RLS on the same object
- Use `РАЗРЕШЕННЫЕ` in SELECT to apply RLS (without it, access errors may occur)
- If RLS causes severe slowdown: rewrite with temp tables in privileged mode (configuration-level)
- Keep RLS conditions simple (avoid subqueries and joins in RLS templates)

---

## Subquery Restrictions

When using subqueries (in `В`, `СУЩЕСТВУЕТ`, or as a source), avoid:

- Joins inside the subquery
- Compound-type field access ("any reference" patterns)
- Accessing document header fields from a tabular section subquery
- Complex RLS conditions that apply to subquery tables

All of these inflate the SQL generated by the 1C engine. Replace with temporary tables.

---

## DBMS Portability

1C runs on multiple DBMS backends (MS SQL, PostgreSQL, IBM DB2, Oracle). Some behaviors differ:

- **String comparison:** Generally case-insensitive in 1C, but edge cases may differ by DBMS
- **Date arithmetic precision:** May vary
- **Arithmetic precision:** Rounding differences possible
- **Query plan optimization:** Different DBMS may choose different execution plans for the same 1C query

**Recommendation:** Always use `ВЫРАЗИТЬ` for explicit type casting. Test queries on the target DBMS. Avoid relying on DBMS-specific behaviors.

# Query Syntax Reference

Detailed syntax for clauses covered briefly in the main SKILL.md.

## Contents

- [ВЫБОР (CASE)](#выбор-case)
- [ОБЪЕДИНИТЬ (UNION)](#объединить-union)
- [УПОРЯДОЧИТЬ ПО (ORDER BY)](#упорядочить-по-order-by)
- [АВТОУПОРЯДОЧИВАНИЕ](#автоупорядочивание)
- [ИТОГИ (TOTALS)](#итоги-totals)
- [Grouping sets](#grouping-sets)
- [ПОДОБНО (LIKE)](#подобно-like)
- [ССЫЛКА (type check)](#ссылка-type-check)
- [Subqueries in В (IN)](#subqueries-in-в-in)
- [ПУСТАЯТАБЛИЦА (empty table)](#пустаятаблица-empty-table)

---

## ВЫБОР (CASE)

Conditional expression - equivalent to SQL CASE.

```
ВЫБОР
    КОГДА <condition1> ТОГДА <result1>
    КОГДА <condition2> ТОГДА <result2>
    ИНАЧЕ <default>
КОНЕЦ
```

Can be used in field list, HAVING, TOTALS. **Cannot** be used as part of indexed (main) WHERE condition.

Example:
```
ВЫБРАТЬ
    Наименование,
    ВЫБОР
        КОГДА Сумма > 100000 ТОГДА "Крупный"
        КОГДА Сумма > 10000 ТОГДА "Средний"
        ИНАЧЕ "Мелкий"
    КОНЕЦ КАК Категория
ИЗ Документ.РеализацияТоваровУслуг
```

---

## ОБЪЕДИНИТЬ (UNION)

Merges results of two or more SELECT queries into one result set.

```
ВЫБРАТЬ Поле1, Поле2 ИЗ Таблица1
ОБЪЕДИНИТЬ [ВСЕ]
ВЫБРАТЬ Поле1, Поле2 ИЗ Таблица2
```

**Rules:**
- `ОБЪЕДИНИТЬ` - removes duplicates (like UNION)
- `ОБЪЕДИНИТЬ ВСЕ` - keeps duplicates (like UNION ALL, faster)
- Column count must match across all queries
- Column names and types are taken from the **first** query
- If nested table structures differ, use `ПУСТАЯТАБЛИЦА` in the query that lacks the nested table

---

## УПОРЯДОЧИТЬ ПО (ORDER BY)

```
УПОРЯДОЧИТЬ ПО <field_or_alias> [ВОЗР | УБЫВ] [, ...]
```

- `ВОЗР` - ascending (default)
- `УБЫВ` - descending
- Can reference field aliases from SELECT
- Can use aggregate function results when grouping
- **Do NOT use aggregate functions directly** for comparison in ORDER BY

Example:
```
ВЫБРАТЬ Контрагент, СУММА(Сумма) КАК Итого
ИЗ Документ.РеализацияТоваровУслуг
СГРУППИРОВАТЬ ПО Контрагент
УПОРЯДОЧИТЬ ПО Итого УБЫВ
```

---

## АВТОУПОРЯДОЧИВАНИЕ

Adds automatic ordering by "presentation" (human-readable name) of reference fields. Placed after ORDER BY or standalone.

```
ВЫБРАТЬ Контрагент, Сумма
ИЗ Документ.РеализацияТоваровУслуг
АВТОУПОРЯДОЧИВАНИЕ
```

Rarely needed - explicit `УПОРЯДОЧИТЬ ПО` is preferred for predictable results.

---

## ИТОГИ (TOTALS)

Computes aggregate subtotal rows and interleaves them with detail rows.

```
ИТОГИ
    [<aggregate_expression> [КАК <Alias>] [, ...]]
ПО
    [ОБЩИЕ]
    [, <control_point> [, ...]]
```

**Components:**
- `ОБЩИЕ` - grand total across entire result
- Control points - fields to group subtotals by. Can be hierarchical
- `ПЕРИОДАМИ(<Period>, <StartDate>, <EndDate>)` - for date-type fields; `<Period>` is one of: `СЕКУНДА`, `МИНУТА`, `ЧАС`, `ДЕНЬ`, `НЕДЕЛЯ`, `МЕСЯЦ`, `КВАРТАЛ`, `ГОД`, `ДЕКАДА`, `ПОЛУГОДИЕ`

Example:
```
ВЫБРАТЬ
    Контрагент, Номенклатура, Количество, Сумма
ИЗ Документ.РеализацияТоваровУслуг.Товары
ИТОГИ СУММА(Количество), СУММА(Сумма)
ПО ОБЩИЕ, Контрагент
```

**Periodic register totals:** Only enable (`РАЗРЕШИТЬ ИТОГИ`) when large data volume, no date in slice queries, and simple RLS.

---

## Grouping Sets

Multiple groupings in a single pass for performance.

```
СГРУППИРОВАТЬ ПО ГРУППИРУЮЩИМ НАБОРАМ
    (
        (НаборПолей1),
        (НаборПолей2)
    )
```

Field order within a set and set order both matter. Use `СГРУППИРОВАНОПО(<field>)` function to determine which grouping set produced a given row.

Example:
```
ВЫБРАТЬ Контрагент, Номенклатура, СУММА(Сумма) КАК Итого
ИЗ Документ.РеализацияТоваровУслуг.Товары
СГРУППИРОВАТЬ ПО ГРУППИРУЮЩИМ НАБОРАМ
    (
        (Контрагент),
        (Номенклатура),
        (Контрагент, Номенклатура)
    )
```

---

## ПОДОБНО (LIKE)

String pattern matching operator.

```
ГДЕ Наименование ПОДОБНО "Шаблон"
```

**Wildcards:**

| Character | Meaning | Example |
|-----------|---------|---------|
| `%` | Any string (0+ chars) | `"%молоко%"` - contains "молоко" |
| `_` | Exactly one character | `"__-__"` - matches "12-34" |
| `[abc]` | One char from set | `"[АБВ]%"` - starts with А, Б, or В |
| `[^abc]` | One char NOT in set | `"[^0-9]%"` - starts with non-digit |
| `[a-z]` | One char in range | `"[А-Я]%"` - starts with capital Cyrillic |

**Escape character:** Use `СПЕЦСИМВОЛ` to escape wildcards:
```
ГДЕ Код ПОДОБНО "%#_%" СПЕЦСИМВОЛ "#"
// matches literal underscore in Код
```

**Performance:** Pattern must NOT start with `%` or `_` if used in indexed (main) condition - such patterns prevent index usage.

---

## ССЫЛКА (Type Check)

Checks if a reference-type value points to a specific table. Used with compound-type fields.

```
ГДЕ Регистратор ССЫЛКА Документ.РеализацияТоваровУслуг
```

Commonly paired with `ВЫРАЗИТЬ`:
```
ВЫБРАТЬ
    ВЫБОР
        КОГДА Регистратор ССЫЛКА Документ.Реализация
            ТОГДА ВЫРАЗИТЬ(Регистратор КАК Документ.Реализация).Контрагент
        КОГДА Регистратор ССЫЛКА Документ.Поступление
            ТОГДА ВЫРАЗИТЬ(Регистратор КАК Документ.Поступление).Контрагент
    КОНЕЦ КАК Контрагент
ИЗ РегистрНакопления.ОстаткиТоваров
```

---

## Subqueries in В (IN)

Check membership against a subquery result:

```
ГДЕ Контрагент В (
    ВЫБРАТЬ Ссылка ИЗ Справочник.Контрагенты ГДЕ Город = &Город
)
```

**Rules:**
- Subquery must return exactly one column
- Avoid complex subqueries (joins, compound type access, nested subqueries). Use temporary tables instead
- For large filter sets, a temp table with `В (ВЫБРАТЬ ... ИЗ ВТ)` is more efficient than a literal list

---

## ПУСТАЯТАБЛИЦА (Empty Table)

Used in UNION when one query has a nested table (tabular section) that the other doesn't.

```
// Query 1 has Товары nested table
ВЫБРАТЬ Ссылка, Товары.(Номенклатура, Количество)
ИЗ Документ.РеализацияТоваровУслуг

ОБЪЕДИНИТЬ ВСЕ

// Query 2 lacks it - provide matching empty table
ВЫБРАТЬ Ссылка, ПУСТАЯТАБЛИЦА.(Номенклатура, Количество)
ИЗ Документ.ВозвратТоваров
```

Alias names inside `ПУСТАЯТАБЛИЦА.(...)` must match the aliases from the corresponding real nested table in the other query.