SQL
Fonctions de chaîne

Introduction

Syntaxe

• CONCAT (string_value1, string_value2 [, string_valueN])
• LTRIM (expression_caractère)
• RTRIM (expression_caractère)
• SUBSTRING (expression, début, longueur)
• ASCII (expression_caractère)
• REPLICATE (expression_chaîne, expression_entier)
• REVERSE (expression_chaîne)
• UPPER (expression_caractère)
• TRIM ([caractères FROM] chaîne)
• STRING_SPLIT (chaîne, séparateur)
• STUFF (expression_caractère, début, longueur, remplacement_expression)
• REPLACE (expression_chaîne, string_pattern, string_replacement)

Remarques

Couper les espaces vides

Trim est utilisé pour supprimer l'espace d'écriture au début ou à la fin de la sélection

En MSSQL, il n'y a pas un seul TRIM()

SELECT LTRIM('  Hello  ') --returns 'Hello  '
SELECT RTRIM('  Hello  ') --returns '  Hello'
SELECT LTRIM(RTRIM('  Hello  ')) --returns 'Hello'

MySql et Oracle

SELECT TRIM('  Hello  ') --returns 'Hello'

Enchaîner

En (standard ANSI / ISO) SQL, l'opérateur pour la concaténation de chaînes est || . Cette syntaxe est prise en charge par toutes les bases de données principales, à l'exception de SQL Server:

SELECT 'Hello' || 'World' || '!'; --returns HelloWorld!

De nombreuses bases de données prennent en charge une fonction CONCAT pour joindre des chaînes:

SELECT CONCAT('Hello', 'World'); --returns 'HelloWorld'

Certaines bases de données prennent en charge CONCAT pour joindre plus de deux chaînes (Oracle non):

SELECT CONCAT('Hello', 'World', '!'); --returns 'HelloWorld!'

Dans certaines bases de données, les types non-chaîne doivent être convertis ou convertis:

SELECT CONCAT('Foo', CAST(42 AS VARCHAR(5)), 'Bar'); --returns 'Foo42Bar'

Certaines bases de données (par exemple, Oracle) effectuent des conversions implicites sans perte. Par exemple, un CONCAT sur un CLOB et NCLOB produit un NCLOB . Un CONCAT sur un nombre et un varchar2 donne un varchar2 , etc.:

SELECT CONCAT(CONCAT('Foo', 42), 'Bar') FROM dual; --returns Foo42Bar

Certaines bases de données peuvent utiliser l'opérateur non standard + (mais dans la plupart des cas, + ne fonctionne que pour les nombres):

SELECT 'Foo' + CAST(42 AS VARCHAR(5)) + 'Bar';

Sur SQL Server <2012, où CONCAT n'est pas pris en charge, + est le seul moyen de joindre des chaînes.

Minuscules supérieure

SELECT UPPER('HelloWorld') --returns 'HELLOWORLD'
SELECT LOWER('HelloWorld') --returns 'helloworld'

Substring

La syntaxe est la suivante: SUBSTRING ( string_expression, start, length ) . Notez que les chaînes SQL sont indexées en 1.

SELECT SUBSTRING('Hello', 1, 2) --returns 'He'
SELECT SUBSTRING('Hello', 3, 3) --returns 'llo'

Ceci est souvent utilisé avec la fonction LEN() pour obtenir les n derniers caractères d'une chaîne de longueur inconnue.

DECLARE @str1 VARCHAR(10) = 'Hello', @str2 VARCHAR(10) = 'FooBarBaz';
SELECT SUBSTRING(@str1, LEN(@str1) - 2, 3) --returns 'llo'
SELECT SUBSTRING(@str2, LEN(@str2) - 2, 3) --returns 'Baz'

Divisé

Divise une expression de chaîne à l'aide d'un séparateur de caractères. Notez que STRING_SPLIT() est une fonction table.

SELECT value FROM STRING_SPLIT('Lorem ipsum dolor sit amet.', ' ');

Résultat:

value
-----
Lorem
ipsum
dolor
sit
amet.

Des trucs

Farcir une chaîne dans une autre, en remplaçant 0 ou plusieurs caractères à une certaine position.

Remarque: la position de start est indexée sur 1 (vous commencez à indexer à 1 et non à 0).

Syntaxe:

STUFF ( character_expression , start , length , replaceWith_expression )  

Exemple:

SELECT STUFF('FooBarBaz', 4, 3, 'Hello') --returns 'FooHelloBaz'

Longueur

serveur SQL

Le LEN ne compte pas l’espace de fuite.

SELECT LEN('Hello') -- returns 5

SELECT LEN('Hello '); -- returns 5

La DATALENGTH compte l’espace de fuite.

SELECT DATALENGTH('Hello') -- returns 5

SELECT DATALENGTH('Hello '); -- returns 6

Il convient toutefois de noter que DATALENGTH renvoie la longueur de la représentation sous-jacente des octets de la chaîne, qui dépend, entre autres, du jeu de caractères utilisé pour stocker la chaîne.

DECLARE @str varchar(100) = 'Hello ' --varchar is usually an ASCII string, occupying 1 byte per char
SELECT DATALENGTH(@str) -- returns 6

DECLARE @nstr nvarchar(100) = 'Hello ' --nvarchar is a unicode string, occupying 2 bytes per char
SELECT DATALENGTH(@nstr) -- returns 12

Oracle

Syntaxe: Longueur (char)

Exemples:

SELECT Length('Bible') FROM dual; --Returns 5
SELECT Length('righteousness') FROM dual; --Returns 13
SELECT Length(NULL) FROM dual; --Returns NULL

Voir aussi: LongueurB, LongueurC, Longueur2, Longueur4

Remplacer

Syntaxe:

REPLACE( Chaîne à rechercher , Chaîne à rechercher et remplacer , Chaîne à placer dans la chaîne d'origine )

Exemple:

SELECT REPLACE( 'Peter Steve Tom', 'Steve', 'Billy' ) --Return Values: Peter Billy Tom

GAUCHE DROITE

La syntaxe est la suivante:
LEFT (expression de chaîne, entier)
DROITE (expression de chaîne, entier)

SELECT LEFT('Hello',2)  --return He  
SELECT RIGHT('Hello',2) --return lo

Oracle SQL n'a pas de fonctions GAUCHE et DROITE. Ils peuvent être émulés avec SUBSTR et LONGUEUR.
SUBSTR (expression de chaîne, 1, entier)
SUBSTR (expression_chaîne, longueur (expression_chaîne) -intérieur + 1, entier)

SELECT SUBSTR('Hello',1,2)  --return He  
SELECT SUBSTR('Hello',LENGTH('Hello')-2+1,2) --return lo

SENS INVERSE

La syntaxe est la suivante: REVERSE (expression de chaîne)

SELECT REVERSE('Hello') --returns olleH

REPRODUIRE

La fonction REPLICATE concatène une chaîne avec elle-même un nombre de fois spécifié.

La syntaxe est la suivante: REPLICATE (expression de chaîne, entier)

SELECT REPLICATE ('Hello',4) --returns 'HelloHelloHelloHello'

REGEXP

SELECT 'bedded' REGEXP '[a-f]' -- returns True

SELECT 'beam' REGEXP '[a-f]' -- returns False

Remplacer la fonction dans sql Sélectionner et mettre à jour la requête

La fonction Remplacer dans SQL est utilisée pour mettre à jour le contenu d'une chaîne. L'appel de fonction est REPLACE () pour MySQL, Oracle et SQL Server.

La syntaxe de la fonction Remplacer est la suivante:

REPLACE (str, find, repl)

L'exemple suivant remplace les occurrences de South par Southern dans la table Employees:

Select Statement:

Si nous appliquons la fonction Remplacer suivante:

SELECT 
    FirstName, 
    REPLACE (Address, 'South', 'Southern') Address
FROM Employees 
ORDER BY FirstName 

Résultat:

Déclaration de mise à jour:

Nous pouvons utiliser une fonction de remplacement pour apporter des modifications permanentes à notre tableau en suivant l'approche suivante.

Update Employees 
Set city = (Address, 'South', 'Southern');

Une approche plus commune consiste à utiliser ceci en conjonction avec une clause WHERE comme ceci:

Update Employees 
Set Address = (Address, 'South', 'Southern')
Where Address LIKE 'South%';

PARSENAME

BASE DE DONNEES : SQL Server

La fonction PARSENAME renvoie la partie spécifique de la chaîne donnée (nom d'objet). Le nom de l'objet peut contenir une chaîne comme le nom de l'objet, le nom du propriétaire, le nom de la base de données et le nom du serveur.

Plus de détails MSDN: PARSENAME

Syntaxe

PARSENAME('NameOfStringToParse',PartIndex)

Exemple

Pour obtenir le nom de l'objet, utilisez l'index de la partie 1

SELECT PARSENAME('ServerName.DatabaseName.SchemaName.ObjectName',1)  // returns `ObjectName`
SELECT PARSENAME('[1012-1111].SchoolDatabase.school.Student',1)     // returns `Student`

Pour obtenir le nom du schéma, utilisez l'index du composant 2

SELECT PARSENAME('ServerName.DatabaseName.SchemaName.ObjectName',2)  // returns `SchemaName`
SELECT PARSENAME('[1012-1111].SchoolDatabase.school.Student',2)     // returns `school`

Pour obtenir le nom de la base de données, utilisez l'index de la pièce 3

SELECT PARSENAME('ServerName.DatabaseName.SchemaName.ObjectName',3) // returns `DatabaseName`
SELECT PARSENAME('[1012-1111].SchoolDatabase.school.Student',3)    // returns `SchoolDatabase` 

Pour obtenir le nom du serveur, utilisez l'index de la pièce 4

SELECT PARSENAME('ServerName.DatabaseName.SchemaName.ObjectName',4)  // returns `ServerName`
SELECT PARSENAME('[1012-1111].SchoolDatabase.school.Student',4)     // returns `[1012-1111]`

PARSENAME retournera null si la partie spécifiée n'est pas présente dans la chaîne de nom d'objet donnée

INSTR

Retourne l'index de la première occurrence d'une sous-chaîne (zéro si non trouvé)

Syntaxe: INSTR (chaîne, sous-chaîne)

SELECT INSTR('FooBarBar', 'Bar') -- return 4
SELECT INSTR('FooBarBar', 'Xar') -- return 0