Partilhar via

Capitalização no Power Query M

Trabalhar com dados de texto às vezes pode ser confuso. Por exemplo, o nome da cidade de Redmond pode ser representado em um banco de dados usando diferentes invólucros ("Redmond", "redmond" e "REDMOND"). Isso pode causar um problema ao transformar os dados no Power Query porque a linguagem de fórmula do Power Query M é sensível a maiúsculas e minúsculas.

Felizmente, o Power Query M fornece funções para limpar e normalizar o caso de dados de texto. Existem funções para converter texto em minúsculas (abc), maiúsculas (ABC) ou capitalização correta (Abc). Além disso, o Power Query M também fornece várias maneiras de ignorar a distinção entre maiúsculas e minúsculas.

Este artigo mostra como alterar a capitalização de palavras em texto, listas e tabelas. Ele também descreve várias maneiras de ignorar maiúsculas e minúsculas ao manipular dados em texto, listas e tabelas. Além disso, este artigo discute como classificar de acordo com o caso.

Alterar maiúsculas e minúsculas no texto

Existem três funções que convertem texto em minúsculas, maiúsculas e capitalização inicial. As funções são Text.Lower, Text.Uppere Text.Proper. Os exemplos simples a seguir demonstram como essas funções podem ser usadas em texto.

Converter todos os caracteres do texto em minúsculas

O exemplo a seguir demonstra como converter todos os caracteres de uma string em minúsculas.

let
    Source = Text.Lower("The quick brown fox jumps over the lazy dog.")
in
    Source

Este código produz a seguinte saída:

the quick brown fox jumps over the lazy dog.

Converter todos os caracteres do texto em maiúsculas

O exemplo a seguir demonstra como converter todos os caracteres em uma cadeia de texto em maiúsculas.

let
    Source = Text.Upper("The quick brown fox jumps over the lazy dog.")
in
    Source

Este código produz a seguinte saída:

THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG.

Converter todas as palavras em maiúsculas iniciais

O exemplo a seguir demonstra como converter todas as palavras da frase em maiúsculas iniciais.

let
    Source = Text.Proper("The quick brown fox jumps over the lazy dog.")
in
    Source

Este código produz a seguinte saída:

The Quick Brown Fox Jumps Over The Lazy Dog.

Alterar maiúsculas e minúsculas em listas

Ao alterar maiúsculas e minúsculas em listas, a função mais comum a ser usada é List.Transform. Os exemplos simples a seguir demonstram como essa função pode ser usada em listas.

Converter todos os itens em minúsculas

O exemplo a seguir mostra como alterar todos os itens de uma lista para minúsculas.

let
    Source = {"Squash", "Pumpkin", "ApPlE", "pear", "orange", "APPLE", "Pear", "pear"},
    #"Lower Case" = List.Transform(Source, Text.Lower)
in
    #"Lower Case"

Este código produz a seguinte saída:

Captura de tela da lista criada pela função de transformação de lista que produz resultados em minúsculas.

Converta todos os itens em letras maiúsculas

O exemplo a seguir demonstra como alterar todos os itens em uma lista para maiúsculas.

let
    Source = {"Squash", "Pumpkin", "ApPlE", "pear", "orange", "APPLE", "Pear", "pear"},
    #"Upper Case" = List.Transform(Source, Text.Upper)
in
    #"Upper Case"

Este código produz a seguinte saída:

Captura de ecrã da lista criada pela função de transformação de lista que produz resultados em maiúsculas.

Converta todos os itens para maiúsculas iniciais

O exemplo a seguir demonstra como alterar todos os itens em uma lista para maiúsculas iniciais.

let
    Source = {"Squash", "Pumpkin", "ApPlE", "pear", "orange", "APPLE", "Pear", "pear"},
    #"Proper Case" = List.Transform(Source, Text.Proper)
in
    #"Proper Case"

Este código produz a seguinte saída:

Captura de ecrã da lista criada pela função de transformação de lista que produz resultados com maiúscula inicial.

Alterar maiúsculas e minúsculas em tabelas

Ao alterar maiúsculas e minúsculas em tabelas, a função mais frequentemente utilizada é Table.TransformColumns. Há também uma função que pode utilizar para alterar o caso do texto contido em uma fila, chamada Table.TransformRows. No entanto, esta função não é usada com tanta frequência.

Os exemplos simples a seguir demonstram como a Table.TransformColumns função pode ser usada para alterar o caso em tabelas.

Converter todos os itens de uma coluna da tabela em minúsculas

O exemplo a seguir demonstra como alterar todos os itens em uma coluna de tabela para minúsculas, neste caso, os nomes de clientes.

let
    Source = #table(type table [CUSTOMER = text, FRUIT = text],
    {
        {"Tulga", "Squash"}, 
        {"suSanna", "Pumpkin"}, 
        {"LESLIE", "ApPlE"}, 
        {"Willis", "pear"}, 
        {"Dilbar", "orange"}, 
        {"ClaudiA", "APPLE"}, 
        {"afonso", "Pear"}, 
        {"SErgio", "pear"}
    }),
    #"Lower Case" = Table.TransformColumns(Source, {"CUSTOMER", Text.Lower})
in
    #"Lower Case"

Este código produz a seguinte saída:

Captura de ecrã da tabela criada pela função de transformação de colunas da tabela que produz resultados em minúsculas.

Converter todos os itens de uma coluna da tabela em maiúsculas

O exemplo a seguir demonstra como alterar todos os itens numa coluna da tabela para maiúsculas, neste caso, os nomes de frutas.

let
    Source = #table(type table [CUSTOMER = text, FRUIT = text], 
    {
        {"Tulga", "Squash"}, 
        {"suSanna", "Pumpkin"}, 
        {"LESLIE", "ApPlE"}, 
        {"Willis", "pear"}, 
        {"Dilbar", "orange"}, 
        {"ClaudiA", "APPLE"}, 
        {"afonso", "Pear"}, 
        {"SErgio", "pear"}
    }),
    #"Upper Case" = Table.TransformColumns(Source, {"FRUIT", Text.Upper})
in
    #"Upper Case"

Este código produz a seguinte saída:

Captura de ecrã da tabela criada pela função de transformação de colunas da tabela que produz resultados em maiúsculas.

Converter todos os itens de uma tabela para a primeira letra maiúscula

O exemplo a seguir demonstra como alterar todos os itens em ambas as colunas da tabela para a forma correta, com a primeira letra de cada palavra em maiúscula.

let
    Source = #table(type table [CUSTOMER = text, FRUIT = text], 
    {
        {"Tulga", "Squash"}, 
        {"suSanna", "Pumpkin"}, 
        {"LESLIE", "ApPlE"}, 
        {"Willis", "pear"}, 
        {"Dilbar", "orange"}, 
        {"ClaudiA", "APPLE"}, 
        {"afonso", "Pear"}, 
        {"SErgio", "pear"}
    }),
    #"Customer Case" = Table.TransformColumns(Source, {"CUSTOMER", Text.Proper}),
    #"Proper Case" = Table.TransformColumns(#"Customer Case", {"FRUIT", Text.Proper})
in
    #"Proper Case"

Este código produz a seguinte saída:

Captura da tabela criada pela função de transformação de colunas da tabela que produz resultados de maiúsculas e minúsculas adequados em ambas as colunas.

Ignorando o caso

Em muitos casos, ao pesquisar ou substituir itens, talvez seja necessário ignorar o caso do item que está procurando. Como a linguagem de fórmula do Power Query M diferencia maiúsculas de minúsculas, as comparações entre itens que são idênticos mas têm diferenças de maiúsculas e minúsculas resultam na identificação dos itens como diferentes, não idênticos. Um método para ignorar maiúsculas e minúsculas envolve a utilização da Comparer.OrdinalIgnoreCase função em funções que incluem um parâmetro equationCriteria ou um parâmetro comparer. Outro método de ignorar maiúsculas e minúsculas envolve o uso da IgnoreCase opção (se disponível) em funções que incluem um options parâmetro.

Ignorando caso no texto

Às vezes, ao procurar texto, é necessário ignorar maiúsculas e minúsculas para encontrar todas as ocorrências do texto pesquisado. As funções de texto geralmente usam a função Comparer.OrdinalIgnoreCase no parâmetro comparer para ignorar maiúsculas e minúsculas ao testar a igualdade.

O exemplo a seguir mostra como ignorar maiúsculas e minúsculas ao determinar se uma frase contém uma palavra específica, independentemente de maiúsculas e minúsculas.

let
    Source = Text.Contains(
        "The rain in spain falls mainly on the plain.", 
        "Spain", 
        Comparer.OrdinalIgnoreCase
    )
in
    Source

Este código produz a seguinte saída:

true

O exemplo a seguir mostra como recuperar a posição inicial da última ocorrência da palavra "o" na frase, independentemente do caso.

let
    Source = Text.PositionOf(
        "THE RAIN IN SPAIN FALLS MAINLY ON THE PLAIN.", 
        "the", 
        Occurrence.Last, 
        Comparer.OrdinalIgnoreCase
    )
in
    Source

Este código produz a seguinte saída:

34

Ignorando casos em listas

Qualquer função de lista que contenha um parâmetro opcional equationCriteria pode usar a função Comparer.OrdinalIgnoreCase para ignorar diferenças de maiúsculas e minúsculas na lista.

O exemplo a seguir verifica se uma lista contém um item específico, ignorando maiúsculas e minúsculas. Neste exemplo, List.Contains só pode comparar um item na lista, não pode comparar uma lista com uma lista. Para isso, você precisa usar List.ContainsAny.

let
    Source = List.Contains(
        {"Squash", "Pumpkin", "ApPlE", "pear", "orange", "APPLE", "Pear", "pear"},
        "apple",
        Comparer.OrdinalIgnoreCase
    )
in
    Source

Este código produz a seguinte saída:

true

Os exemplos a seguir verificam se uma lista contém todos os itens especificados no segundo parâmetro (value), ignorando maiúsculas ou minúsculas. Se algum item não estiver contido na lista, como cucumber no segundo exemplo, a função retornará FALSE.

let
    Source = List.ContainsAll(
        {"Squash", "Pumpkin", "ApPlE", "pear", "orange", "APPLE", "Pear", "pear"},
        {"apple", "pear", "squash", "pumpkin"},
        Comparer.OrdinalIgnoreCase
    )
in
    Source

Este código produz a seguinte saída:

true

let
    Source = List.ContainsAll(
        {"Squash", "Pumpkin", "ApPlE", "pear", "orange", "APPLE", "Pear", "pear"},
        {"apple", "pear", "squash", "pumpkin", "cucumber"},
        Comparer.OrdinalIgnoreCase
    )
in
    Source

Este código produz a seguinte saída:

false

O exemplo a seguir verifica se algum dos itens na lista são maçãs ou peras, ignorando maiúsculas e minúsculas.

let
    Source = List.ContainsAny(
        {"Squash", "Pumpkin", "ApPlE", "PEAR", "orange", "APPLE", "Pear", "peaR"},
        {"apple","pear"},
        Comparer.OrdinalIgnoreCase
    )
in
    Source

Este código produz a seguinte saída:

true

O exemplo a seguir mantém apenas itens exclusivos, ignorando maiúsculas e minúsculas.

let
    Source = List.Distinct(
        {"Squash", "Pumpkin", "ApPlE", "PEAR", "orange", "APPLE", "Pear", "peaR"},
        Comparer.OrdinalIgnoreCase
    )
in
    Source

Este código produz a seguinte saída:

Captura de ecrã da lista criada pela função 'lista distinta', ignorando maiúsculas e minúsculas.

No exemplo anterior, a saída exibe o caso do primeiro item exclusivo encontrado na lista. Assim, embora existam duas maçãs (ApPlE e APPLE), apenas o primeiro exemplo encontrado é exibido.

O exemplo a seguir mantém apenas itens exclusivos sem considerar maiúsculas e minúsculas, mas também retorna todos os resultados em minúsculas.

let
    Source = List.Distinct(
        {"Squash", "Pumpkin", "ApPlE", "PEAR", "orange", "APPLE", "Pear", "peaR"},
        Comparer.OrdinalIgnoreCase
    ),
    #"Lower Case" = List.Transform(Source, Text.Lower)
in
    #"Lower Case"

Este código produz a seguinte saída:

Captura de tela da lista criada pela função distinta da lista, ignorando maiúsculas e minúsculas, mas também emitindo minúsculas.

Ignorando caso em tabelas

As tabelas têm várias maneiras de ignorar a diferença entre maiúsculas e minúsculas. Funções de tabela como Table.Contains, Table.Distincte Table.PositionOf todas contêm equationCriteria parâmetros. Esses parâmetros podem usar a função Comparer.OrdinalIgnoreCase para ignorar diferenças de maiúsculas e minúsculas em tabelas, da mesma forma que as listas nas seções anteriores. As funções de tabela, como Table.MatchesAnyRows que contêm um parâmetro condition, também podem usar Comparer.OrdinalIgnoreCase encapsuladas em outras funções de tabela para ignorar maiúsculas e minúsculas. Outras funções de tabela, especificamente para correspondência difusa, podem usar a IgnoreCase opção.

O exemplo a seguir demonstra como selecionar linhas específicas que contêm a palavra "pera" ignorando maiúsculas e minúsculas. Este exemplo usa o parâmetro condition de Table.SelectRows com Text.Contains como condicional para fazer as comparações ignorando maiúsculas e minúsculas.

let
    Source = #table(type table[CUSTOMER = text, FRUIT = text],
    {
        {"Tulga", "Squash"}, 
        {"suSanna", "Pumpkin"}, 
        {"LESLIE", "ApPlE"}, 
        {"Willis", "pear"}, 
        {"Dilbar", "orange"}, 
        {"ClaudiA", "APPLE"}, 
        {"afonso", "Pear"}, 
        {"SErgio", "pear"}
    }),
    #"Select Rows" = Table.SelectRows(
        Source, each Text.Contains([FRUIT], "pear", Comparer.OrdinalIgnoreCase))
in
    #"Select Rows"

Este código produz a seguinte saída:

Captura de tela da tabela criada pela função de seleção de linhas da tabela ignorando maiúsculas e minúsculas.

O exemplo a seguir mostra como determinar se alguma das linhas de uma tabela contém um pear na FRUIT coluna. Este exemplo usa Comparer.OrdinalIgnoreCase numa função Text.Contains utilizando o parâmetro condition da função Table.MatchesAnyRows.

let
    Source = #table(type table [CUSTOMER = text, FRUIT = text], 
    {
        {"Tulga", "Squash"}, 
        {"suSanna", "Pumpkin"}, 
        {"LESLIE", "ApPlE"}, 
        {"Willis", "PEAR"}, 
        {"Dilbar", "orange"}, 
        {"ClaudiA", "APPLE"}, 
        {"afonso", "Pear"}, 
        {"SErgio", "peAR"}
        }),
    #"Select Rows" = Table.MatchesAnyRows(Source,
        each Text.Contains([FRUIT], "pear", Comparer.OrdinalIgnoreCase))
in
    #"Select Rows"

Este código produz a seguinte saída:

true

O exemplo a seguir demonstra como pegar uma tabela com valores inseridos por usuários que contém uma coluna listando suas frutas favoritas, usando nenhum formato definido. Esta coluna é primeiro comparada utilizando correspondência difusa para extrair os nomes das suas frutas favoritas, que são então exibidos na sua própria coluna, chamada Cluster. Em seguida, a coluna Cluster é examinada para determinar os diferentes frutos distintos que estão na coluna. Uma vez que os frutos únicos são determinados, um passo final é mudar todos os nomes dos frutos para minúsculas.

let
    // Load a table of user's favorite fruits into Source
    Source = #table(type table [Fruit = text], {{"blueberries"}, 
        {"Blue berries are simply the best"}, {"strawberries"}, {"Strawberries = <3"}, 
        {"Apples"}, {"'sples"}, {"4ppl3s"}, {"Bananas"}, {"fav fruit is bananas"}, 
        {"Banas"}, {"My favorite fruit, by far, is Apples. I simply love them!"}}
    ),
    // Create a Cluster column and fuzzy match the fruits into that column
    #"Cluster fuzzy match" = Table.AddFuzzyClusterColumn(
        Source, "Fruit", "Cluster", 
        [IgnoreCase = true, IgnoreSpace = true, Threshold = 0.5]
    ),
    // Find the distinct fruits from the Cluster column
    #"Ignore cluster case" = Table.Distinct(
        Table.SelectColumns(#"Cluster fuzzy match", "Cluster"), 
        Comparer.OrdinalIgnoreCase
    ),
    // Set all of the distinct fruit names to lower case
    #"Set lower case" = Table.TransformColumns(#"Ignore cluster case",
        {"Cluster", Text.Lower}
    )
in
    #"Set lower case"

Este código produz a seguinte saída:

Captura de tela da tabela criada pela correspondência difusa ignorando maiúsculas e minúsculas.

Caso e ordenação

Listas e tabelas podem ser classificadas usando um List.Sort ou Table.Sort, respectivamente. No entanto, a classificação do texto depende do caso dos itens associados na lista ou tabela para determinar a ordem de classificação real (crescente ou decrescente).

A forma mais comum de classificação usa texto que está todo em minúsculas, todo em maiúsculas, ou capitalizado como em títulos. Se houver uma mistura desses casos, a ordem de classificação crescente é a seguinte:

  1. Qualquer texto na coluna da lista ou tabela que comece com uma letra maiúscula é o primeiro.
  2. Se houver texto correspondente, mas um for em maiúsculas e outro em maiúsculas, a versão em maiúsculas será a primeira.
  3. As letras minúsculas são então classificadas.

Por ordem decrescente, as etapas listadas anteriormente são processadas no sentido inverso.

Por exemplo, o exemplo a seguir tem uma mistura de texto todo em minúsculas, todo em maiúsculas e com capitalização própria, a serem classificados em ordem crescente.

let
    Source = { "Alpha", "Beta", "Zulu", "ALPHA", "gamma", "alpha", 
        "beta", "Gamma", "Sierra", "zulu", "GAMMA", "ZULU" },
    SortedList = List.Sort(Source, Order.Ascending)
in
    SortedList

Este código produz a seguinte saída:

Captura de ecrã da lista criada ordenando texto com todas as letras minúsculas, maiúsculas e maiúsculas.

Embora não seja comum, você pode ter uma mistura de letras maiúsculas e minúsculas no texto para classificar. A ordem de classificação crescente neste caso é:

  1. Qualquer texto na coluna da lista ou tabela que comece com uma letra maiúscula é o primeiro.
  2. Se houver texto correspondente, o texto com o número máximo de letras maiúsculas à esquerda é processado a seguir.
  3. As letras minúsculas são então ordenadas, com o maior número de letras maiúsculas deslocadas para a direita primeiro.

Em qualquer caso, pode ser mais conveniente converter o texto em um caso consistente antes de classificar.

Normalização do Power BI Desktop

O Power Query M é sensível a maiúsculas e minúsculas e distingue entre diferentes capitalizações do mesmo texto. Por exemplo, "Foo", "foo" e "FOO" são tratados como diferentes. No entanto, quando os dados são carregados no Power BI Desktop, os valores de texto são normalizados, o que significa que o Power BI Desktop os trata como o mesmo valor, independentemente de suas maiúsculas. Portanto, se você precisar transformar dados enquanto mantém a diferenciação de maiúsculas e minúsculas em seus dados, deverá manipular a transformação de dados no Power Query antes de carregar os dados no Power BI Desktop.

Por exemplo, a tabela seguinte no Power Query mostra casos diferentes em cada linha da tabela.

Captura de tela de uma tabela contendo o texto foo e too com diferentes formatos.

Quando esta tabela é carregada no Power BI Desktop, os valores de texto tornam-se normalizados, resultando na tabela seguinte.

Captura de ecrã da mesma tabela carregada no Power BI Desktop, com a capitalização de cada palavra normalizada.

A primeira instância de "foo" e a primeira instância de "too" determinam o caso de "foo" e "too" no restante das linhas na tabela do Power BI Desktop. Neste exemplo, todas as instâncias de "foo" são normalizadas para o valor "Foo" e todas as instâncias de "too" são normalizadas para o valor "TOO".