ClickHouse/docs/fr/sql-reference/functions/string-functions.md
Ivan Blinkov cd14f9ebcb
SQL reference refactoring (#10857)
* split up select.md

* array-join.md basic refactoring

* distinct.md basic refactoring

* format.md basic refactoring

* from.md basic refactoring

* group-by.md basic refactoring

* having.md basic refactoring

* additional index.md refactoring

* into-outfile.md basic refactoring

* join.md basic refactoring

* limit.md basic refactoring

* limit-by.md basic refactoring

* order-by.md basic refactoring

* prewhere.md basic refactoring

* adjust operators/index.md links

* adjust sample.md links

* adjust more links

* adjust operatots links

* fix some links

* adjust aggregate function article titles

* basic refactor of remaining select clauses

* absolute paths in make_links.sh

* run make_links.sh

* remove old select.md locations

* translate docs/es

* translate docs/fr

* translate docs/fa

* remove old operators.md location

* change operators.md links

* adjust links in docs/es

* adjust links in docs/es

* minor texts adjustments

* wip

* update machine translations to use new links

* fix changelog

* es build fixes

* get rid of some select.md links

* temporary adjust ru links

* temporary adjust more ru links

* improve curly brace handling

* adjust ru as well

* fa build fix

* ru link fixes

* zh link fixes

* temporary disable part of anchor checks
2020-05-15 07:34:54 +03:00

15 KiB
Raw Blame History

machine_translated machine_translated_rev toc_priority toc_title
true 72537a2d52 40 Travailler avec des chaînes

Fonctions pour travailler avec des chaînes

vide

Renvoie 1 pour une chaîne vide ou 0 pour une chaîne non vide. Le type de résultat est UInt8. Une chaîne est considérée comme non vide si elle contient au moins un octet, même s'il s'agit d'un espace ou d'un octet nul. La fonction fonctionne également pour les tableaux.

notEmpty

Renvoie 0 pour une chaîne vide ou 1 pour une chaîne non vide. Le type de résultat est UInt8. La fonction fonctionne également pour les tableaux.

longueur

Renvoie la longueur d'une chaîne en octets (pas en caractères, et pas en points de code). Le type de résultat est UInt64. La fonction fonctionne également pour les tableaux.

lengthUTF8

Renvoie la longueur d'une chaîne en points de code Unicode (pas en caractères), en supposant que la chaîne contient un ensemble d'octets qui composent le texte codé en UTF-8. Si cette hypothèse n'est pas remplie, elle renvoie un résultat (elle ne lance pas d'exception). Le type de résultat est UInt64.

char_length, CHAR_LENGTH

Renvoie la longueur d'une chaîne en points de code Unicode (pas en caractères), en supposant que la chaîne contient un ensemble d'octets qui composent le texte codé en UTF-8. Si cette hypothèse n'est pas remplie, elle renvoie un résultat (elle ne lance pas d'exception). Le type de résultat est UInt64.

character_length, CHARACTER_LENGTH

Renvoie la longueur d'une chaîne en points de code Unicode (pas en caractères), en supposant que la chaîne contient un ensemble d'octets qui composent le texte codé en UTF-8. Si cette hypothèse n'est pas remplie, elle renvoie un résultat (elle ne lance pas d'exception). Le type de résultat est UInt64.

plus bas, lcase

Convertit les symboles latins ASCII dans une chaîne en minuscules.

supérieur, ucase

Convertit les symboles latins ASCII dans une chaîne en majuscules.

lowerUTF8

Convertit une chaîne en minuscules, en supposant que la chaîne de caractères contient un ensemble d'octets qui composent un texte UTF-8. Il ne détecte pas la langue. Donc, pour le turc, le résultat pourrait ne pas être exactement correct. Si la longueur de la séquence d'octets UTF-8 est différente pour les majuscules et les minuscules d'un point de code, le résultat peut être incorrect pour ce point de code. Si la chaîne contient un ensemble d'octets qui N'est pas UTF-8, le comportement n'est pas défini.

upperUTF8

Convertit une chaîne en majuscules, en supposant que la chaîne de caractères contient un ensemble d'octets qui composent un texte UTF-8. Il ne détecte pas la langue. Donc, pour le turc, le résultat pourrait ne pas être exactement correct. Si la longueur de la séquence d'octets UTF-8 est différente pour les majuscules et les minuscules d'un point de code, le résultat peut être incorrect pour ce point de code. Si la chaîne contient un ensemble d'octets qui N'est pas UTF-8, le comportement n'est pas défini.

isValidUTF8

Renvoie 1, si l'ensemble d'octets est codé en UTF-8 valide, sinon 0.

toValidUTF8

Remplace les caractères UTF-8 non valides par <EFBFBD> (U+FFFD) caractère. Tous les caractères non valides s'exécutant dans une rangée sont réduits en un seul caractère de remplacement.

toValidUTF8( input_string )

Paramètre:

  • input_string — Any set of bytes represented as the Chaîne type de données objet.

Valeur renvoyée: chaîne UTF-8 valide.

Exemple

SELECT toValidUTF8('\x61\xF0\x80\x80\x80b')
┌─toValidUTF8('a<><61><EFBFBD><EFBFBD>b')─┐
│ a<>b                   │
└───────────────────────┘

répéter

Répète une corde autant de fois que spécifié et concatène les valeurs répliquées comme une seule chaîne.

Syntaxe

repeat(s, n)

Paramètre

  • s — The string to repeat. Chaîne.
  • n — The number of times to repeat the string. UInt.

Valeur renvoyée

La chaîne unique, qui contient la chaîne s répéter n temps. Si n < 1, la fonction renvoie une chaîne vide.

Type: String.

Exemple

Requête:

SELECT repeat('abc', 10)

Résultat:

┌─repeat('abc', 10)──────────────┐
│ abcabcabcabcabcabcabcabcabcabc │
└────────────────────────────────┘

inverser

Inverse la chaîne (comme une séquence d'octets).

reverseUTF8

Inverse une séquence de points de code Unicode, en supposant que la chaîne contient un ensemble d'octets représentant un texte UTF-8. Sinon, il fait autre chose (il ne lance pas d'exception).

format(pattern, s0, s1, …)

Formatage du motif constant avec la chaîne listée dans les arguments. pattern est un modèle de format Python simplifié. Chaîne de Format contient “replacement fields” entouré par des accolades {}. Tout ce qui n'est pas contenu dans les accolades est considéré comme du texte littéral, qui est copié inchangé dans la sortie. Si vous devez inclure un caractère d'Accolade dans le texte littéral, il peut être échappé en doublant: {{ '{{' }} et {{ '}}' }}. Les noms de champs peuvent être des nombres (à partir de zéro) ou vides (ils sont alors traités comme des nombres de conséquence).

SELECT format('{1} {0} {1}', 'World', 'Hello')
┌─format('{1} {0} {1}', 'World', 'Hello')─┐
│ Hello World Hello                       │
└─────────────────────────────────────────┘
SELECT format('{} {}', 'Hello', 'World')
┌─format('{} {}', 'Hello', 'World')─┐
│ Hello World                       │
└───────────────────────────────────┘

concat

Concatène les chaînes répertoriées dans les arguments, sans séparateur.

Syntaxe

concat(s1, s2, ...)

Paramètre

Valeurs de type String ou FixedString.

Valeurs renvoyées

Renvoie la chaîne qui résulte de la concaténation des arguments.

Si l'une des valeurs d'argument est NULL, concat retourner NULL.

Exemple

Requête:

SELECT concat('Hello, ', 'World!')

Résultat:

┌─concat('Hello, ', 'World!')─┐
│ Hello, World!               │
└─────────────────────────────┘

concatAssumeInjective

Même que concat la différence est que vous devez vous assurer que concat(s1, s2, ...) → sn est injectif, il sera utilisé pour l'optimisation du groupe par.

La fonction est nommée “injective” si elle renvoie toujours un résultat différent pour différentes valeurs d'arguments. En d'autres termes: des arguments différents ne donnent jamais un résultat identique.

Syntaxe

concatAssumeInjective(s1, s2, ...)

Paramètre

Valeurs de type String ou FixedString.

Valeurs renvoyées

Renvoie la chaîne qui résulte de la concaténation des arguments.

Si l'une des valeurs d'argument est NULL, concatAssumeInjective retourner NULL.

Exemple

Table d'entrée:

CREATE TABLE key_val(`key1` String, `key2` String, `value` UInt32) ENGINE = TinyLog;
INSERT INTO key_val VALUES ('Hello, ','World',1), ('Hello, ','World',2), ('Hello, ','World!',3), ('Hello',', World!',2);
SELECT * from key_val;
┌─key1────┬─key2─────┬─value─┐
│ Hello,  │ World    │     1 │
│ Hello,  │ World    │     2 │
│ Hello,  │ World!   │     3 │
│ Hello   │ , World! │     2 │
└─────────┴──────────┴───────┘

Requête:

SELECT concat(key1, key2), sum(value) FROM key_val GROUP BY concatAssumeInjective(key1, key2)

Résultat:

┌─concat(key1, key2)─┬─sum(value)─┐
│ Hello, World!      │          3 │
│ Hello, World!      │          2 │
│ Hello, World       │          3 │
└────────────────────┴────────────┘

substring(s, offset, longueur), mid(s, offset, longueur), substr(s, offset, longueur)

Renvoie une sous-chaîne commençant par l'octet du offset index length octets de long. L'indexation des caractères commence à partir d'un (comme dans SQL standard). Le offset et length les arguments doivent être des constantes.

substringUTF8(s, offset, longueur)

Le même que substring, mais pour les points de code Unicode. Fonctionne sous l'hypothèse que la chaîne contient un ensemble d'octets représentant un texte codé en UTF-8. Si cette hypothèse n'est pas remplie, elle renvoie un résultat (elle ne lance pas d'exception).

appendTrailingCharIfAbsent (s, c)

Si l' s la chaîne n'est pas vide et ne contient pas c personnage à la fin, il ajoute le c personnage à la fin.

convertCharset(s, à partir de, à)

Retourne une chaîne de caractères s qui a été converti à partir de l'encodage dans from pour l'encodage dans to.

base64Encode(s)

Encodage s chaîne dans base64

base64Decode(s)

Décoder la chaîne codée en base64 s dans la chaîne d'origine. En cas d'échec, une exception est levée.

tryBase64Decode(s)

Semblable à base64Decode, mais en cas d'erreur, une chaîne vide serait renvoyé.

endsWith (s, suffixe)

Renvoie s'il faut se terminer par le suffixe spécifié. Retourne 1 si la chaîne se termine par le suffixe spécifié, sinon elle renvoie 0.

startsWith (STR, préfixe)

Retourne 1 si la chaîne commence par le préfixe spécifié, sinon elle renvoie 0.

SELECT startsWith('Spider-Man', 'Spi');

Valeurs renvoyées

  • 1, si la chaîne commence par le préfixe spécifié.
  • 0, si la chaîne ne commence pas par le préfixe spécifié.

Exemple

Requête:

SELECT startsWith('Hello, world!', 'He');

Résultat:

┌─startsWith('Hello, world!', 'He')─┐
│                                 1 │
└───────────────────────────────────┘

coupe

Supprime tous les caractères spécifiés du début ou de la fin d'une chaîne. Par défaut supprime toutes les occurrences consécutives d'espaces communs (caractère ASCII 32) des deux extrémités d'une chaîne.

Syntaxe

trim([[LEADING|TRAILING|BOTH] trim_character FROM] input_string)

Paramètre

  • trim_character — specified characters for trim. Chaîne.
  • input_string — string for trim. Chaîne.

Valeur renvoyée

Une chaîne sans caractères de début et (ou) de fin spécifiés.

Type: String.

Exemple

Requête:

SELECT trim(BOTH ' ()' FROM '(   Hello, world!   )')

Résultat:

┌─trim(BOTH ' ()' FROM '(   Hello, world!   )')─┐
│ Hello, world!                                 │
└───────────────────────────────────────────────┘

trimLeft

Supprime toutes les occurrences consécutives d'espaces communs (caractère ASCII 32) depuis le début d'une chaîne. Il ne supprime pas d'autres types de caractères d'espaces (tabulation, espace sans pause, etc.).

Syntaxe

trimLeft(input_string)

Alias: ltrim(input_string).

Paramètre

  • input_string — string to trim. Chaîne.

Valeur renvoyée

Une chaîne sans ouvrir les espaces communs.

Type: String.

Exemple

Requête:

SELECT trimLeft('     Hello, world!     ')

Résultat:

┌─trimLeft('     Hello, world!     ')─┐
│ Hello, world!                       │
└─────────────────────────────────────┘

trimRight

Supprime toutes les occurrences consécutives d'espaces communs (caractère ASCII 32) de la fin d'une chaîne. Il ne supprime pas d'autres types de caractères d'espaces (tabulation, espace sans pause, etc.).

Syntaxe

trimRight(input_string)

Alias: rtrim(input_string).

Paramètre

  • input_string — string to trim. Chaîne.

Valeur renvoyée

Une chaîne sans espaces communs de fin.

Type: String.

Exemple

Requête:

SELECT trimRight('     Hello, world!     ')

Résultat:

┌─trimRight('     Hello, world!     ')─┐
│      Hello, world!                   │
└──────────────────────────────────────┘

trimBoth

Supprime toutes les occurrences consécutives d'espaces communs (caractère ASCII 32) des deux extrémités d'une chaîne. Il ne supprime pas d'autres types de caractères d'espaces (tabulation, espace sans pause, etc.).

Syntaxe

trimBoth(input_string)

Alias: trim(input_string).

Paramètre

  • input_string — string to trim. Chaîne.

Valeur renvoyée

Une chaîne sans espaces communs de début et de fin.

Type: String.

Exemple

Requête:

SELECT trimBoth('     Hello, world!     ')

Résultat:

┌─trimBoth('     Hello, world!     ')─┐
│ Hello, world!                       │
└─────────────────────────────────────┘

CRC32 (s)

Renvoie la somme de contrôle CRC32 d'une chaîne, en utilisant le polynôme CRC-32-IEEE 802.3 et la valeur initiale 0xffffffff (zlib mise en œuvre).

Le type de résultat est UInt32.

CRC32IEEE (s)

Renvoie la somme de contrôle CRC32 d'une chaîne, en utilisant le polynôme CRC-32-IEEE 802.3.

Le type de résultat est UInt32.

CRC64 (s)

Renvoie la somme de contrôle CRC64 d'une chaîne, en utilisant le polynôme CRC-64-ECMA.

Le type de résultat est UInt64.

Article Original