Power Query (M)

Operadores M

Operadores da linguagem Power Query M com exemplo, precedência, ausência de conversão implícita, null nas contas e contas com datas.

31 operadores

Aritmético

+
Soma números. Também soma duração a data, hora ou data/hora. Não converte texto em número: 1 + "2" dá erro.
Exemplo: #time(12, 23, 0) + #duration(0, 0, 2, 0) // #time(12, 25, 0)
-
Subtrai números ou duração de data. Data menos data devolve uma duração.
Exemplo: #date(2026, 12, 31) - #date(2026, 1, 1) // #duration(364, 0, 0, 0)
*
Multiplica números, ou uma duração por um número. Com null, devolve null.
Exemplo: [Qtd] * [Preço Unitário]
/
Divide números, ou uma duração por um número. Divisão por zero não dá erro: devolve #infinity ou #nan.
Exemplo: [Valor] / 1000
+x
Mais unário: devolve o próprio número.
Exemplo: +5
-x
Inverte o sinal de um número ou de uma duração.
Exemplo: -[Desconto]

Combinação

&
Concatena textos, listas e tabelas; mescla registros; combina data com hora em data/hora. Com null de um lado, o texto resultante é null. Na mescla de registros, o campo da direita vence. Número não vira texto sozinho: use Text.From.
Exemplo: [x = 1, y = 2] & [x = 3, z = 4] // [x = 3, y = 2, z = 4]

Comparação

=
Igual. Valores de tipos diferentes nunca são iguais (1 = "1" e true = 1 são false). Texto diferencia maiúsculas: "a" = "A" é false. null = null é true e #nan = #nan é false. Registros comparam campos pelo nome (a ordem não importa); listas comparam item a item, na ordem.
Exemplo: [A = 1, B = 2] = [B = 2, A = 1] // true
<>
Diferente. É sempre o contrário de =.
Exemplo: [Status] <> "Cancelado"
<
Menor que. Os dois lados precisam ser do mesmo tipo (número, texto, data, hora, duração, lógico ou binário), senão dá erro. Com null em qualquer lado, o resultado é null, não false. Texto é comparado caractere a caractere, diferenciando maiúsculas e sem cultura.
Exemplo: null < 1 // null
>
Maior que. Mesmas regras do <: tipos iguais, null devolve null, #nan devolve false. Em lógico, true é maior que false.
Exemplo: [Valor] > 1000
<=
Menor ou igual. Mesmas regras do <.
Exemplo: [Idade] <= 17
>=
Maior ou igual. Mesmas regras do <.
Exemplo: [Nota] >= 7

Lógico

and
E lógico com curto-circuito: se a esquerda é false, a direita não é avaliada. Aceita só lógico ou null: false and null = false, true and null = null. Outro tipo dá erro.
Exemplo: [Qtd] <> 0 and [Valor] / [Qtd] > 10
or
OU lógico com curto-circuito: se a esquerda é true, a direita não é avaliada. Aceita só lógico ou null: true or null = true, false or null = null. Outro tipo dá erro.
Exemplo: [UF] = "SP" or [UF] = "RJ"
not
Negação lógica.
Exemplo: not [Cancelado]

Nulo

??
Coalescência: devolve o lado esquerdo, ou o direito quando o esquerdo é null.
Exemplo: [Desconto] ?? 0

Acesso

x[campo]
Lê um campo de registro (ou a coluna da linha atual, dentro de each). Campo inexistente dá erro.
Exemplo: [Cliente = "Ana", UF = "SP"][UF] // "SP"
x[campo]?
Leitura opcional: devolve null se o campo não existir.
Exemplo: Registro[Telefone]?
x[[a], [b]]
Projeção: devolve um registro (ou tabela) só com os campos listados. A forma com ? usa null nos campos ausentes.
Exemplo: [A = 1, B = 2, C = 3][[A], [C]] // [A = 1, C = 3]
x{i}
Lê o item de uma lista pela posição, começando em 0. Numa tabela, {i} devolve a linha como registro. Posição inexistente ou negativa dá erro.
Exemplo: {"a", "b", "c"}{1} // "b"
x{i}?
Leitura opcional de item: devolve null se a posição (ou a linha buscada) não existir.
Exemplo: Lista{10}?
tabela{[Coluna = valor]}
Busca numa tabela a linha cujas colunas têm os valores do registro e devolve a linha como registro. Nenhuma linha dá erro (com ?, devolve null); mais de uma linha dá erro mesmo com ?.
Exemplo: Clientes{[Código = 42]}[Nome]
Seção!Membro
Acessa um membro compartilhado de uma seção. Aparece em conectores personalizados; consultas comuns não usam seções.
Exemplo: Utilitarios!Dobro(5)

Tipo

is
Testa se o valor é compatível com um tipo primitivo.
Exemplo: [Valor] is number
as
Afirma o tipo; dá erro se o valor não for compatível.
Exemplo: [Valor] as number

Metadados

meta
Anexa um registro de metadados a um valor.
Exemplo: "Mozart" meta [Nota = 5]

Função

=>
Define uma função: parâmetros à esquerda, corpo à direita.
Exemplo: (x, y) => x + y
@
Referência inclusiva: permite que uma função chame a si mesma (recursão).
Exemplo: fatorial = (n) => if n = 0 then 1 else n * @fatorial(n - 1)

Lista

..
Intervalo dentro de uma lista.
Exemplo: {1..5} // {1, 2, 3, 4, 5}

Erro

...
"Não implementado": atalho que gera erro. Útil para esboçar código.
Exemplo: (x, y) => if x > y then x - y else ...

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.

⚠️ 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ú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 ?.