Blog

Dinheiro em float que não fecha o caixa: numeric, centavos inteiros e arredondamento no lugar certo

O fechamento de outubro de um e-commerce não bateu por R$ 20,69. Era pouco dinheiro em R$ 2,18 milhões, mas a contabilidade não aceita "pouco": cada centavo sem explicação vira ajuste manual, e ajuste manual todo mês vira pergunta de auditoria. Depois de três dias procurando estornos e taxas, a causa apareceu em 1 de cada 6 pedidos: diferenças de 1 ou 2 centavos entre o que o sistema calculava e o que o gateway cobrava. A coluna de valor era double precision, a API somava com Number, o arredondamento acontecia só no total enquanto o gateway arredondava item a item, e o parcelamento cobrava R$ 99,99 de uma compra de R$ 100,00. Este artigo explica por que float não representa centavo, onde guardar valor monetário, como arredondar uma vez só e no lugar certo, como ratear parcelas sem perder centavo e como migrar uma coluna float para numeric sem esconder a diferença que já existe.

2026-11-14 / Arquitetura / 13 min

01

O caixa que não fecha por R$ 20,69: um erro pequeno em cada pedido

Diferença de fechamento costuma ser investigada como problema de processo: pedido estornado por fora, taxa lançada no lugar errado, venda duplicada. Por isso o time gastou dois dias nas hipóteses erradas. O que denunciou a causa real foi o formato da diferença: muitos pedidos com 1 ou 2 centavos, nenhum com valor grande. Diferença de processo aparece concentrada. Diferença de representação numérica aparece espalhada.

Dia 1  fechamento de outubro: 41.380 pedidos
       soma no banco (coluna double precision)   R$ 2.184.392,17
       repasse do gateway de pagamento           R$ 2.184.371,48
       diferença                                 R$ 20,69

Dia 1  primeira hipótese: pedidos estornados fora do sistema -> nenhum encontrado
Dia 2  segunda hipótese: taxa do gateway -> a taxa já vinha separada no extrato

Dia 3  a diferença aparece em 1 de cada 6 pedidos, sempre de 1 ou 2 centavos
       API em Node: total = itens.reduce((s, i) => s + i.preco * i.qtd * (1 - desc), 0)
       arredondamento: Math.round(total * 100) / 100, aplicado só no total
       gateway: arredonda o desconto item a item e soma depois
       parcelamento: 3 x Math.floor(total / 3 * 100) / 100 -> R$ 99,99 cobrado de R$ 100,00

Dia 4  contabilidade lança R$ 20,69 como "ajuste" e pede para isso não voltar em novembro

Havia três defeitos somados. O primeiro era de tipo: double precision no banco e Number no Node, os dois em ponto flutuante binário, que não representam 0,10 de forma exata. O segundo era de lugar: o sistema arredondava o total do pedido e o gateway arredondava cada desconto de item, então os dois chegavam a valores diferentes mesmo com aritmética perfeita. O terceiro era de rateio: dividir R$ 100,00 em três e truncar cada parcela perde um centavo, e o cliente paga menos do que o pedido registra.

Só o primeiro defeito se resolve trocando o tipo da coluna. Os outros dois são decisões de regra de negócio que o código precisa tornar explícitas. É por isso que "trocar float por decimal" sozinho raramente fecha o caixa.

02

Por que float não guarda 0,10: ponto flutuante binário e o erro que acumula

real e double precision no Postgres, float e double em Java, Number em JavaScript seguem o IEEE 754: o valor é guardado como uma fração binária. Assim como 1/3 não tem representação finita em decimal, 1/10 não tem em binário. O número guardado para 0,1 é o double mais próximo, um pouco acima de 0,1. Cada operação arredonda de novo para o double mais próximo, e o erro de cada etapa se soma ao das anteriores.

-- O mesmo valor em float e em numeric.
SELECT 0.1::float8 + 0.2::float8     AS soma_float,      -- 0.30000000000000004
       0.1::numeric + 0.2::numeric   AS soma_numeric;    -- 0.3

-- Soma de dez parcelas de 0,10 em float.
SELECT sum(v) FROM (SELECT 0.1::float8 AS v FROM generate_series(1, 10)) s;
-- 0.9999999999999999

-- round em float arredonda metade para o par. Em numeric, metade para longe do zero.
SELECT round(2.5::float8) AS round_float,     -- 2
       round(2.5::numeric) AS round_numeric;  -- 3

// Em JavaScript, Number e double: o mesmo problema, agora no backend.
0.1 + 0.2;                       // 0.30000000000000004
19.9 * 3;                        // 59.699999999999996
Math.floor(19.9 * 3 * 100);      // 5969 centavos, não 5970
Math.round(1.005 * 100) / 100;   // parece arredondar para 1,01, mas devolve 1
(1.005).toFixed(2);              // '1.00'

O problema não é a exibição. Mostrar 0,30000000000000004 como R$ 0,30 parece resolver, mas o valor errado continua sendo usado na conta seguinte. O caso clássico é o de Math.floor(19.9 * 3 * 100): o produto em float fica um fio abaixo de 59,70, o floor joga para 5969 centavos, e o cliente é cobrado um centavo a menos. Math.round(1.005 * 100) devolve 100 pelo mesmo motivo: 1,005 em binário é um pouco menor que 1,005, e o arredondamento cai para baixo.

Existe ainda uma diferença sutil de comportamento. round em float no Postgres arredonda a metade para o par, então round(2.5::float8) devolve 2, enquanto round(2.5::numeric) devolve 3. Uma consulta que arredonda o mesmo campo em tipos diferentes, por exemplo numa view que faz cast, produz centavos diferentes para o mesmo pedido.

03

Onde guardar dinheiro: numeric, centavos inteiros ou o tipo money

Existem duas escolhas corretas e uma armadilha. numeric(p, s) guarda o valor em base decimal, com escala fixa, e faz soma, subtração e multiplicação exatas. bigint em centavos guarda um inteiro, que é exato por definição, e deixa a interpretação da escala para a aplicação. O tipo money do Postgres parece feito para isso, mas formata e interpreta valores conforme o lc_monetary da sessão e mistura dado com apresentação.

TipoExatoPonto forteArmadilhaQuando usar
real / double precisionNãoRápido e compactoErro de representação que acumula em somasNunca para valor monetário
moneySim, com 2 casas fixasFormatação prontaDepende do lc_monetary; uma só moeda; divisão devolve floatEvitar em sistema novo
numeric(14, 2)SimAritmética exata no SQL, legível em relatórioDriver devolve string; mais lento que inteiro em agregações enormesPadrão para a maioria dos sistemas
bigint em centavosSimRápido, simples de serializar, sem ambiguidade de escalaEscala implícita: a moeda precisa vir junto; relatório SQL divide por 100Ledger de alto volume, integração com gateway que usa centavos
numeric sem escala ou com 4+ casasSimGuarda câmbio, tarifa por unidade, juros intermediáriosValor final precisa ser arredondado antes de cobrarTaxas e preços unitários fracionados, nunca o valor cobrado

Na prática, numeric(14, 2) cobre até R$ 999 bilhões com centavos e é a escolha mais segura para o modelo relacional, porque relatório, view e consulta ad hoc continuam legíveis. Centavos inteiros fazem sentido quando o volume de agregação é muito alto ou quando o gateway já fala em centavos, como a maioria das APIs de pagamento. O que não faz sentido é misturar: uma tabela em centavos e outra em reais força conversão em cada join, e cada conversão é um lugar novo para errar a escala.

-- Valor monetário em numeric com escala fixa: soma e multiplicação exatas.
CREATE TABLE pedidos (
  id          bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
  moeda       char(3) NOT NULL DEFAULT 'BRL',
  -- O cabeçalho guarda o total cobrado, que precisa bater com a soma dos itens.
  total       numeric(14, 2) NOT NULL CHECK (total >= 0),
  criado_em   timestamptz NOT NULL DEFAULT now()
);

CREATE TABLE pedido_itens (
  pedido_id      bigint NOT NULL REFERENCES pedidos (id),
  linha          smallint NOT NULL,
  quantidade     integer NOT NULL CHECK (quantidade > 0),
  preco_unitario numeric(12, 2) NOT NULL CHECK (preco_unitario >= 0),
  desconto       numeric(12, 2) NOT NULL DEFAULT 0 CHECK (desconto >= 0),
  -- O total do item é derivado, nunca digitado em outro lugar.
  total          numeric(14, 2) GENERATED ALWAYS AS (quantidade * preco_unitario - desconto) STORED,
  PRIMARY KEY (pedido_id, linha),
  CHECK (desconto <= quantidade * preco_unitario)
);

Duas decisões desse esquema evitam a maior parte das divergências. O total do item é uma coluna gerada, então não existe um segundo cálculo do mesmo valor em outro lugar do código. E a moeda fica ao lado do valor: escala de duas casas não serve para iene, que não tem centavos, nem para dinar kuwaitiano, que tem três.

04

Arredondar uma vez e no lugar certo: item, total e parcela

Mesmo com aritmética exata, arredondar em lugares diferentes produz resultados diferentes. Três itens de R$ 0,35 com 10% de desconto: se o desconto é calculado no total, R$ 1,05 vezes 10% dá R$ 0,105, que vira R$ 0,11. Se é calculado por item, cada R$ 0,035 vira R$ 0,04, e o desconto total é R$ 0,12. Nenhum dos dois está errado. Errado é o sistema fazer de um jeito e o gateway, a nota fiscal ou o ERP fazerem de outro.

  • Descubra a granularidade do documento de referência: a nota fiscal arredonda tributo por item, então o sistema também precisa arredondar por item e somar depois.
  • Escolha o modo de arredondamento e escreva no código: metade para longe do zero é o que o Postgres faz em numeric e o que a maioria das regras fiscais espera; metade para o par reduz viés em somas grandes e aparece em regras bancárias.
  • Arredonde uma vez, no fim de cada cálculo que gera valor cobrado. Valores intermediários, como preço por grama ou câmbio, ficam com mais casas e só viram centavo no último passo.
  • Parcela e rateio não se dividem: se alocam. O total é fixo e as partes precisam somar exatamente o total.

O módulo abaixo resolve as três operações sem passar por float: converte string decimal para centavos em BigInt, multiplica e divide com o modo de arredondamento explícito e faz o rateio pelo método do maior resto. Ele usa só a biblioteca padrão e cabe no projeto sem dependência nova.

// money.js
// Valor monetário entra e sai como string decimal ("123.45") e vive como BigInt em centavos.
// Number nunca: um parseFloat no caminho reintroduz o erro de representação.
const DECIMAL_RE = /^(-)?(\d+)(?:\.(\d{1,2}))?$/;

export function toCents(value) {
  if (typeof value !== 'string') {
    throw new TypeError('valor monetário deve chegar como string, nunca como number');
  }
  const match = DECIMAL_RE.exec(value.trim());
  if (!match) throw new RangeError(`valor monetário inválido: ${value}`);
  const [, sign, units, fraction = ''] = match;
  const cents = BigInt(units) * 100n + BigInt(fraction.padEnd(2, '0'));
  return sign ? -cents : cents;
}

export function fromCents(cents) {
  const negative = cents < 0n;
  const abs = negative ? -cents : cents;
  const fraction = (abs % 100n).toString().padStart(2, '0');
  return `${negative ? '-' : ''}${abs / 100n}.${fraction}`;
}

// a * b / d com arredondamento explícito, sem passar por float.
// 'half-up': metade para longe do zero, igual a round(numeric) no Postgres.
// 'half-even': metade para o par (arredondamento bancário).
export function mulDiv(a, b, d, mode = 'half-up') {
  if (d === 0n) throw new RangeError('divisão por zero');
  const n = a * b;
  const negative = (n < 0n) !== (d < 0n);
  const absN = n < 0n ? -n : n;
  const absD = d < 0n ? -d : d;
  let q = absN / absD;
  const twice = (absN % absD) * 2n;
  if (mode === 'half-up' && twice >= absD) q += 1n;
  if (mode === 'half-even' && (twice > absD || (twice === absD && q % 2n === 1n))) q += 1n;
  return negative ? -q : q;
}

// Rateio pelo maior resto: a soma das partes é sempre igual ao total.
// Para estorno, rateie o valor absoluto e inverta o sinal.
export function allocate(totalCents, weights) {
  if (totalCents < 0n) throw new RangeError('rateie o valor absoluto');
  const totalWeight = weights.reduce((sum, w) => sum + w, 0n);
  if (totalWeight <= 0n || weights.some((w) => w < 0n)) {
    throw new RangeError('pesos precisam ser não negativos e somar mais que zero');
  }
  const shares = weights.map((w, index) => ({
    index,
    cents: (totalCents * w) / totalWeight,
    remainder: (totalCents * w) % totalWeight,
  }));
  let leftover = totalCents - shares.reduce((sum, s) => sum + s.cents, 0n);
  // Os centavos que sobraram vão para as partes com maior resto.
  const byRemainder = [...shares].sort((a, b) =>
    b.remainder === a.remainder ? a.index - b.index : b.remainder > a.remainder ? 1 : -1,
  );
  for (const share of byRemainder) {
    if (leftover === 0n) break;
    share.cents += 1n;
    leftover -= 1n;
  }
  return shares.map((s) => s.cents);
}

// uso.js
import { allocate, fromCents, mulDiv, toCents } from './money.js';

// 10% de desconto sobre 3 itens de R$ 0,35 (R$ 1,05): 0,105 vira 11 centavos.
const subtotal = toCents('0.35') * 3n;                // 105n
const desconto = mulDiv(subtotal, 10n, 100n);         // 11n

// R$ 100,00 em 3 parcelas: soma 100,00, não 99,99.
const parcelas = allocate(toCents('100.00'), [1n, 1n, 1n]);
parcelas.map(fromCents);                              // ['33.34', '33.33', '33.33']

// Formatação só na borda, a partir da string exata.
const brl = new Intl.NumberFormat('pt-BR', { style: 'currency', currency: 'BRL' });
brl.format(fromCents(subtotal - desconto));           // 'R$ 0,94'

O rateio pelo maior resto é o que impede o R$ 99,99. Cada parte recebe o quociente inteiro, e os centavos que sobram são distribuídos, um a um, para as partes com maior resto, em ordem estável. Com pesos iguais, o centavo extra fica na primeira parcela; com pesos proporcionais, como o rateio de frete pelo valor de cada item, ele vai para quem perdeu mais no arredondamento. A propriedade que importa é testável: a soma das partes é sempre igual ao total.

05

A borda da aplicação: driver, JSON e formatação sem parseFloat

Trocar a coluna para numeric não adianta se o valor volta a ser float no caminho. O driver pg do Node devolve numeric como string justamente para não perder precisão, e a correção mais comum que se encontra em projetos é um setTypeParser com parseFloat, que desfaz toda a proteção. O mesmo acontece com um ORM configurado para mapear decimal em number, ou com um front que recebe "19.90" e faz Number(valor) antes de multiplicar pela quantidade.

// db.js
import pg from 'pg';

// numeric (OID 1700) já chega como string: mantenha assim e converta com toCents.
// NUNCA: pg.types.setTypeParser(1700, parseFloat)
// bigint (OID 20) como BigInt, para colunas em centavos inteiros.
pg.types.setTypeParser(20, (value) => BigInt(value));

export const pool = new pg.Pool({ connectionString: process.env.DATABASE_URL });

export async function totalDoPedido(pedidoId) {
  const { rows } = await pool.query('SELECT total FROM pedidos WHERE id = $1', [pedidoId]);
  return rows[0].total; // '1234.56', string exata
}

// JSON.stringify não serializa BigInt: a API devolve string decimal.
export const serializar = (pedido) => ({ ...pedido, total: String(pedido.total) });
  • No banco: numeric com escala fixa ou bigint em centavos, nunca float.
  • Na entrada da API: valor como string decimal ("19.90") ou inteiro em centavos (1990), com validação de formato. Number em JSON perde a garantia antes de chegar ao código.
  • No domínio: BigInt em centavos ou uma biblioteca decimal; toda multiplicação por percentual passa por uma função com modo de arredondamento explícito.
  • Na saída: string decimal, e Intl.NumberFormat só para exibição, recebendo a string exata.

Uma regra de revisão de código pega quase todos os casos: qualquer parseFloat, Number(), toFixed ou Math.round perto de uma variável chamada valor, preco, total ou desconto merece pergunta. toFixed, em particular, é formatação, não arredondamento: (1.005).toFixed(2) devolve "1.00".

06

Migrar a coluna float para numeric sem esconder a diferença

A migração tem duas partes: medir o estrago antes e trocar o tipo depois. Medir importa porque a conversão arredonda os resíduos e faz a diferença acumulada aparecer de uma vez nos relatórios. Se o financeiro não souber disso antes, o primeiro fechamento depois da migração parece um novo incidente.

-- Quantas linhas já carregam resíduo de float (valor que não é um centavo exato).
SELECT count(*) AS linhas,
       count(*) FILTER (WHERE valor <> round(valor::numeric, 2)::float8) AS com_residuo,
       -- Diferença acumulada que a migração vai tornar visível.
       sum(valor::numeric) - sum(round(valor::numeric, 2)) AS diferenca
  FROM lancamentos;

-- Tabela pequena: conversão direta. Reescreve a tabela sob ACCESS EXCLUSIVE.
ALTER TABLE lancamentos
  ALTER COLUMN valor TYPE numeric(14, 2) USING round(valor::numeric, 2);

-- Itens cuja soma não bate com o total cobrado no cabeçalho.
SELECT p.id, p.total, sum(i.total) AS soma_itens, p.total - sum(i.total) AS diferenca
  FROM pedidos p
  JOIN pedido_itens i ON i.pedido_id = p.id
 GROUP BY p.id, p.total
HAVING p.total <> sum(i.total)
 ORDER BY abs(p.total - sum(i.total)) DESC
 LIMIT 100;

O ALTER COLUMN TYPE reescreve a tabela inteira com lock exclusivo, o que só é aceitável em tabela pequena ou numa janela de manutenção. Em tabela grande, o caminho seguro é adicionar uma coluna numeric nova, preencher em lotes, manter as duas sincronizadas por trigger enquanto o código passa a ler da nova e só então remover a antiga. A consulta de conciliação no fim do bloco deve virar um job diário: qualquer pedido cuja soma dos itens não bate com o total cobrado é um alerta, não um ajuste de fim de mês.

EtapaO que fazerComo validar
1. MedirContar linhas com resíduo e a diferença acumuladaNúmero compartilhado com o financeiro antes da troca
2. Corrigir a bordaRemover parseFloat e Number do caminho do valorTestes com 1.005, 19.9 x 3 e rateio de 100 em 3
3. Trocar o tipoALTER direto em tabela pequena ou coluna nova com backfill em lotesContagem de linhas e soma por mês iguais antes e depois do arredondamento
4. Alinhar a regraArredondar na mesma granularidade do gateway e da nota fiscalAmostra de pedidos com valor idêntico nos dois sistemas
5. Conciliar sempreJob diário comparando itens, cabeçalho e repasseAlerta com lista de pedidos divergentes, não um total

FAQ

Perguntas frequentes

Posso continuar com double precision se eu arredondar na hora de exibir?

Não. Arredondar na exibição esconde o erro, mas o valor sem arredondamento continua sendo usado em somas, descontos, parcelas e relatórios. O erro aparece justamente onde não há exibição: no total do mês, na conciliação com o gateway e em comparações de igualdade que falham por um resíduo na décima sexta casa.

numeric é lento demais para tabelas grandes?

Para a maioria dos sistemas, não faz diferença perceptível: o custo de um pedido está em I/O, índices e rede, não na soma de alguns numeric. Em agregações de centenas de milhões de linhas, numeric é mais lento que bigint, e aí guardar centavos inteiros é uma escolha legítima. O que nunca compensa é trocar exatidão por velocidade usando float.

Centavos inteiros ou numeric: qual escolher?

numeric(14, 2) é o padrão mais seguro quando o banco também serve relatórios e consultas manuais, porque o valor é legível como está. Centavos em bigint compensam em ledger de alto volume ou quando a integração principal já fala em centavos. Em qualquer dos dois, guarde a moeda junto, nunca misture as duas representações no mesmo banco e use mais casas só para valores intermediários, como câmbio e preço unitário fracionado.

Dinheiro exige tipo exato, regra explícita e conciliação contínua

O caixa que não fecha por centavos quase nunca tem uma causa só. O tipo float introduz erro de representação, o arredondamento em lugares diferentes cria divergência com gateway e nota fiscal, e a divisão de parcelas perde centavo. A correção combina numeric ou centavos inteiros no banco, uma borda que nunca converte valor para float, arredondamento escrito no código com modo e granularidade definidos, rateio pelo maior resto e uma conciliação diária que transforma diferença em alerta. Se o seu fechamento depende de ajuste manual todo mês, eu posso revisar o modelo de dados, o fluxo de cálculo e a integração com o gateway.