SQL
Strängfunktioner

Introduktion

Syntax

• CONCAT (string_value1, string_value2 [, string_valueN])
• LTRIM (karaktäruttryck)
• RTRIM (karaktäruttryck)
• SUBSTRING (uttryck, start, längd)
• ASCII (karaktäruttryck)
• REPLICATE (stränguttryck, heltaluttryck)
• REVERSE (stränguttryck)
• UPPER (karaktäruttryck)
• TRIM ([tecken från] sträng)
• STRING_SPLIT (sträng, separator)
• STUFF (karaktäruttryck, start, längd, ersätt meduttryck)
• REPLACE (string_expression, string_pattern, string_replacement)

Anmärkningar

Trimma tomma utrymmen

Trim används för att ta bort skrivutrymme i början eller slutet av valet

I MSSQL finns det ingen enda TRIM()

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

MySql och Oracle

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

HOPLÄNKA

I (standard ANSI / ISO) SQL är operatören för strängkoppling || . Denna syntax stöds av alla större databaser utom SQL Server:

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

Många databaser stöder en CONCAT funktion för att gå med i strängar:

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

Vissa databaser stöder att använda CONCAT att gå med i fler än två strängar (Oracle gör inte):

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

I vissa databaser måste icke-strängtyper castas eller konverteras:

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

Vissa databaser (t.ex. Oracle) utför implicita förlustfria konverteringar. Till exempel ger en CONCAT på en CLOB och NCLOB en NCLOB . En CONCAT på ett nummer och en varchar2 resulterar i en varchar2 , etc:

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

Vissa databaser kan använda den icke-standardiserade + operatören (men i de flesta fall + fungerar bara för nummer):

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

På SQL Server <2012, där CONCAT inte stöds, är + det enda sättet att gå med i strängar.

Små och stora bokstäver

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

träng

Syntax är: SUBSTRING ( string_expression, start, length ) . Observera att SQL-strängar är 1-indexerade.

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

Detta används ofta i samband med LEN() -funktionen för att få de sista n tecknen i en sträng med okänd längd.

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'

Dela

Delar upp ett stränguttryck med en teckenavskiljare. Observera att STRING_SPLIT() är en tabellvärderad funktion.

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

Resultat:

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

Grejer

Lägg en sträng i en annan och ersätt 0 eller fler tecken på en viss position.

Obs: start position är en indexerad (du börjar indexera på en, inte 0).

Syntax:

STUFF ( character_expression , start , length , replaceWith_expression )  

Exempel:

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

Längd

SQL Server

LEN räknar inte bakutrymmet.

SELECT LEN('Hello') -- returns 5

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

DATALÄNGDEN räknar släputrymmet.

SELECT DATALENGTH('Hello') -- returns 5

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

Det bör emellertid noteras att DATALENGTH returnerar längden på den underliggande bytepresentationen av strängen, vilket beror bland annat på den charset som används för att lagra strängen.

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

Orakel

Syntax: Längd (char)

Exempel:

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

Se även: LängdB, LängdC, Längd2, Längd4

Byta ut

Syntax:

REPLACE( sträng för att söka , sträng för att söka efter och ersätta , sträng för att placera i den ursprungliga strängen )

Exempel:

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

VÄNSTER HÖGER

Syntax är:
VÄNSTER (stränguttryck, heltal)
HÖGER (stränguttryck, heltal)

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

Oracle SQL har inte VÄNSTER och HÖGER-funktioner. De kan emuleras med SUBSTR och LENGTH.
SUBSTR (stränguttryck, 1, heltal)
SUBSTR (stränguttryck, längd (stränguttryck) - heltal + 1, heltal)

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

OMVÄND

Syntax är: REVERSE (stränguttryck)

SELECT REVERSE('Hello') --returns olleH

ÅTERSKAPA

Funktionen REPLICATE sammanlänker en sträng med sig själv ett specificerat antal gånger.

Syntax är: REPLICATE (stränguttryck, heltal)

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

REGUTTR

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

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

Ersätt funktion i sql Välj och uppdatera frågan

Funktionen Ersätt i SQL används för att uppdatera innehållet i en sträng. Funktionssamtalet är REPLACE () för MySQL, Oracle och SQL Server.

Syntaxen för ersättningsfunktionen är:

REPLACE (str, find, repl)

Följande exempel ersätter förekomster av South med Southern i tabellen Anställda:

Välj uttalande:

Om vi använder följande ersättningsfunktion:

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

Resultat:

Uppdatera uttalande:

Vi kan använda en ersättningsfunktion för att göra permanenta ändringar i vår tabell genom följande tillvägagångssätt.

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

En vanligare metod är att använda detta tillsammans med en WHERE-klausul som denna:

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

PARSENAME

DATABASE : SQL Server

Funktionen PARSENAME returnerar den specifika delen av den givna strängen (objektnamn). objektnamn kan innehålla strängar som objektnamn, ägarnamn, databasnamn och servernamn.

Mer information MSDN: PARSENAME

Syntax

PARSENAME('NameOfStringToParse',PartIndex)

Exempel

För att få objektnamn använda en del index 1

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

För att få schemanamnet använda en del index 2

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

För att få databasnamn använda en del index 3

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

Använd delindex 4 servernamn

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

PARSENAME kommer att returnera noll är angiven del är inte närvarande i en given sträng för objektnamn

INSTR

Returnera indexet för den första förekomsten av en substring (noll om den inte hittas)

Syntax: INSTR (sträng, substring)

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