Caracteres de escape - MaxCompute: Central de Documentação do Alibaba Cloud

O MaxCompute usa a barra invertida (\) como caractere de escape em literais de string SQL, expressões regulares e JSON. Ao trabalhar nesses contextos, muitas vezes você precisa aplicar múltiplas camadas de escape, o que dificulta a leitura das strings. Este tópico aborda as sequências de escape para cada contexto e mostra como lidar corretamente com escapes aninhados.

Nem todas as especificações usam \ como caractere de escape. Por exemplo, URLs usam o sinal de porcentagem % , e XML usa o "e" comercial & .

Se sua string contiver muitas barras invertidas, use a sintaxe de literal de string bruta R"()" para ignorar completamente o escape. Consulte Literais de string bruta .

Sequências de escape SQL

No SQL do MaxCompute, os literais de string são delimitados por aspas simples ou duplas — 'abc' ou "abc". Se a string contiver um tipo de aspa, delimite-a com o outro:

"I'm a happy developer."      -- single quote inside double-quoted string
'She said "hello".'           -- double quote inside single-quoted string

Se a string contiver ambos os tipos de aspas ou caracteres invisíveis, como quebras de linha, use sequências de escape. A tabela a seguir lista todas as sequências de escape compatíveis.

Sequência de escape	Descrição
`\b`	Backspace
`\t`	Tabulação
`\n`	Line feed (nova linha)
`\r`	Retorno de carro
`\'`	Aspa simples
`\"`	Aspa dupla
`\\`	Barra invertida
`\;`	Ponto e vírgula
`\Z`	Ctrl-Z
`\0` ou `\00`	Terminador nulo
`\<other>`	O próprio caractere — a barra invertida é removida. Por exemplo, `\a` equivale a `a`.

Exemplo: Represente uma string que contém ambos os tipos de aspas e uma quebra de linha:

-- Using single-quoted string:
'Double quotation mark(")\nSingle quotation mark(\')'

-- Using double-quoted string:
"Double quotation mark(\")\nSingle quotation mark(')"

Correspondência de padrões LIKE

Ao usar LIKE para corresponder a um caractere literal % ou _, faça o escape do caractere com \:

SELECT 'ab_cde' LIKE 'ab\_c%';

-- Result:
true

Sequências de escape em expressões regulares

O MaxCompute usa o mecanismo de regex RE2. Em um padrão de expressão regular, \ introduz atalhos de classes de caracteres para categorias comuns:

Sequência de escape	Descrição
`\d`	Dígito — equivalente a `[0-9]`
`\D`	Não dígito — equivalente a `[^0-9]`
`\s`	Caractere de espaço em branco — equivalente a `[\t\n\f\r ]`
`\S`	Caractere que não seja espaço em branco — equivalente a `[^\t\n\f\r ]`
`\w`	Caractere alfanumérico — equivalente a `[0-9A-Za-z_]`
`\W`	Caractere não alfanumérico — equivalente a `[^0-9A-Za-z_]`

Use o regexr ou o regex101 para criar e testar expressões regulares interativamente.

Sequências de escape JSON

O JSON usa a barra invertida como caractere de escape. A especificação JSON define as seguintes sequências de escape:

Sequência de escape	Descrição
`\"`	Aspa dupla
`\\`	Barra invertida
`\/`	Barra normal
`\b`	Backspace
`\f`	Form feed
`\n`	Line feed
`\r`	Retorno de carro
`\t`	Tabulação horizontal
`\u` + hex de 4 dígitos	Caractere Unicode

Use o JSONLint para validar strings JSON.

Exemplos

Caracteres especiais em strings SQL

\t conta como um único caractere:

SELECT LENGTH('a\tb');

-- Result:
3

Como \a não é uma sequência de escape reconhecida, a barra invertida é removida e \a torna-se a:

SELECT 'a\ab', LENGTH('a\ab');

-- Result:
aab, 3

Escape Regex + SQL

Para extrair 010 de 010-12345678 usando uma expressão regular:

Escreva a regex: (\d+)-
Faça o escape da barra invertida para SQL: (\\d+)-
Delimite com aspas simples: '(\\d+)-'

SELECT REGEXP_EXTRACT('010-12345678', '(\\d+)-');

-- Result:
010

Escape JSON + SQL

A string JSON {"key":"this is very \"important\"."} contém sequências de escape SQL (\"). Ao passá-la diretamente para get_json_object, o parser SQL consome as barras invertidas primeiro e transforma \" em ". A string resultante deixa de ser um JSON válido, então a função retorna NULL:

SET odps.sql.udf.getjsonobj.new=true;
SELECT get_json_object('{"key":"this is very \"important\"."}', '$.key');

-- Result:
NULL

Verifique o que o parser SQL realmente vê:

SELECT '{"key":"this is very \"important\"."}';

-- Result:
{"key":"this is very "important"."}

As barras invertidas desapareceram. Para passar uma string JSON válida pelo SQL, faça o escape duplo das barras invertidas (\" → \\"):

SET odps.sql.udf.getjsonobj.new=true;
SELECT get_json_object('{"key":"this is very \\"important\\"."}', '$.key');

-- Result:
this is very "important".

Escape JSON + regex + SQL

Para corresponder a important na string JSON {"key":"this is very \"important\"."} usando uma expressão regular:

Escreva a regex para corresponder à palavra entre aspas: \"(.*)\"
Faça o escape das barras invertidas para o mecanismo de regex: \\"(.*)\\"
Faça o escape das barras invertidas novamente para SQL: '\\\\"(.*)\\\\"'

SELECT REGEXP_EXTRACT('{"key":"this is very \\"important\\"."}', '\\\\"(.*)\\\\"');

-- Result:
important

Quando o aninhamento for tão profundo, analise o JSON primeiro e depois aplique a regex. Assim, a expressão permanece legível:

SET odps.sql.udf.getjsonobj.new=true;
SELECT REGEXP_EXTRACT(
  get_json_object('{"key":"this is very \\"important\\"."}', '$.key'),
  '"(.*)"'
);

-- Result:
important

Para entender exatamente a que '\\\\"(.*)\\\\"' corresponde, execute-o via SELECT:

SELECT '\\\\"(.*)\\\\"';

-- Result:
\\"(.*)\\"

Literais de string bruta

Ao combinar SQL, JSON e expressões regulares, as barras invertidas se multiplicam rapidamente. A sintaxe R"()" permite escrever a string literal exatamente como ela aparece, sem necessidade de escape de barra invertida dentro dos parênteses.

A tabela a seguir mostra como os literais de string bruta reduzem o excesso de barras invertidas:

String regular	Literal de string bruta
`'abc'`	`R"(abc)"`
`'\\\\"(.*)\\\\"'`	`R'(\\"(.*)\\")'`

Notas sobre a sintaxe:

R não diferencia maiúsculas de minúsculas — r"()" funciona igualmente bem.
Tanto aspas simples quanto duplas são válidas: R"()" ou R'()'.
Apenas os delimitadores mudam; o conteúdo dentro dos parênteses é interpretado literalmente.

O exemplo de JSON + regex da seção anterior fica muito mais limpo com literais de string bruta:

SELECT REGEXP_EXTRACT(R'({"key":"this is very \"important\"."})', R'(\\"(.*)\\")');

-- Result:
important