Regras que valem para todos os operadores M

1. Precedência

Da maior para a menor. No mesmo nível, da esquerda para a direita.

Ordem	Categoria	Operadores
1	Primário	`x[campo]`, `x{i}`, `x(...)`, `( )`, `{ }`, `[ ]`, `@`, `...`
2	Unário	`+x`, `-x`, `not x`
3	Metadados	`meta`
4	Multiplicativo	`*`, `/`
5	Aditivo	`+`, `-`, `&`
6	Relacional	`<`, `>`, `<=`, `>=`
7	Igualdade	`=`, `<>`
8	Afirmação de tipo	`as`
9	Teste de tipo	`is`
10	E lógico	`and`
11	OU lógico	`or`
12	Coalescência	`??`

1 + 2 * 3      // 7
(1 + 2) * 3    // 9

2. Sem conversão implícita

Diferente do DAX e do Excel, o M não converte tipos nos operadores:

1 + "2"               // erro
"Lote " & 5           // erro
"Lote " & Text.From(5)   // "Lote 5"
1 = "1"               // false (tipos diferentes nunca são iguais)
true = 1              // false

Converta explicitamente com Number.From, Text.From, Date.From e similares, ou defina o tipo da coluna antes da conta.

3. `null` nas contas e nas comparações

6 * null           // null
"Lote " & null     // null
null = null        // true
null < 1           // null (não false!)
[Desconto] ?? 0    // troca null por 0

Uma coluna com null contamina a conta inteira: trate com ?? ou com Substituir valores antes de calcular.

Atenção Table.SelectRows(Vendas, each [Valor] > 100) descarta as linhas com [Valor] nulo, porque null > 100 é null, não true.

and e or com null (linha = lado esquerdo, coluna = lado direito):

`and`	`true`	`false`	`null`
`true`	`true`	`false`	`null`
`false`	`false`	`false`	`false`
`null`	`null`	`false`	`null`

`or`	`true`	`false`	`null`
`true`	`true`	`true`	`true`
`false`	`true`	`false`	`null`
`null`	`true`	`null`	`null`

and e or só aceitam lógico ou null; qualquer outro tipo dá erro.

3.1 Comparações de texto e de estruturas

"a" = "A"                              // false: diferencia maiúsculas
"B" < "a"                              // true: ordem ordinal, sem cultura
Text.Lower([Nome]) = "ana"             // compare sem diferenciar maiúsculas
[A = 1, B = 2] = [B = 2, A = 1]        // true: ordem dos campos não importa
{1, 2} = {2, 1}                        // false: ordem dos itens importa
#nan = #nan                            // false

<, >, <= e >= exigem os dois lados do mesmo tipo; comparar número com texto dá erro.

4. Precisão

Os operadores + - * / usam precisão Double (ponto flutuante). Para precisão decimal de 128 bits, use as funções com Precision.Decimal:

Value.Add([Valor], [Frete], Precision.Decimal)
Value.Multiply([Qtd], [Preço], Precision.Decimal)

Divisão por zero não dá erro: 1 / 0 devolve #infinity e 0 / 0 devolve #nan.

5. Contas com data e hora

Conta	Resultado
data/hora + duração	data/hora deslocada
data/hora − duração	data/hora deslocada para trás
data/hora − data/hora	duração entre as duas
duração + duração	duração
duração Não número	duração multiplicada
duração ÷ número	fração da duração
data `&` hora	data/hora combinada

#date(2026, 12, 31) - #date(2026, 1, 1)             // #duration(364, 0, 0, 0)
Duration.Days(#date(2026, 12, 31) - #date(2026, 1, 1))   // 364
#date(2026, 9, 24) & #time(14, 30, 0)               // #datetime(2026, 9, 24, 14, 30, 0)

6. `&` em listas e registros

{1} & {2, 3}             // {1, 2, 3}
[a = 1] & [b = 2]        // [a = 1, b = 2]
[x = 1, y = 2] & [x = 3]  // [x = 3, y = 2]: o campo da direita vence

Tabelas também se concatenam com &: as colunas que só existem de um lado vêm com null do outro.

7. Buscar uma linha pela chave

Clientes{[Código = 42]}           // a linha inteira, como registro
Clientes{[Código = 42]}[Nome]     // só o nome
Clientes{[Código = 99]}?          // null se não existir

Se mais de uma linha tiver o valor, dá erro — mesmo com ?.