Grundläggande strängfunktioner och -operatorer ger en mängd olika funktioner och returnerar ett strängvärde som ett resultat. Vissa strängfunktioner är tvåelement, vilket innebär att de kan arbeta på två strängar samtidigt. SQL 2003-standarden stöder strängfunktioner.

Sammankopplingsoperatör

SQL 2003 definierar sammanlänkningsoperatorn (||), som sammanfogar två separata strängar till ett enda strängvärde.

DB2-plattform

DB2-plattformen stöder SQL 2003-konkateneringsoperatorn samt dess synonym, CONCAT-funktionen.

MySQL-plattform

MySQL-plattformen stöder CONCATQ-funktionen, en synonym för SQL 2003-konkateneringsoperatorn.

Oracle och PostgreSQL

PostgreSQL- och Oracle-plattformarna stöder SQL 2003 dubbel vertikal strecksammansättningsoperator.

SQL Server-plattform

SQL Server-plattformen använder plustecknet (+) som en synonym för SQL 2003-konkateneringsoperatorn har en systemparameter CONCAT_NULL_YIELDS_NULL som styr hur systemet beter sig om NULL-värden påträffas vid sammanlänkning av strängvärden.

/* SQL 2003-syntax */

stringl || sträng2 || sträng3

sträng1sträng2sträng3

/* För MySQL */

CONCAT("strängl", "sträng2")

Om något av de sammanlänkade värdena är tomt, returneras en tom sträng. Dessutom, om ett numeriskt värde är involverat i sammanlänkningen, konverteras det implicit till ett strängvärde.

SELECT CONCAT("Mitt", "bologna", "har", "ett", "första", "namn...");

Min bologna har ett förnamn

SELECT CONCAT("Mitt ", NULL, "har", "första", "namn...");

KONVERTERA och ÖVERSÄTT

Funktionen KONVERTERA ändrar visningen av en teckensträng inom en teckenuppsättning och sortering. Funktionen KONVERTERA kan till exempel användas för att ändra antalet bitar per tecken.

Funktionen TRANSLATE översätter ett strängvärde från en teckenuppsättning till en annan. Till exempel kan funktionen ÖVERSÄTT användas för att konvertera ett värde från den engelska teckenuppsättningen till teckenuppsättningen Kanji (japanska) eller kyrillisk (ryska). Själva översättningen måste redan finnas - antingen specificerad som standard eller skapad med kommandot CREATE TRANSLATION.

SQL 2003 syntax

KONVERTERA (character_value USING character_conversion_name)

TRANSLATE(teckenvärde ANVÄNDER översättningsnamn)

Funktionen CONVERT konverterar ett teckenvärde till teckenuppsättningen med namnet som anges i parametern character_conversion_name. Funktionen TRANSLATE konverterar ett teckenvärde till den teckenuppsättning som anges i translation_name.

Bland de granskade plattformarna är det bara Oracle som stöder CONVERT- och TRANSLATE-funktionerna enligt definitionen i SQL 2003-standarden Oracles implementering av TRANSLATE-funktionen är mycket lik, men inte identisk med, SQL 2003. I den här implementeringen tar funktionen bara två argument och översätter endast mellan databasteckenuppsättningen och den språkaktiverade teckenuppsättningen.

MySQL:s implementering av CONV-funktionen konverterar bara tal från en bas till en annan. SQL Servers implementering av CONVERT-funktionen är ganska rik på möjligheter och ändrar datatypen för uttrycket, men i alla andra aspekter skiljer den sig från CONVERT-funktionen i SQL 2003-standarden. PostgreSQL-plattformen stöder inte CONVERT-funktionen implementering av TRANSLATE-funktionen konverterar alla förekomster av en teckensträng till vilken som helst annan teckensträng.

DB2

DB2-plattformen stöder inte CONVERT-funktionen och stödet för TRANSLATE-funktionen är inte ANSI-kompatibelt. TRANSLATE-funktionen används för att transformera delsträngar och har historiskt sett varit synonym med UPPER-funktionen eftersom UPPER-funktionen nyligen lades till i DB2. Om funktionen TRANSLATE används i DB2 med ett enda argument som teckenuttryck, blir resultatet samma sträng som konverterats till versaler. Om funktionen används med flera argument, som TRANSLATE(ucmo4HUK, replace, match), konverterar funktionen alla tecken i källan som också finns i matchningsparametern. Varje tecken i källan som är i samma position som i matchningsparametern kommer att ersättas med tecknet från parametern replace. Nedan följer ett exempel.

TRANSLATE("Hej världen!") "HEJ; VÄRLDEN!"

TRANSLATE("Hej, Värld1", "wZ", "1W") "Hewwo, Zorwd1

MySQL

MySQL-plattformen stöder inte funktionerna TRANSLATE och CONVERT.

Orakel

Oracle-plattformen stöder följande syntax för funktionerna CONVERT och TRANSLATE.

I Oracles implementering returnerar funktionen CONVERT texten i ett teckenvärde som konverterats till target_charset_set. Parametern char_value är strängen som ska konverteras, target_charset_set är namnet på teckenuppsättningen som strängen ska konverteras till, och parametern source_charset är teckenuppsättningen där strängvärdet ursprungligen lagrades.

ÖVERSÄTT-funktionen i Oracle överensstämmer med ANSI-syntaxen, men du kan bara välja en av två teckenuppsättningar: databasteckenuppsättningen (CHARJCS) och den nationella språkspecifika teckenuppsättningen (NCHARJZS).

Oracle stöder även en annan funktion, även kallad TRANSLATE (utan att använda nyckelordet USING). Denna TRANSLATE-funktion har ingenting att göra med teckenuppsättningskonvertering.

Namnen på mål- och källteckenuppsättningarna kan skickas antingen som strängkonstanter eller som en referens till en tabellkolumn. Observera att när du konverterar en sträng till en teckenuppsättning som inte visar alla tecken som konverteras, kan du ersätta ersättningstecken.

Oracle stöder flera vanliga teckenuppsättningar, som inkluderar US7ASCII och WE8DECDEC. WE8HP, F7DEC, WE8EBCDIC500, WE8PC850u WE8ISO8859PI. Till exempel:

SELECT CONVERT("Gro2", "US7ASCII", "WE8HP") FROM DUAL;

PostgreSQL

PostgreSQL-plattformen stöder ANSI-standarden CONVERT-satsen, och konverteringar här kan definieras med kommandot CREATE CONVERSION. PostgreSQL:s implementering av TRANSLATE-funktionen ger en utökad uppsättning funktioner som låter dig omvandla vilken text som helst till annan text inom en specificerad sträng.

TRANSLATE (teckensträng, från_text, till_text)

Här är några exempel:

SELECT TRANSLATE("12345abcde", "5a", "XX"); "1234XXbcde" SELECT TRANSLATE(title, "Dator", "PC") FROM titles WHERE type="Personal_computer" SELECT CONVERT("PostgreSQL" ANVÄNDA iso_8859_1_to_utf_8) "PostgreSQL"

SQL Server

SQL Server-plattformen stöder inte funktionen TRANSLATE. Implementeringen av CONVERT-funktionen i SQL Server är inte kompatibel med SQL 2003-standarden. Denna funktion i SQL Server är likvärdig med CAST-funktionen.

KONVERTERA (data_typ[(längd) | (precision, skala)], uttryck, stil])

Stilsatsen används för att definiera formatet för datumkonvertering. Mer information finns i SQL Server-dokumentationen. Nedan följer ett exempel.

SELECT title, CONVERT(char(7), ytd_sales) FROM titles ORDER BY title GO

SQL-strängfunktioner

Denna grupp av funktioner låter dig manipulera text. Det finns många strängfunktioner, vi ska titta på de vanligaste.

• CONCAT(str1,str2...) Returnerar en sträng skapad genom att sammanfoga argumenten (argumenten står inom parentes - str1,str2...). Till exempel, i vår leverantörstabell finns en stadskolumn och en adresskolumn. Anta att vi vill att den resulterande tabellen ska ha Adress och Stad i samma kolumn, dvs. vi vill kombinera data från två kolumner till en. För att göra detta kommer vi att använda strängfunktionen CONCAT() och som argument kommer vi att ange namnen på kolumnerna som ska kombineras - stad och adress:

  VÄLJ KONCAT(ort, adress) FRÅN leverantörer;

  
  

  Observera att sammanslagningen skedde utan splittring, vilket inte är särskilt läsbart. Låt oss justera vår fråga så att det finns ett mellanslag mellan kolumnerna som sammanfogas:

  SELECT CONCAT(stad, " ", adress) FRÅN leverantörer;

  
  

  Som du kan se anses ett mellanslag också vara ett argument och indikeras avgränsat med kommatecken. Om det fanns fler kolumner som skulle slås samman skulle det vara irrationellt att ange mellanslag varje gång. I det här fallet kan man använda strängfunktionen CONCAT_WS(separator, str1,str2...), som placerar en avgränsare mellan de sammanlänkade strängarna (avgränsaren anges som det första argumentet). Vår fråga kommer då att se ut så här:

  SELECT CONCAT_WS(" ", stad, adress) FRÅN leverantörer;

  Resultatet förändrades inte externt, men om vi skulle slå samman 3 eller 4 kolumner skulle koden reduceras avsevärt.



• INSERT(str, pos, len, ny_str) Returnerar strängen str med delsträngen som börjar vid position pos och har en längd av len-tecken ersatt av delsträngen new_str. Anta att vi bestämmer oss för att inte visa de tre första tecknen i adresskolumnen (förkortningar st., pr., etc.), då kommer vi att ersätta dem med mellanslag:

  SELECT INSERT(adress, 1, 3, " ") FRÅN leverantörer;

  
  

  Det vill säga tre tecken, med början från den första, ersätts med tre mellanslag.



• LPAD(str, len, dop_str) Returnerar strängen str, vänster vadderad med dop_str till längden len. Låt oss säga att vi vill visa leverantörsstäder till höger och fylla det tomma utrymmet med prickar:

  SELECT LPAD(stad, 15, "."") FROM leverantörer;

  
  


• RPAD(str, len, dop_str) Returnerar strängen str höger vadderad med dop_str till längden len. Låt oss säga att vi vill visa leverantörsstäder till vänster och fylla det tomma utrymmet med prickar:

  SELECT RPAD(stad, 15, "."") FROM leverantörer;

  
  

  Observera att len-värdet begränsar antalet tecken som visas, d.v.s. om stadsnamnet är längre än 15 tecken kommer det att trunkeras.



• LTRIM(str) Returnerar strängen str med alla inledande mellanslag borttagna. Denna strängfunktion är praktisk för att visa information korrekt i de fall där slumpmässiga mellanslag är tillåtna när data skrivs in:

  VÄLJ LTRIM(stad) FRÅN leverantörer;



• RTRIM(str) Returnerar strängen str med alla efterföljande mellanslag borttagna:

  VÄLJ RTRIM(stad) FRÅN leverantörer;

  I vårt fall fanns det inga extra utrymmen, så vi kommer inte att se resultatet externt.



• TRIM(str) Returnerar strängen str med alla inledande och efterföljande mellanslag borttagna:

  VÄLJ TRIM(stad) FRÅN leverantörer;



• LOWER(str) Returnerar strängen str med alla tecken omvandlade till gemener. Det fungerar inte korrekt med ryska bokstäver, så det är bättre att inte använda det. Låt oss till exempel tillämpa den här funktionen på kolumnen stad:

  VÄLJ stad, LÄGRE(stad) FRÅN leverantörer;

  
  Se vilken typ av gobbledygook det visade sig vara. Men allt är bra med det latinska alfabetet:

  SELECT LOWER("STAD");

  
  


• UPPER(str) Returnerar strängen str med alla tecken omvandlade till versaler. Det är också bättre att inte använda det med ryska bokstäver. Men allt är bra med det latinska alfabetet:

  VÄLJ ÖVRE (e-post) FRÅN kunder;

  
  


• LENGTH(str) Returnerar längden på strängen str. Låt oss till exempel ta reda på hur många tecken som finns i våra leverantörsadresser:

  VÄLJ adress, LENGTH(adress) FRÅN leverantörer;

  
  


• LEFT(str, len) Returnerar len left-tecken i strängen str. Låt till exempel endast de tre första tecknen visas i leverantörsstäder:

  SELECT name, LEFT(city, 3) FROM leverantörer;

  
  


• RIGHT(str, len) Returnerar len right-tecken i strängen str. Låt till exempel endast de tre sista tecknen visas i leverantörsstäder: SELECT LOAD_FILE("C:/proverka");
  Observera att du måste ange den absoluta sökvägen till filen.

Som redan nämnts finns det många fler strängfunktioner, men även några av de som diskuteras här används extremt sällan. Låt oss därför överväga dem här och gå vidare till mer vanliga datum- och tidsfunktioner.

I denna del kommer vi att prata om funktioner för att arbeta med textinformation som kan användas i frågor och programkod i PL/SQL-språket.

Funktion CONCAT(strl, str2)

Denna funktion sammanfogar strängarna strl och str2. Om ett av argumenten är NULL, behandlas det som en tom sträng. Om båda argumenten är NULL, returnerar funktionen NULL. Exempel:

SELECT CONCAT("Prästen hade en hund") x1,
CONCATCTest" , NULL) x2,
CONCAT(NULL, "Test") x3,
CONCAT(NULL, NULL) x4
FRÅN dubbel

Prästen hade en hund

För att sammanfoga strängar stöder Oracle en speciell sammanfogningsoperator "||", som fungerar på samma sätt som CONCAT-funktionen, till exempel:

SELECT CONCAT("Prästen "hade en hund") x1, "Prästen " || "hade en hund" x2
FRÅN dubbel

Blanda inte ihop sammanlänkningsoperatorn "||", vilket motsvarar anrop av CONCAT-funktionen, och operatorn "+" som används i aritmetiska operationer. I Oracle är dessa olika operatörer, men på grund av automatisk typgjutning är subtila fel möjliga, till exempel:

VÄLJ "5" + "3" x1
FRÅN dubbel

I det här fallet returneras det numeriska värdet 8 istället för textsträngen "53". Detta beror på att när Oracle upptäcker den aritmetiska operatorn "+", försöker Oracle automatiskt casta argumenten till typ NUMBER.

Funktion LOWER(str)

Funktionen LOWER konverterar alla tecken i str till gemener. Exempel:

SELECT LOWER("TeXt DATA") X
FRÅN dubbel

FungeraÖVRE(str)

Funktionen UPPER konverterar alla tecken i strängen str till versaler. Exempel:

VÄLJ ÖVRE("TEXDATA") X
FRÅN dubbel

INITCAP(str) funktion

Returnerar strängen str med de första bokstäverna i alla ord omvandlade till versaler. Funktionen är bekväm för att formatera hela namnet när du bygger rapporter. Exempel:

VÄLJ INITCAPCIVANOV peter sidorovich") X
FRÅN dubbel

FunktionerLTRIM(str [,set])OchRTRIM(str [,set])

LTRIM-funktionen tar bort alla tecken från början av en sträng upp till det första tecknet som inte finns i den uppsatta teckenuppsättningen. Som standard består uppsättningen av ett enda mellanslag och kanske inte anges. RTRIM-funktionen liknar LTRIM, men tar bort tecken från slutet av strängen. Låt oss titta på några exempel:

SELECT LTRIM(" Text DATA") X1,
LTRIM(" _ # TeXt DATA", " #_") X2,
LTRIM(" 1234567890 TeXt DATA", " 1234567890") X3
FRÅN dubbel

Funktion REPLACE(str, sök_str, [,ersätt_str])

REPLACE-funktionen söker efter ett search_str-mönster i strängen str och ersätter varje förekomst som hittas med replace_str. Som standard är replace_str den tomma strängen, så att anropa REPLACE med två argument tar bort alla förekomster som hittas. Sökningen efter en delsträng är skiftlägeskänslig. Exempel:

SELECT REPLACE("Prästen hade en hund", "hund", "katt") x1,
REPLACE("Prästen hade en ond hund", "ond") x2,
REPLACE("Prästen hade en hund", "Hund", "Katt") x3
FRÅN dubbel

Prästen hade en katt	Prästen hade en hund	Prästen hade en hund

Funktion TRANSLATE(str, from_mask, to_mask)

TRANSLATE-funktionen analyserar strängen str och ersätter alla tecken som förekommer i from_mask-strängen med motsvarande tecken från to_mask. För att funktionen ska fungera korrekt måste from_mask- och to_mask-strängarna vara lika långa, eller så måste from_mask-strängen vara längre än to_mask. Om from_mask är längre än to_mask, och under bearbetning av strängen str, hittas tecken som matchar ett av from_mask-tecken, och det inte finns någon matchning för dem i to_mask, kommer sådana tecken att tas bort från strängen str. Om du skickar från_mask eller till_mask lika med NULL, kommer funktionen att returnera NULL. Jämförelsen görs skiftlägeskänslig.

SELECT TRANSLATE("Test 12345", "e2\"E!") x1,
TRANSLATE("Test 12345", "e234", "E") x2
FRÅN dubbel

Denna funktion är praktisk för att lösa ett antal praktiska problem relaterade till teckenkonvertering eller sökning efter förbjudna tecken. Du måste till exempel analysera ett lösenord och ta reda på om det innehåller minst en siffra. Implementeringen av denna kontroll med TRANSLATE ser ut så här:

IF TRANSLATE(PassWd, "0123456789", "*") = PassWd THEN
ADD_ERR0R("Fel - Lösenordet måste innehålla minst en siffra!");
RETUR 1;
ENDIF;

Ett annat exempel: ett nummer förbereds för omvandling till NUMBER. Det är nödvändigt att ersätta decimalavgränsarna "," och "." på "." och ta bort mellanslag. Implementeringen av denna operation med hjälp av TRANSLATE ser ut så här:

SELECT TRANSLATE("123 455,23", "., ", " . . ") x1,
TRANSLATE("-123 455,23", "., ", " . . ") x2
FRÅN dubbel

Funktion SUBSTR(str, m [,n])

SUBSTR-funktionen returnerar ett fragment av strängen str, som börjar med tecknet m, med en längd på n tecken. Längden kan utelämnas - i det här fallet returneras strängen från tecknet m till slutet av strängen str. Tecken numreras från 1. Om du anger m = 0, kommer kopieringen fortfarande att börja från det första tecknet. Att ange ett negativt värde för m gör att tecken räknas från slutet av strängen snarare än från början. Att specificera värden på m som är större i absolut värde än längden på strängen gör att funktionen returnerar NULL.

SELECT SUBSTR("Prästen hade en hund", 13) x1,
SUBSTR("Prästen hade en hund", -6) x2,
SUBSTR("Detta är testtext", 5, 8) x3,
SUBSTR("Prästen hade en hund", 150) x4
FRÅN dubbel

		text

Funktion INSTR(str, sök_str [,n[,m]])

Funktionen INSTR returnerar positionen för det första tecknet m-ro i strängfragmentet str som matchar search_str. Jämförelsen utförs från det n:te tecknet i strängen str. Jämförelsen är skiftlägeskänslig. Som standard är n = m = 1, det vill säga sökningen utförs från början av raden och positionen för det första hittade fragmentet returneras. Om sökningen misslyckas returnerar funktionen 0.

SELECT INSTR("y rumpa var en hund", "hund") x1,
INSTR("y rumpa var en hund", "katt") x2,
INSTR("Detta är text för att demonstrera textsökning", "text", 1, 2) x3,
INSTR(‘11111000000001", "1", 7) x4
FRÅN dubbel

Med denna funktion, liksom med alla andra i Oracle, görs ofta vanliga fel associerade med hantering av NULL-värden. Om str=NULL kommer funktionen att returnera NULL, inte noll! Detta måste beaktas vid konstruktion av olika förhållanden. Till exempel tar detta fragment av ett PL/SQL-program inte hänsyn till denna funktion:

OM INSTR(TXT_VAR,"*") = 0 SEDAN
...
SLUTETOM;

I det här fallet skulle det vara korrekt att skriva så här:

OM NVL(INSTR(TXT_VAR, "*"), 0) = 0 DÅ
...
ENDIF;

LENGTH (str) och LENGTHB (str) funktioner

Funktionen LENGTH(str) returnerar längden på strängen str i tecken. För en tom sträng och ett NULL-värde returnerar funktionen NULL, så det rekommenderas att använda NVL i kombination med denna funktion.

SELECT LENGTH("Prästen hade en hund") x1,
LENGTH("") x2,
LENGTH(NULL) x3,
NVL(LENGTH(""), 0) x4
FRÅN dubbel

LENGTHB-funktionen liknar LENGTH-funktionen, men returnerar längden på strängen i byte.

ASCII(str) funktion

Returnerar ASCII-värdet för det första tecknet i strängen str när du använder ASCII-teckenkodning, och värdet för den första byten av ett multibytetecken när du använder multibyte-teckenkodning. Exempel:

VÄLJ ASCII("Test") x1 FRÅN dual

Funktion CHR(n)

Returnerar ett tecken med dess kod.

VÄLJ CHR(64) x1
FRÅN dubbel

Här är en komplett lista över strängfunktioner hämtade från BOL:

Resultatet är 11. För att ta reda på vilka bokstäver det är kan vi använda CHAR-funktionen, som returnerar tecknet med en känd ASCII-kod (från 0 till 255):

Så här kan du till exempel få en tabell med koder för alla alfabetiska tecken:

SELECT CHAR(ASCII("a")+ siffra-1) bokstav, ASCII("a")+ num - 1 FRÅN (VÄLJ 5*5*(a-1)+5*(b-1) + c AS num FRÅN (VÄLJ 1 a UNION ALLA VÄLJ 2 UNION ALLA VÄLJ 3 UNION ALLA VÄLJ 4 UNION ALLA VÄLJ 5) x CROSS JOIN (VÄLJ 1 b UNION ALLA VÄLJ 2 UNION ALLA VÄLJ 3 UNION ALLA VÄLJ 4 UNION ALLA VÄLJ 5) y CROSS JOIN ( VÄLJ 1 c UNION ALLA VÄLJ 2 UNION ALLA VÄLJ 3 UNION ALLA VÄLJ 4 UNION ALLA VÄLJ 5) z) x WHERE ASCII("a")+ num -1 MELLAN ASCII("a") OCH ASCII("z")

Jag hänvisar de som ännu inte är medvetna om genereringen av en nummersekvens till motsvarande artikel.

Som ni vet är koderna för gemener och stora bokstäver olika. Därför, för att få hela uppsättningen utan att skriva om begäran, behöver du bara lägga till en liknande till ovanstående kod:

Jag tror att det inte skulle vara alltför svårt att lägga till detta brev till bordet om det skulle behövas.

Låt oss nu överväga uppgiften att bestämma var den önskade delsträngen ska hittas i ett stränguttryck. Två funktioner kan användas för detta - CHARINDEX Och PATINDEX. De returnerar båda startpositionen (positionen för det första tecknet i delsträngen) för delsträngen i strängen. CHARINDEX-funktionen har syntaxen:

CHARINDEX ( sökuttryck, string_expression[, startposition])

Här är en valfri heltalsparameter startposition definierar positionen i ett stränguttryck från vilket sökningen utförs sökuttryck. Om denna parameter utelämnas utförs sökningen från början string_expression. Till exempel begäran

Det bör noteras att om den sökta delsträngen eller stränguttrycket är NULL, kommer resultatet av funktionen också att vara NULL.

Följande exempel bestämmer positionerna för den första och andra förekomsten av tecknet "a" i fartygsnamnet "California"

Men, till exempel, hur kan du hitta namnen på fartyg som innehåller en sekvens av tre tecken, varav den första och sista är "e":

Ångbad till VÄNSTER fungera HÖGER returnerar det angivna antalet tecken till höger från ett stränguttryck:

HÖGER(<stränguttryck>,<antal tecken>)

Här är till exempel hur du kan bestämma namnen på fartyg som börjar och slutar med samma bokstav:

Här separerar vi klassnamnet och fartygsnamnet med ett mellanslag. Dessutom, för att inte upprepa hela konstruktionen som ett funktionsargument, använder vi en underfråga. Resultatet kommer att se ut så här:

För att eliminera detta fall kan du använda en annan användbar funktion LEN (<stränguttryck>) , som returnerar antalet tecken i strängen. Låt oss begränsa oss till fallet när antalet tecken är större än ett:

Fungera ÅTERSKAPA fyller konstanten "abcde" med fem mellanslag till höger, som inte beaktas av funktionen LEN, - i båda fallen får vi 5.
Fungera DATALÄNGD returnerar antalet byte i variabelns representation och visar oss skillnaden mellan CHAR- och VARCHAR-typer. DATALÄNGD ger oss 12 för CHAR-typen och 10 för VARCHAR-typen.
Som förväntat, DATALÄNGD för en variabel av typen VARCHAR, returnerade den faktiska längden på variabeln. Men varför blev resultatet 12 för en variabel av typen CHAR? Poängen är att CHAR är en typ bestämd längd. Om värdet på en variabel är mindre än dess längd, och vi deklarerade längden som CHAR(12), kommer värdet på variabeln att "justeras" till den önskade längden genom att lägga till efterföljande mellanslag.

Det finns uppgifter på webbplatsen där du måste ordna (hitta maximalt, etc.) i numerisk ordning värdena som presenteras i textformat. Till exempel flygplanssätesnummer ("2d") eller CD-hastighet ("24x"). Problemet är att texten är sorterad så här (stigande)

Om du vill ordna platserna i stigande ordning av rader, bör ordningen vara så här

Om vi ​​begränsar oss till detta får vi

Allt som återstår är att sortera

Idag föreslår jag att titta på enkla exempel på användning Transact-SQL-strängfunktioner, och inte bara en beskrivning och exempel på vissa funktioner, utan deras kombination, dvs. hur kan de kapslas in i varandra, eftersom det inte räcker med standardfunktioner för att implementera många uppgifter och de måste användas tillsammans. Och så skulle jag vilja visa dig ett par enkla exempel på hur du skriver sådana frågor.

Du och jag har redan tittat på SQL-strängfunktioner, men eftersom implementeringarna av det här språket i olika DBMS:er är olika, till exempel, finns vissa funktioner inte i Transact-SQL, utan de är i PL/PGSql, och förra gången vi tittade på strängfunktioner som kan användas i plpgsql och därför kommer vi idag att prata specifikt om Transact-SQL.

Hur man kombinerar SUBSTRING, CHARINDEX och LEN

Och så behöver du till exempel söka efter en del av en sträng enligt ett visst kriterium och klippa ut den, och inte bara söka efter en del av samma typ, utan dynamiskt, d.v.s. Söksträngen kommer att vara olika för varje sträng. Vi kommer att skriva exempel i Management Studio SQL Server 2008.

För att göra detta kommer vi att använda följande funktioner:

• SUBSTRING(str, start, len) – denna funktion skär en del av en sträng från en annan sträng. Har tre parametrar 1. Detta är själva strängen; 2. Startpositionen för att börja skära; 3. Antalet tecken du behöver klippa.
• CHARINDEX(str1, str2) - söker efter str1 i str2 och returnerar serienumret för det första tecknet om en sådan sträng hittas. Den har en tredje valfri parameter, med vilken du kan ange vilken sida du ska starta sökningen från.
• LEN(str1) - stränglängd, dvs. Tecken.

Som du kan se använde jag här variabeldeklarationer, och du kan ersätta dina egna fält i begäran istället för variabler. Här är själva koden:

Deklarera @rezult som varchar(10) -- källsträng deklarera @str1 som varchar(100) --söksträng deklarera @str2 som varchar(10) set @str1 = "Testa sträng för att söka efter en annan sträng i den" set @str2 = "sträng" set @rezult=substring(@str1,CHARINDEX(@str2, @str1), LEN(@str2)) välj @rezult

Poängen här är denna: med hjälp av len-funktionen tar vi reda på hur många tecken som behöver klippas, och charindex ställer in positionen från vilken vi måste börja klippa, och följaktligen utför delsträngen själva valet i strängen.

Hur man kombinerar VÄNSTER, HÖGER och LEN

Låt oss säga att du behöver få de första tecknen i en sträng eller kontrollera de första tecknen i en sträng för närvaron av något, till exempel någon form av nummer, och dess längd är naturligtvis annorlunda (exemplet är naturligtvis, ett test).

• Vänster(str, kol) – funktioner skär ut det angivna antalet tecken från vänster, har två parametrar, den första är strängen och den andra är antalet tecken;
• Höger(str, kol) - funktioner skär ut det angivna antalet tecken från höger, parametrarna är desamma.

Nu kommer vi att använda enkla frågor mot tabellen

Låt oss först skapa en tabell test_table:

SKAPA TABELL ( IDENTITET(1,1) INTE NULL, (18, 0) NULL, (50) NULL, BEGRÄNSNING PRIMÄRNYCKEL KLUSTERAD ( ASC) MED (PAD_INDEX = AV, STATISTICS_NORECOMPUTE = AV, IGNORE_DUP_KEY = AV_AV, LOCKLOCKLOCK_AV_, AVLÅT_ = PÅ) PÅ ) PÅ GÅR

Låt oss fylla den med testdata och skriva följande frågor:

Som du förstår är den första frågan helt enkelt ett urval av alla rader (SQL Basics - select-sats), och den andra är en direkt kombination av våra funktioner, här är koden:

Välj * från test_table välj nummer, left(text,LEN(nummer)) som str från test_table

Och om dessa siffror var till höger skulle vi använda funktionen HÖGER.

Använder Rtrim, Ltrim, Upper och Lower i kombination

Låt oss säga att du har en rad med mellanslag i början och i slutet, och du skulle naturligtvis vilja bli av med dem och till exempel göra den första bokstaven i den här raden versal.

• Rtrim(str) – tar bort mellanslag från höger;
• Ltrim(str) – tar bort mellanslag till vänster;
• Övre(str) – konverterar strängen till versaler;
• Lägre(str) - konverterar strängen till gemener.

Som du kan se, för att säkra här använde vi också Delsträng Och Len. Innebörden av frågan är enkel, vi tar bort mellanslag till både höger och vänster, sedan konverterar vi det första tecknet till versaler genom att klippa ut det, sedan sammanfogar vi (operatorn +) detta tecken med den återstående strängen. Här är koden:

Deklarera @str1 som varchar(100) set @str1 = " teststräng med inledande och efterföljande mellanslag " välj @str1 välj upper(substring(rtrim(ltrim(@str1)),1,1))+ lower(substring( rtrim( ltrim(@str1)),2,LEN(rtrim(ltrim(@str1)))-1))

Jag tror att det räcker för idag, och om du gillar att programmera i SQL, så har vi på denna sida berört detta mycket intressanta ämne mer än en gång, till exempel.