Escape characters - MaxCompute - Centre de documentation Alibaba Cloud

MaxCompute utilise l'antislash (\) comme caractère d'échappement dans les littéraux de chaîne SQL, les expressions régulières et le format JSON. La manipulation de ces différents contextes impose souvent plusieurs niveaux d'échappement, ce qui peut nuire à la lisibilité des chaînes. Cette rubrique présente les séquences d'échappement propres à chaque contexte et explique comment gérer correctement leur imbrication.

Toutes les spécifications n'utilisent pas \ comme caractère d'échappement. Par exemple, les URL utilisent le signe pourcentage % , et XML utilise l'esperluette & .

Si votre chaîne contient de nombreux antislashs, utilisez la syntaxe de littéral de chaîne brute R"()" pour éviter tout échappement. Consultez la section Littéraux de chaîne brute .

Séquences d'échappement SQL

Dans MaxCompute SQL, les littéraux de chaîne sont délimités par des guillemets simples ou doubles — 'abc' ou "abc". Si la chaîne contient un type de guillemet, délimitez-la avec l'autre :

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

Si la chaîne contient les deux types de guillemets ou des caractères invisibles tels que des sauts de ligne, utilisez des séquences d'échappement. Le tableau suivant répertorie toutes les séquences prises en charge.

Séquence d'échappement	Description
`\b`	Retour arrière
`\t`	Tabulation
`\n`	Saut de ligne (nouvelle ligne)
`\r`	Retour chariot
`\'`	Apostrophe
`\"`	Guillemet double
`\\`	Antislash
`\;`	Point-virgule
`\Z`	Ctrl-Z
`\0` ou `\00`	Caractère nul de fin
`\<autre>`	Le caractère lui-même : l'antislash est supprimé. Par exemple, `\a` équivaut à `a`.

Exemple : Représentation d'une chaîne contenant les deux types de guillemets et un saut de ligne :

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

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

Correspondance de modèle LIKE

Pour rechercher un littéral % ou _ avec LIKE, échappez le caractère à l'aide de \ :

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

-- Result:
true

Séquences d'échappement d'expressions régulières

MaxCompute utilise le moteur d'expressions régulières RE2. Dans un motif d'expression régulière, \ introduit des raccourcis de classe de caractères pour les catégories courantes :

Séquence d'échappement	Description
`\d`	Chiffre — équivaut à `[0-9]`
`\D`	Non-chiffre — équivaut à `[^0-9]`
`\s`	Espace blanc — équivaut à `[\t\n\f\r ]`
`\S`	Caractère non-espace blanc — équivaut à `[^\t\n\f\r ]`
`\w`	Caractère alphanumérique — équivaut à `[0-9A-Za-z_]`
`\W`	Caractère non-alphanumérique — équivaut à `[^0-9A-Za-z_]`

Utilisez regexr ou regex101 pour créer et tester des expressions régulières de manière interactive.

Séquences d'échappement JSON

JSON utilise l'antislash comme caractère d'échappement. Les séquences d'échappement suivantes sont définies par la spécification JSON :

Séquence d'échappement	Description
`\"`	Guillemet double
`\\`	Antislash
`\/`	Barre oblique
`\b`	Retour arrière
`\f`	Saut de page
`\n`	Saut de ligne
`\r`	Retour chariot
`\t`	Tabulation horizontale
`\u` + 4 chiffres hexadécimaux	Caractère Unicode

Utilisez JSONLint pour valider les chaînes JSON.

Exemples

Caractères spéciaux dans les chaînes SQL

\t compte comme un seul caractère :

SELECT LENGTH('a\tb');

-- Result:
3

\a n'est pas une séquence d'échappement reconnue ; l'antislash est donc supprimé et \a devient a :

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

-- Result:
aab, 3

Échappement regex + SQL

Pour extraire 010 de 010-12345678 à l'aide d'une expression régulière :

Écrivez l'expression régulière : (\d+)-
Échappez l'antislash pour SQL : (\\d+)-
Délimitez la chaîne avec des apostrophes : '(\\d+)-'

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

-- Result:
010

Échappement JSON + SQL

La chaîne JSON {"key":"this is very \"important\"."} contient des séquences d'échappement SQL (\"). Lorsqu'elle est transmise directement à get_json_object, l'analyseur SQL consomme d'abord les antislashs, transformant \" en ". La chaîne résultante n'est plus du JSON valide, donc la fonction renvoie NULL :

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

-- Result:
NULL

Vérifiez ce que l'analyseur SQL voit réellement :

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

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

Les antislashs ont disparu. Pour transmettre une chaîne JSON valide via SQL, doublez l'échappement des antislashs (\" → \\") :

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

-- Result:
this is very "important".

Échappement JSON + regex + SQL

Pour faire correspondre important à partir de la chaîne JSON {"key":"this is very \"important\"."} à l'aide d'une expression régulière :

Écrivez l'expression régulière pour faire correspondre le mot entre guillemets : \"(.*)\"
Échappez les antislashs pour le moteur d'expressions régulières : \\"(.*)\\"
Échappez à nouveau les antislashs pour SQL : '\\\\"(.*)\\\\"'

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

-- Result:
important

Lorsque l'imbrication est aussi profonde, analysez d'abord le JSON, puis appliquez l'expression régulière : l'expression reste ainsi lisible.

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

-- Result:
important

Pour comprendre ce que '\\\\"(.*)\\\\"' fait réellement correspondre, exécutez-le via SELECT :

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

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

Littéraux de chaîne brute

Lorsque SQL, JSON et les expressions régulières sont combinés, le nombre d'antislashs augmente rapidement. La syntaxe R"()" vous permet d'écrire la chaîne littérale exactement telle qu'elle apparaît, sans avoir besoin d'échapper les antislashs à l'intérieur des parenthèses.

Le tableau suivant montre comment les littéraux de chaîne brute réduisent le bruit visuel lié aux antislashs :

Chaîne normale	Littéral de chaîne brute
`'abc'`	`R"(abc)"`
`'\\\\"(.*)\\\\"'`	`R'(\\"(.*)\\")'`

Remarques sur la syntaxe :

R est insensible à la casse : r"()" fonctionne tout aussi bien.
Les apostrophes ou les guillemets doubles sont tous deux valides : R"()" ou R'()'.
Seuls les délimiteurs changent ; le contenu entre les parenthèses est pris littéralement.

L'exemple JSON + regex de la section précédente devient beaucoup plus clair avec les littéraux de chaîne brute :

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

-- Result:
important