String functions supported by Lindorm SQL - Lindorm - Centre de documentation Alibaba Cloud

Fonctions de chaîne prises en charge

Catégorie	Fonction	Description

| Manipulation générale |

CONCAT

| Concatène plusieurs chaînes en une seule |

| |

LENGTH

| Renvoie le nombre de caractères d'une chaîne |

| |

REPLACE

| Remplace toutes les occurrences d'une sous-chaîne |

| |

REVERSE

| Inverse l'ordre des caractères d'une chaîne |

| |

SUBSTR

| Extrait une sous-chaîne selon sa position et sa longueur |

| |

TRIM

| Supprime les espaces de début et de fin |

| Conversion de casse |

LOWER

| Convertit tous les caractères alphabétiques en minuscules |

| |

UPPER

| Convertit tous les caractères alphabétiques en majuscules |

| Expressions régulières |

REGEXP_REPLACE

| Remplace les sous-chaînes correspondant à une expression régulière |

| |

REGEXP_SUBSTR

| Extrait la première sous-chaîne correspondant à une expression régulière |

| Correspondance de préfixe |

START_WITH

| Renvoie true si une chaîne commence par un préfixe donné |

| Recherche en texte intégral |

MATCH

| Compare les valeurs de colonne à une expression de recherche à l'aide d'un index de recherche |

| Hachages cryptographiques |

MD5

| Renvoie le hachage MD5 d'une chaîne |

| |

SHA256

| Renvoie le hachage SHA256 d'une chaîne |

CONCAT

Concatène deux chaînes ou plus en une seule. Aucun délimiteur n'est ajouté entre les valeurs.

Syntaxe

CONCAT('string1', 'string2', ..., 'stringN')

Paramètres

Paramètre	Obligatoire	Description
`'string1', 'string2', ..., 'stringN'`	Oui	Chaînes à concaténer. Spécifiez deux valeurs de chaîne ou plus.

Exemple

SELECT concat('a', 'b', 'c') AS val;

Résultat :

+-----+
| val |
+-----+
| abc |
+-----+

LENGTH

Renvoie le nombre de caractères contenus dans une chaîne.

Syntaxe

LENGTH('string')

Paramètres

Paramètre	Obligatoire	Description
`string`	Oui	Chaîne à mesurer.

Exemple

SELECT length('abc') AS len;

Résultat :

+-----+
| len |
+-----+
| 3   |
+-----+

LOWER

Convertit tous les caractères alphabétiques d'une chaîne en minuscules. Les caractères non alphabétiques ne sont pas affectés.

Syntaxe

LOWER('string')

Paramètres

Paramètre	Obligatoire	Description
`string`	Oui	Chaîne à convertir.

Exemples

Exemple 1 : Conversion de ABC en minuscules.

SELECT lower('ABC') AS val;

Résultat :

+-----+
| val |
+-----+
| abc |
+-----+

Exemple 2 : Conversion d'une chaîne mixte en minuscules.

SELECT lower('Abc') AS val;

Résultat :

+-----+
| val |
+-----+
| abc |
+-----+

UPPER

Convertit tous les caractères alphabétiques d'une chaîne en majuscules. Les caractères non alphabétiques ne sont pas affectés.

Syntaxe

UPPER('string')

Paramètres

Paramètre	Obligatoire	Description
`string`	Oui	Chaîne à convertir.

Exemples

Exemple 1 : Conversion de abc en majuscules.

SELECT upper('abc') AS val;

Résultat :

+-----+
| val |
+-----+
| ABC |
+-----+

Exemple 2 : Conversion d'une chaîne mixte en majuscules.

SELECT upper('aBC') AS val;

Résultat :

+-----+
| val |
+-----+
| ABC |
+-----+

TRIM

Supprime les espaces situés au début et à la fin d'une chaîne. Les espaces internes sont conservés.

Syntaxe

TRIM('string')

Paramètres

Paramètre	Obligatoire	Description
`string`	Oui	Chaîne à nettoyer.

Exemple

SELECT trim(' abc    ') AS str;

Résultat :

+-----+
| str |
+-----+
| abc |
+-----+

REPLACE

Remplace toutes les occurrences d'une sous-chaîne au sein d'une chaîne source.

Syntaxe

REPLACE('string', 'from_str', 'to_str')

Paramètres

Paramètre	Obligatoire	Description
`string`	Oui	Chaîne source.
`from_str`	Oui	Sous-chaîne à rechercher et remplacer.
`to_str`	Oui	Sous-chaîne de remplacement.

Exemples

Exemple 1 : Remplacement de bc par cd dans la chaîne abc.

SELECT replace('abc', 'bc', 'cd') AS val;

Résultat :

+-----+
| val |
+-----+
| acd |
+-----+

Exemple 2 : Remplacement de toutes les occurrences de bc par cd dans la chaîne abcbc.

SELECT replace('abcbc', 'bc', 'cd') AS val;

Résultat :

+-------+
|  val  |
+-------+
| acdcd |
+-------+

REVERSE

Inverse l'ordre des caractères d'une chaîne.

Syntaxe

REVERSE('string')

Paramètres

Paramètre	Obligatoire	Description
`string`	Oui	Chaîne à inverser.

Exemple

SELECT reverse('abc') AS val;

Résultat :

+-----+
| val |
+-----+
| cba |
+-----+

SUBSTR

Extrait une sous-chaîne à partir d'une position donnée, avec une limite de longueur facultative.

Syntaxe

SUBSTR(string, position [, length])

Paramètres

Paramètre	Obligatoire	Description
`string`	Oui	Chaîne source.
`position`	Oui	Position de départ (indexée à 1) de l'extraction. Doit être un entier supérieur ou égal à 1.
`length`	Non	Nombre de caractères à extraire. Doit être un entier supérieur ou égal à 1. Par défaut : extraction depuis la `position` jusqu'à la fin de la chaîne.

Exemples

Exemple 1 : Extraction depuis la position 2 jusqu'à la fin de la chaîne.

SELECT substr('abc', 2) AS val;

Résultat :

+-----+
| val |
+-----+
| bc  |
+-----+

Exemple 2 : Extraction de 2 caractères à partir de la position 1.

SELECT substr('abc', 1, 2) AS val;

Résultat :

+-----+
| val |
+-----+
| ab  |
+-----+

START_WITH

Renvoie true si une chaîne commence par le préfixe spécifié, et false dans le cas contraire.

Syntaxe

START_WITH('string', 'prefix')

Paramètres

Paramètre	Obligatoire	Description
`string`	Oui	Chaîne à vérifier.
`prefix`	Oui	Préfixe à comparer avec le début de la `string`.

Exemples

Exemple 1 : Vérification si abc commence par ab.

SELECT start_with('abc', 'ab') AS val;

Résultat :

+------+
| val  |
+------+
| true |
+------+

Exemple 2 : Vérification si abc commence par bc.

SELECT start_with('abc', 'bc') AS val;

Résultat :

+-------+
| val   |
+-------+
| false |
+-------+

REGEXP_REPLACE

Remplace les sous-chaînes correspondant à une expression régulière, en démarrant la recherche à partir d'une position spécifiée.

Syntaxe

REGEXP_REPLACE('string', pattern, replacement [, position])

Paramètres

Paramètre	Obligatoire	Description
`string`	Oui	Chaîne source.
`pattern`	Oui	Motif d'expression régulière définissant la règle de correspondance.
`replacement`	Oui	Chaîne de substitution pour chaque correspondance trouvée.
`position`	Non	Position du caractère (indexée à 1) où commencer la recherche. Doit être un entier supérieur ou égal à 1. Valeur par défaut : `1` (début au premier caractère).

Exemples

Exemple 1 : Remplacement de toutes les occurrences de b par c dans la chaîne abc (position par défaut).

SELECT regexp_replace('abc', 'b', 'c') AS val;

Résultat :

+-----+
| val |
+-----+
| acc |
+-----+

Exemple 2 : Remplacement des occurrences de b dans la chaîne abcbc à partir de la position 2.

SELECT regexp_replace('abcbc', 'b', 'c', 2) AS val;

Résultat :

+-------+
|  val  |
+-------+
| acccc |
+-------+

Exemple 3 : Remplacement des occurrences de b dans la chaîne abcbc à partir de la position 3. Le caractère b situé à la position 2 n'est pas remplacé.

SELECT regexp_replace('abcbc', 'b', 'c', 3) AS val;

Résultat :

+-------+
|  val  |
+-------+
| abccc |
+-------+

REGEXP_SUBSTR

Renvoie la première sous-chaîne correspondant à une expression régulière, en démarrant la recherche à partir d'une position spécifiée.

Syntaxe

REGEXP_SUBSTR('string', pattern [, position])

Paramètres

Paramètre	Obligatoire	Description
`string`	Oui	Chaîne source.
`pattern`	Oui	Motif d'expression régulière définissant la règle de correspondance.
`position`	Non	Position du caractère (indexée à 1) où commencer la recherche. Doit être un entier supérieur ou égal à 1. Valeur par défaut : `1` (début au premier caractère).

Exemples

Exemple 1 : Recherche de b dans la chaîne abc à partir du premier caractère (valeur par défaut).

SELECT regexp_substr('abc', 'b') AS val;

Résultat :

+-----+
| val |
+-----+
| b   |
+-----+

Exemple 2 : Recherche de b dans la chaîne abc à partir de la position 3. Aucune correspondance n'est trouvée car b se trouve à la position 2.

SELECT regexp_substr('abc', 'b', 3) AS val;

Résultat :

+-----+
| val |
+-----+
|     |
+-----+

MD5

Renvoie le hachage MD5 d'une chaîne.

Syntaxe

MD5('string')

Paramètres

Paramètre	Obligatoire	Description
`string`	Oui	Chaîne à hacher.

Exemple

SELECT md5('abc') AS val;

Résultat :

+----------------------------------+
|               val                |
+----------------------------------+
| 900150983cd24fb0d6963f7d28e17f72 |
+----------------------------------+

SHA256

Renvoie le hachage SHA256 d'une chaîne.

Syntaxe

SHA256('string')

Paramètres

Paramètre	Obligatoire	Description
`string`	Oui	Chaîne à hacher.

Exemple

Cet exemple crée une table d'exemple, insère une ligne, puis interroge le hachage SHA256 d'une valeur de colonne.

-- Create a sample table.
CREATE TABLE tb (id INT, name VARCHAR, address VARCHAR, PRIMARY KEY(id, name));

-- Insert a row.
UPSERT INTO tb (id, name, address) VALUES (1, 'jack', 'hz');

-- Query the SHA256 hash of the name column.
SELECT sha256(name) AS sc FROM tb WHERE id = 1;

Résultat :

+------------------------------------------------------------------+
|                                sc                                |
+------------------------------------------------------------------+
| 31611159e7e6ff7843ea4627745e89225fc866621cfcfdbd40871af4413747cc |
+------------------------------------------------------------------+

MATCH

Recherche des valeurs de colonne à l'aide d'une expression de recherche en texte intégral et d'un index de recherche. Les résultats sont triés par pertinence décroissante par défaut.

Important

MATCH nécessite LindormTable 2.7.2 ou une version ultérieure. Pour mettre à niveau, consultez les notes de version de LindormTable et la procédure de mise à niveau de votre instance.
MATCH fonctionne uniquement avec les index de recherche. Lorsqu'une condition MATCH et un index de recherche existent simultanément, le système utilise automatiquement l'index de recherche.

Notes d'utilisation

Colonnes non indexées : Le système récupère d'abord les lignes via l'index de recherche, puis filtre les colonnes non indexées ligne par ligne. Cette approche peut dégrader les performances sur les grands ensembles de données. Pour éviter cela, utilisez l'instruction ADD COLUMN afin d'ajouter les colonnes concernées à l'index de recherche.
Tables principales et index secondaires : MATCH n'est pas pris en charge sur les tables principales ni sur les index secondaires. Pour ces cas, utilisez LIKE pour effectuer des requêtes floues. Notez que les requêtes floues offrent des performances inférieures à celles des requêtes tokenisées.
Combinaison de MATCH et LIKE : Lorsque vous utilisez les deux opérateurs dans la même requête, configurez les colonnes concernées comme des colonnes tokenisées dans l'index de recherche.

Syntaxe

MATCH (column_identifiers) AGAINST (search_expr)

MATCH ne peut être utilisé que dans la clause WHERE d'une instruction SELECT.

Paramètres

Paramètre	Obligatoire	Description
`column_identifiers`	Oui	Un ou plusieurs noms de colonnes à rechercher, séparés par des virgules. Si plusieurs colonnes sont spécifiées, leurs valeurs sont combinées pour la correspondance. Des index de recherche doivent exister pour toutes les colonnes spécifiées, avec des analyseurs configurés pour la segmentation des mots. Consultez Activation de la fonctionnalité d'index de recherche et CREATE INDEX.
`search_expr`	Oui	Constante de chaîne définissant la règle de correspondance. Consultez la syntaxe des règles de correspondance ci-dessous.

Syntaxe des règles de correspondance

Une règle de correspondance comprend une ou plusieurs conditions séparées par des espaces. Chaque condition peut prendre l'une des formes suivantes :

Un mot unique — correspond aux lignes contenant ce mot. Exemple : hello
Une phrase entre guillemets — correspond aux lignes contenant la phrase exacte sans segmentation. Exemple : "hello world"
Une sous-règle entre parenthèses — correspond aux lignes satisfaisant la règle encapsulée. Exemple : (another "hello world")

Préfixez une condition avec un symbole pour modifier son comportement :

Symbole	Signification
`+`	La condition doit être satisfaite (ET logique)
`-`	La condition ne doit pas être satisfaite (NON logique)
(aucun)	La condition est optionnelle, mais les lignes correspondantes obtiennent un classement plus élevé

Exemples

Les exemples suivants utilisent cette table d'exemple :

-- Create a sample table.
CREATE TABLE tb (id INT, c1 VARCHAR, PRIMARY KEY(id));

-- Create a search index. Enable the search index feature before running this statement.
CREATE INDEX idx USING SEARCH ON tb (c1(type=text));

-- Insert rows.
UPSERT INTO tb (id, c1) VALUES (1, 'hello');
UPSERT INTO tb (id, c1) VALUES (2, 'world');
UPSERT INTO tb (id, c1) VALUES (3, 'hello world');
UPSERT INTO tb (id, c1) VALUES (4, 'hello my world');
UPSERT INTO tb (id, c1) VALUES (5, 'hello you');
UPSERT INTO tb (id, c1) VALUES (6, 'hello you and me');
UPSERT INTO tb (id, c1) VALUES (7, 'you and me');

Exemple 1 : Renvoie les lignes où c1 contient hello ou world (ou les deux). Les lignes correspondant aux deux termes obtiennent un classement plus élevé.

SELECT * FROM tb WHERE MATCH (c1) AGAINST ('hello world');

Résultat :

+----+------------------+
| id |        c1        |
+----+------------------+
| 3  | hello world      |
| 2  | world            |
| 4  | hello my world   |
| 5  | hello you        |
| 1  | hello            |
| 6  | hello you and me |
+----+------------------+

Exemple 2 : Renvoie les lignes où c1 doit contenir world et peut contenir hello. Les lignes contenant les deux termes obtiennent un classement plus élevé.

SELECT * FROM tb WHERE MATCH (c1) AGAINST ('hello +world');

Résultat :

+----+----------------+
| id |       c1       |
+----+----------------+
| 3  | hello world    |
| 2  | world          |
| 4  | hello my world |
+----+----------------+

Exemple 3 : Renvoie les lignes où c1 contient world mais pas hello.

SELECT * FROM tb WHERE MATCH (c1) AGAINST ('-hello +world');

Résultat :

+----+-------+
| id |  c1   |
+----+-------+
| 2  | world |
+----+-------+

Exemple 4 : Renvoie les lignes où c1 contient la phrase exacte hello world.

SELECT * FROM tb WHERE MATCH (c1) AGAINST ('"hello world"');

Résultat :

+----+-------------+
| id |     c1      |
+----+-------------+
| 3  | hello world |
+----+-------------+

Exemple 5 : Renvoie les lignes où c1 doit contenir hello et au moins l'un des termes you ou me.

SELECT * FROM tb WHERE MATCH (c1) AGAINST ('+hello +(you me)');

Résultat :

+----+------------------+
| id |        c1        |
+----+------------------+
| 6  | hello you and me |
| 5  | hello you        |
+----+------------------+