Деление vs умножение: одна цифра в запросе крадёт три знака точности

Деление vs умножение: одна цифра в запросе крадёт три знака точности

Деление и умножение — это одна и та же операция в двух формах. Для математики это так. Для запроса 1С — нет. Замена / 10000 на * 0.0001 в одной формуле может вернуть три потерянных знака точности после запятой и закрыть расхождение в декларации, которая иначе уходит в налоговую с ошибкой.

Я долго думал, что это занудный нюанс, который никому не интересен, пока не наткнулся на него во второй раз за месяц. И тогда понял, что это не нюанс, а закономерность, и закономерность эту полезно описать словами.

Откуда взялась проблема

Я настраивал отчёт по оборотам алкогольной продукции для регуляторной отчётности в Беларуси. По правилам, всё движение алкоголя надо отчитывать в декалитрах — это объёмная единица, где один декалитр равен десяти литрам. Бутылка вина 0,75 литра — это 0,075 декалитра. Бутылка водки 0,5 литра — 0,05 декалитра.

В базе номенклатура хранится в штуках, а ёмкость каждой единицы — в миллилитрах. Чтобы перевести количество штук в декалитры, нужна банальная формула: количество умножить на ёмкость в миллилитрах, поделить на десять тысяч. Получается объём в декалитрах.

В коде запроса это выглядело так:

ВЫБРАТЬ
    Номенклатура,
    КоличествоПриход * Емкость / 10000 КАК ОбъёмДекалитров
ИЗ
    РегистрНакопления.ОборотыАлкоголя.Обороты(...)

Формула математически правильная. Никаких ошибок логики, никаких опечаток. Отчёт формируется, числа выглядят корректными. На бутылке 0,75 литра и обороте в сто штук я ожидал увидеть 7,5 декалитра. И именно 7,5 декалитра я видел.

Расхождение всплыло на сверке с другим отчётом — декларацией оборота алкоголя, которая считалась в той же базе, по тем же данным, но через другой запрос с другим набором затрат. Цифры на товарах со "стандартной" ёмкостью (0,5 литра, 0,75 литра, 1 литр) сходились. На товарах с нестандартной ёмкостью (0,33 литра, 0,375 литра, 0,7 литра) появлялась разница в третьем знаке после запятой. Не катастрофа, но в декалитрах за месяц она накапливалась до сотен граммов абсолютной алкогольной продукции, которые потом нужно было объяснять налоговой.

Платформа сама решает, сколько знаков выделить под результат

Когда я открыл оба запроса параллельно, разница в формулах нашлась моментально. В одном отчёте было Емкость / 10000. В другом — Емкость * 0.0001. Формулы математически эквивалентные. Результаты — нет.

Ключевая особенность языка запросов 1С (и в целом многих SQL-движков) заключается в том, что тип результата выражения вычисляется не из значений операндов, а из их типов. Это статическая типизация, и она довольно агрессивная. Платформа смотрит на типы операндов перед выполнением запроса и решает, какой тип будет у результата каждой операции.

Поле Емкость хранится в базе как число с фиксированной точностью — допустим, четыре знака после запятой. Литерал 10000 в тексте запроса воспринимается платформой как целое число. Когда вы делите Число(4 знака) на Целое, движок запросов рассчитывает тип результата по своим внутренним правилам. И эти правила консервативные: для деления на целое выделяется фиксированное количество знаков после запятой, обычно меньше, чем хранилось в исходном дробном операнде.

Конкретно в моём случае результат Емкость / 10000 получал на выходе пять знаков после запятой. Для бутылки 500 миллилитров это работало: 500 / 10000 = 0,05000, пять знаков, всё точно. Для бутылки 330 миллилитров: 330 / 10000 = 0,03300, тоже точно. Это меня и обмануло — пять знаков обычно "хватает" для интуитивно простых дробей. Но как только результат подставлялся в дальнейшие операции (умножение на количество, суммирование по группам, перевод в декалитры), потеря точности накапливалась.

Сравнение точности: деление на целое 10000 даёт 5 знаков, умножение на 0.0001 даёт 8 знаков после запятой

Замена на * 0.0001 сразу меняет картину. Литерал 0.0001 платформа видит как дробное число с четырьмя знаками после запятой. Тип результата операции Число(4 знака) * Число(4 знака) рассчитывается уже совсем по другим правилам — выделяется больше разрядов под результат. На моих данных вместо пяти знаков получалось восемь. Этих трёх дополнительных знаков и хватало, чтобы пересчёт в декалитры по нестандартным ёмкостям сходился до последней копейки литра.

Та же арифметика. Тот же ответ для калькулятора. Совершенно разные типы данных и совершенно разный результат внутри запроса.

Это не баг платформы — это контракт

Я хочу заострить на этом внимание, потому что когда я первый раз с этим столкнулся, у меня было искушение списать это на странность 1С. "Платформа неправильно считает". Это неправильное обвинение. Платформа считает ровно так, как обещала. Просто её обещание (контракт) нужно знать.

Контракт примерно такой: тип результата выражения определяется типами операндов по фиксированным правилам. Для дробных литералов точность результата выше, чем для целых. Если ты передаёшь в выражение целое число, платформа делает консервативное предположение о точности. Если ты передаёшь дробное — она расширяет разрядность.

Это не подразумевается. Это прямо документировано. Просто такие вещи обычно никто не читает, пока не упрётся в расхождение в декларации алкоголя.

Аналог в SQL других движков — это разница между 1/3 и 1.0/3. В большинстве SQL-баз первое выражение даёт ноль (потому что оба операнда целые, результат тоже целый). Второе даёт 0.333... (потому что один операнд дробный, результат выводится в дробной арифметике). Это та же самая логика, просто выраженная иначе. И ловушка та же: формула выглядит нормальной, но результат зависит от типов, а не от значений.

Масштаб проблемы был больше, чем я думал

Когда я нашёл первое место с / 10000, я полез искать остальные. Открыл текст запроса того отчёта целиком — там было пятнадцать расчётных полей. Поступления, расход, возвраты, сторно, списания, остатки на начало, остатки на конец, балансовые корректировки — каждое со своим пересчётом из миллилитров в декалитры. И в каждом стояло / 10000.

Поправил все пятнадцать.

Перепроверил другие места, где могла быть та же проблема. Запросил у репозитория все тексты запросов проекта, которые содержат / 10000. Нашлось ещё одно — в соседнем отчёте, в декларации оборота алкоголя. Ровно тот же шаблон. Та же ошибка точности. Тот же фикс на одну строку.

Один баг — пятнадцать мест в первом отчёте, плюс ещё один отчёт с тем же шаблоном пересчёта в декалитры

Получилось так, что одна и та же ошибка "расползлась" по двум отчётам и шестнадцати расчётным полям. Не потому что её повторили шестнадцать раз сознательно. А потому что когда первый разработчик писал первый отчёт, он закодировал формулу в одном виде, и потом она копировалась — в соседние поля внутри того же отчёта, а потом и в соседний отчёт. Копи-паста распространила баг быстрее, чем кто-то успел заметить расхождение.

Заодно нашёлся ещё один сюрприз

Пока я возился с пересчётом миллилитров в декалитры, попутно открыл табличный документ, в котором этот результат показывался. И увидел, что формат вывода стоял "5 знаков после запятой". То есть даже если запрос возвращал восемь знаков, отчёт обрезал последние три при отображении. Оператор видел число 0,07530 и думал, что это окончательная точность.

Поправил формат на 8 знаков. Это уже было не для математической корректности (агрегаты считаются с полной точностью), а для того, чтобы человек, открывший отчёт, видел те же цифры, которые потом попадают в декларацию. Когда отчёт показывает одно число, а декларация — другое (отличающееся в пятом-шестом знаке), у пользователя возникает ощущение, что система нестабильна. На самом деле она стабильна, просто разные вьюшки одного и того же числа округляют по-разному. Но пользователю это не объяснишь.

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

Правила, которые я применяю с тех пор

Эта история заставила меня сформулировать несколько правил, которыми я теперь пользуюсь почти автоматически.

В запросах не делить на целые литералы. Если хочешь поделить на десять тысяч — пиши * 0.0001, а не / 10000. Это не суеверие. Это разница в типе результата. Привычка занимает один рефлекс — но экономит часы отладки расхождений в финансовых и регуляторных отчётах.

Не доверять интуиции о точности. Если в запросе есть деление, я иду и проверяю разрядность результата на тестовых данных. Беру одно из исходных значений с заведомо большим количеством знаков (не "круглое" число), пропускаю через формулу и смотрю на выход. Сравниваю с тем, что считал бы калькулятор. Если расходится — повод думать о типах.

Один и тот же шаблон формулы — в одной общей функции. Если в проекте десять отчётов используют одну и ту же формулу пересчёта объёмов, эта формула должна быть в одном месте — в общем модуле или в виде вычисляемого поля регистра. Не пятнадцать копий одного выражения по разным запросам. Иначе одна ошибка распространится по всем местам копи-пастой, и фикс придётся делать тоже пятнадцать раз. Это базовый принцип "одна функция — один источник истины", и для запросов он работает так же, как для обычного кода. Я уже разбирал похожий паттерн в истории про рефакторинг 2400-строчного модуля — там та же копи-паста породила десятки расходящихся версий одной и той же логики.

Сверять несколько отчётов между собой. Если два отчёта считают одно и то же значение разными запросами, и эти запросы по результату не сходятся — это всегда повод для расследования. Чаще всего проблема будет либо в типах операндов, либо в порядке арифметики (сумма после округления vs округление после суммы), либо в том, что один из запросов фильтрует данные иначе. И каждый раз это полезное упражнение, потому что оно заставляет понять, какой именно расчёт является "правильным", и привести оба отчёта к нему.

Чек-лист: проверка точности в запросах 1С — типы литералов, разрядность результата, единый источник формулы

Один абзац-вывод

Запросы в 1С — это не чистая математика. Это математика, наложенная на систему типов. И система типов решает за тебя многие вещи, о которых ты не задумывался. В большинстве случаев это работает незаметно, и привычка "писать формулы как пишутся" даёт правильный результат. Но в финансовой и регуляторной отчётности "в большинстве случаев" — недостаточно. Там нужно "всегда", и для этого надо знать, что одна цифра в литерале может изменить точность результата на три знака.

В моём случае это была разница между отчёт сходится с декларацией и каждую неделю объяснять налоговой, откуда взялись 0,003 декалитра расхождения. И единственный код, который для этого пришлось изменить, — это шестнадцать раз заменить / 10000 на * 0.0001 и поднять формат отображения с пяти знаков до восьми.

Это, наверное, самый дешёвый рефакторинг, который я делал за последний месяц. И, наверное, один из самых поучительных. Потому что он напомнил мне, что компилятор (а движок запросов — это, по сути, компилятор) — не нейтральный посредник между формулой и результатом. Он принимает решения. И если ты не знаешь, какие решения он принимает, твоя "математически правильная" формула будет давать математически правильный, но не тот результат.

Платформа не ошибается. Платформа делает ровно то, что обещала. Просто её обещание нужно прочитать заранее, а не после того, как декларация по алкоголю уйдёт в налоговую с расхождением в третьем знаке.