Funciones numéricas — Referencia de SQL en Marketing Cloud | Cleon

Las funciones numéricas en MC SQL son el set estándar de T-SQL. Los bugs son mayormente sobre tres cosas: la división entera trunca (5 / 2 devuelve 2, no 2.5), ROUND con scale negativo redondea al 10 / 100 / 1000 más cercano (truco útil, fácil de leer mal), y precisión DECIMAL cuando la columna guarda dinero o puntos de loyalty y la matemática tiene que ser exacta.

Sintaxis oficial

-- Valor absoluto
SELECT ABS(LoyaltyDelta) AS DeltaAbs FROM master_subscribers;

-- Redondeo
SELECT
  CEILING(4.2)            AS Up,            -- 5
  FLOOR(4.8)              AS Down,          -- 4
  ROUND(4.567, 2)         AS TwoDec,        -- 4.57
  ROUND(4.567, 0)         AS WholeNumber,   -- 5
  ROUND(1234.567, -2)     AS NearestHundred -- 1200
FROM master_subscribers;

-- Potencia, raíz cuadrada, signo
SELECT
  POWER(2, 10)            AS TwoPowTen,    -- 1024
  SQRT(144)               AS RootOfNine,   -- 12
  SIGN(-7)                AS Negative,     -- -1
  SIGN(0)                 AS Zero,         -- 0
  SIGN(42)                AS Positive      -- 1
FROM master_subscribers;

-- Número aleatorio entre 0 y 1 (no-determinístico por llamada)
SELECT RAND() AS RandomValue FROM master_subscribers;

-- Módulo vía %
SELECT 17 % 5 AS Remainder;  -- 2

El set soportado entre la mayoría de los tenants SFMC:

| Función | Qué hace | Devuelve | |---|---|---| | ABS(n) | Valor absoluto | Mismo tipo numérico que input | | CEILING(n) | Entero más chico ≥ n | INT | | FLOOR(n) | Entero más grande ≤ n | INT | | ROUND(n, scale) | Redondea n a scale decimales (scale negativo redondea a la izquierda del decimal) | Mismo tipo numérico que n | | POWER(base, exp) | base elevado a exp | FLOAT | | SQRT(n) | Raíz cuadrada | FLOAT | | SIGN(n) | -1, 0, o 1 según el signo de n | INT | | RAND() | Float pseudo-random en [0, 1), no-determinístico | FLOAT | | n % m | Módulo (resto de división entera) | INT | | + - * / | Operadores aritméticos estándar | Depende de tipos de operandos |

Referencia:

Salesforce Help — Sintaxis T-SQL soportada (sección de funciones) ↗

Lo que sobrevive en producción

La división entera trunca — la fuente silenciosa de off-by-one

5 / 2 en T-SQL devuelve 2, no 2.5. El tipo de resultado se determina por los tipos de los operandos, no por la matemática. Si los dos lados son INT, la división devuelve INT y la parte fraccional se descarta antes de que la veas.

-- BUG — división entera, devuelve 0 cuando LoyaltyPoints < TotalSpend
SELECT
  SubscriberKey,
  LoyaltyPoints / TotalSpend AS PointsPerDollar
FROM master_subscribers;

-- CORRECTO — casteá un operando a tipo decimal para forzar división decimal
SELECT
  SubscriberKey,
  CAST(LoyaltyPoints AS DECIMAL(18,4)) / TotalSpend AS PointsPerDollar
FROM master_subscribers;

-- TAMBIÉN CORRECTO — multiplicá por 1.0 para coerce un operando
SELECT
  SubscriberKey,
  (LoyaltyPoints * 1.0) / TotalSpend AS PointsPerDollar
FROM master_subscribers;

La versión bug compila, corre, y devuelve resultados truncados — generalmente 0 — para cada fila donde el numerador es menor que el denominador. Fácil de mandar si nadie corre el math a mano sobre algunas filas.

`ROUND` con scale negativo redondea a la izquierda del punto decimal

Es un truco útil pero se lee como typo a cualquiera que no lo haya visto. ROUND(1234.567, -2) devuelve 1200 porque -2 significa "redondeá al cien más cercano". ROUND(1234.567, -3) devuelve 1000.

-- Bucketing en cientos para segmentación gruesa
SELECT
  SubscriberKey,
  ROUND(TotalSpend, -2) AS SpendBucket
FROM master_subscribers;
-- Spend 1234 → bucket 1200
-- Spend 1289 → bucket 1300

Documentá la llamada con scale negativo con un comentario cuando la usás. El próximo lector si no va a asumir que es typo.

`DECIMAL` para dinero, nunca `FLOAT`

FLOAT es punto flotante binario. Sumar 0.1 + 0.2 devuelve 0.30000000000000004 — invisible a escala chica, devastador en sumas financieras. Para puntos de loyalty, moneda, o cualquier valor que necesite math exacta, la columna del DE de destino tiene que ser DECIMAL(precision, scale).

-- EN RIESGO — las dos columnas FLOAT, la suma deriva sobre millones de filas
INSERT INTO de_loyalty_summary
SELECT
  SubscriberKey,
  SUM(PurchaseAmount) AS TotalSpend
FROM purchases
GROUP BY SubscriberKey;
-- (donde PurchaseAmount y TotalSpend son FLOAT)

-- DURABLE — columnas DECIMAL en origen Y destino, math exacta
-- Columna del DE de destino: TotalSpend DECIMAL(18, 2)
INSERT INTO de_loyalty_summary
SELECT
  SubscriberKey,
  CAST(SUM(CAST(PurchaseAmount AS DECIMAL(18,2))) AS DECIMAL(18,2)) AS TotalSpend
FROM purchases
GROUP BY SubscriberKey;

Cuando un DE de destino va a guardar valores monetarios, configurá el tipo de columna a DECIMAL(p, s) (comúnmente DECIMAL(18, 2) para moneda a dos decimales) y casteá los inputs para matchear. El costo es un CAST por columna; el ahorro son reportes de reconciliación que matchean con contabilidad.

WATCH OUT

RAND() es no-determinístico — cada llamada devuelve un valor distinto, incluso adentro de la misma query. Si referenciás RAND() más de una vez esperando el mismo valor, cada referencia resuelve por separado:

-- EN RIESGO — tres llamadas a RAND(), tres valores distintos por fila
SELECT
  SubscriberKey,
  RAND() AS r1,
  RAND() AS r2,                                -- distinto de r1
  CASE WHEN RAND() < 0.1 THEN 'sample' END AS InSample  -- distinto de r1 + r2
FROM master_subscribers;

Para sampleo aleatorio que tiene que ser consistente, capturá un solo RAND() por fila en un paso de staging:

-- Stagéa con un RAND por fila
INSERT INTO de_stg_random_subs
SELECT SubscriberKey, RAND() AS RandValue
FROM master_subscribers;

-- Después leé consistentemente
SELECT SubscriberKey
FROM de_stg_random_subs
WHERE RandValue < 0.1;   -- sample exacto del 10%

Envolver una columna numérica en una función en `WHERE` mata el índice

Misma regla que las funciones de string y fecha: envolver la columna misma evita el uso de índice. Aplicá la matemática al lado del literal en su lugar.

-- EN RIESGO — función sobre la columna, full scan
WHERE ABS(LoyaltyDelta) > 50

-- MEJOR — equivalente algebraico, columna pelada en un lado
WHERE LoyaltyDelta > 50 OR LoyaltyDelta < -50

La primera versión es más clara; la segunda corre más rápido en un DE grande. Tradeoff según el tamaño del origen.

Decisión rápida

Casteá a DECIMAL antes de dividir cuando:

Los dos operandos son enteros y necesitás un resultado decimal.
El math alimenta dinero/puntos/porcentajes.

Usá ROUND(n, -k) cuando:

Estás bucketeando valores para segmentación. Documentá con un comentario.

Usá columnas DECIMAL(p, s) en lugar de FLOAT cuando:

El destino guarda dinero, puntos de loyalty, porcentajes, o cualquier valor donde los errores de redondeo importen.

Stagéa RAND() una vez por fila cuando:

El mismo valor random necesita ser referenciado más de una vez.

Mantené las columnas numéricas peladas en WHERE cuando:

El Data Extension tiene más de ~100k filas. Movele el math al lado del literal en su lugar.

Relacionado

Basics — subset de T-SQL soportado
SELECT — funciones numéricas en proyección
WHERE — funciones numéricas en filtros (y la regla de columna pelada)
INSERT INTO — tipos de columna del destino (DECIMAL vs FLOAT para dinero)
Aggregate functions — SUM, AVG, COUNT sobre columnas numéricas
Conversion functions — CAST para coerción de tipo

Próximas páginas de referencia de funciones: Conversion · Aggregate · Null Functions.

Más snippets how-to para debugging común en producción — sends de email, largo de valores, alcance de contactos, etc.