TRIM-funktionen i SQL Server er designet til at fjerne indledende og efterfølgende mellemrum fra en tegnstreng. Et indledende mellemrum er mellemrum, der opstår før den faktiske streng. Der opstår et bagende mellemrum efter.
I denne artikel skal vi undersøge TRIM-funktionen og illustrere brugen af den med praktiske eksempler. Så lad os starte fra det grundlæggende.
TRIM-funktion i SQL Server
SQL TRIM er en indbygget funktion, der giver os mulighed for at trimme de unødvendige tegn på begge sider af strengen med én handling. Oftest bruger vi det til at fjerne mellemrum. Denne funktion dukkede op i SQL Server 2017, og nu er den også til stede i Azure SQL Database.
Syntaksen for SQL TRIM-funktionen er som følger:
TRIM ( [ tegn FRA ] streng )
- tegn FRA er valgfri parameter, der definerer hvilke tegn vi skal slette. Som standard gælder denne parameter for mellemrum på begge sider af vores streng.
- streng er en obligatorisk parameter, der bestemmer strengen, hvor vi skal slippe af med mellemrum/andre unødvendige tegn.
Det returnerede output er en streng uden de tegn, vi besluttede at skulle trimmes i begyndelsen og slutningen. Se eksemplet:
VÆLG TRIM( ' eksempel ') SOM Resultat; Outputtet er:
eksempel
Som vi nævnte, kan TRIM-funktionen også fjerne andre tegn. Tag et kig på eksemplet, hvor vi vil rense strengen for unødvendige tegn og mellemrum:
VÆLG TRIM( '.,# ' FRA '# ! eksempel .') SOM Resultat; Outputtet er:
! eksempel
SQL TRIM-funktionen er tilgængelig i SQL Server fra og med version 2017, men det var også muligt at udføre opgaven før den udgivelse. Brugere kunne anvende SQL LTRIM og SQL RTRIM funktioner. De findes i alle understøttede versioner af SQL Server.
LTRIM-funktion i SQL Server
SQL LTRIM funktion tjener til at fjerne unødvendige mellemrum på venstre side af strengen. Syntaksen er som følger:
LTRIM( streng )
streng er den obligatoriske parameter, der specificerer målstrengen af tegn, vi skal trimme i venstre side. Outputtet er en kopi af den angivne streng, men uden mellemrum i begyndelsen:
SELECT LTRIM(' SQL-funktion'); Output:
'SQL-funktion'
RTRIM-funktion i SQL Server
SQL RTRIM funktion fungerer på samme måde som LTRIM - forskellen er, at den fjerner mellemrum på højre side af strengen. Syntaksen er nedenfor:
RTRIM(streng)
streng er den påkrævede parameter, der peger på den streng af tegn, hvor vi skal fjerne de efterfølgende mellemrum.
VÆLG RTRIM('SQL-server '); Output:
'SQL-server'
Brug af LTRIM og RTRIM sammen
Når vi arbejder med SQL Server, skal vi ofte kun fjerne mellemrum fra den ene side af strengen. Alligevel er der tilfælde, hvor vi skal rydde strengen på begge sider. TRIM-funktionen, vi beskrev tidligere, tjener dette mål, men som vi husker, er den kun tilgængelig i SQL Server 2017 og nyere.
Er der en måde at fjerne både førende og bagerste mellemrum for en streng uden TRIM-funktionen? Ja. Vi kan bruge LTRIM og RTRIM sammen i én forespørgsel.
Syntaksen er:
LTRIM(RTRIM(streng))
streng definerer den målstreng af tegn, vi ønsker at fjerne fra unødvendige mellemrum på begge sider. Bemærk også, at vi kan placere LTRIM og RTRIM i enhver rækkefølge .
VÆLG LTRIM(RTRIM(' SQL Server ')); Output:
'SQL-server'
Nu hvor vi har klarlagt essensen af alle disse SQL-funktioner (TRIM, LTRIM og RTRIM), lad os dykke dybere.
Hvorfor hvide mellemrum er vigtige
Man kan spørge, hvorfor det kan være vigtigt at fjerne sådanne mellemrum. Enkelt sagt skyldes det, at de kan udgøre en gene, når man fx sammenligner værdier. Whitespace i sig selv betragtes som en del af en streng, hvis det er der, så det er bedre at bekymre sig om sådanne problemer.
Lad os undersøge disse funktioner ordentligt.
Først opretter vi en simpel tabel for de databasetyper, der køres i vores virksomhed. Vores tabel har tre kolonner. Den første er den ID-kolonne, der kræves for at identificere hver række unikt. Den anden er DBTypeNameA . Den tredje er DBTypeNameB .
De sidste to kolonner er forskellige afhængigt af datatypen. DBTypeNameA bruger først VARCHAR datatype og DBTypeNameB bruger CHAR datatype.
For begge kolonner allokerer vi datalængden på 50.
- Liste 1:Opret en simpel tabelBrug DB2GOCREATE TABEL DBType (ID INT IDENTITY(1,1),DBTypeNameA VARCHAR (50),DBTypeNameB CHAR (50))GO Bemærk forskellen mellem disse datatyper.
- For VARCHAR-kolonnen allokerer SQL Server ikke pladsen til 50 tegn, som vi forventer i kolonnen ab initio. Vi siger, at kolonnen skal tænke på et maksimum på 50 tegn, men tildel plads efter behov.
- For CHAR-kolonnen er der sørget for 50 tegn, hver gang en række indsættes, uanset om den faktiske værdi har brug for den plads eller ej.
Brugen af VARCHAR (Variable Characters) er således en måde at spare plads på.
Efter at have oprettet tabellen, udfylder vi den samme ved hjælp af koden i liste 2.
-- Liste 2:Udfyld tabellenUSE DB2GOINSERT INTO DBType VALUES ('SQL Server','SQL Server');INSERT INTO DBType VALUES (' SQL Server ',' SQL Server ');INSERT INTO DBType VALUES (' SQL Server ',' SQL Server ');INSERT INTO DBType VALUES ('Oracle','Oracle');INSERT INTO DBType VALUES (' Oracle ',' Oracle ');INSERT INTO DBType VALUES (' Oracle ',' Oracle ');INSERT INTO DBType VALUES ('MySQL','MySQL');INSERT INTO DBType VALUES (' MySQL ',' MySQL ');INSERT INTO DBType VALUES (' MySQL ',' MySQL '); Mens vi udfyldte vores tabel, har vi bevidst indtastet værdier med førende og efterfølgende mellemrum. Vi bruger dem i vores demonstration.
Når vi forespørger i tabellen (se liste 3), kan vi se "forvrængning" i dataene som gengivet i SSMS (figur 1).
-- Liste 3:Forespørg på tabellenUSE DB2GOSELECT * FRA DBType; 
Denne forvrængning er synlig, fordi vi har førende mellemrum. Efterfølgende rum er sværere at visualisere på denne måde.
Forespørgslen er Listing 4 giver et dybere blik på denne "forvrængning". Den introducerer LEN- og DATALENGTH-funktionerne:
- LEN() returnerer antallet af tegn i en streng eksklusiv efterfølgende mellemrum.
- DATALENGTH() returnerer antallet af bytes, der bruges til at repræsentere et udtryk.
-- Liste 4:Forespørg på tabellen. Brug DB2GOSELECT DBTypeNameA, LEN(DBTypeNameA) LenVarcharCol, DATALENGTH(DBTypeNameA) DataLenVarcharCol, DBTypeNameB, LEN(DBTypeNameB) LenCharCol, DBTKolypeNameB Figur 2 viser variationer i længden for sådanne udtryk som "SQL Server", "Oracle" og "MySQL" på grund af de førende og efterfølgende mellemrum.
Dette indebærer, at disse udtryk ikke er de samme, hvad angår SQL Server-forespørgselsmotoren. Vi kan se dette tydeligt ved at køre koden i liste 5.
-- Liste 5:Forespørgsel til specifik BRUG DB2GOSELECT * FRA DBType WHERE DBTypeNameA='SQL Server';SELECT * FRA DBType WHERE DBTypeNameA='Oracle';SELECT * FROM DBType WHERE DBTypeNameA='MySQL'; /kode> DataLenCharCol feltet repræsenterer output fra funktionen DATALENGTH() på CHAR-kolonnen. Derfor er en konsekvens af denne forskel mellem "SQL Server" og "SQL Server" forespørgselsresultatet vist i figur 3.
Vi ser, at selvom vi har tre rækker med hver databasetype, returnerer vores forespørgsler kun én af hver, fordi indledende og efterfølgende mellemrum adskiller værdierne.
Løsning af problemet
Det er muligt og nemt at få korrekte resultater for forespørgslen i liste 5. Vi har brug for SQL Server TRIM()-funktionen som vist i liste 6.
-- Liste 6:Forespørgsel til specifik BRUG DB2GOSELECT * FRA DBType WHERE TRIM(DBTypeNameA)='SQL Server';VÆLG * FRA DBType WHERE TRIM(DBTypeNameA)='Oracle';SELECT * FRA DBType WHERE TRIM (DBTypeNameA)='MySQL'; 
Uden denne TRIM()-funktion kunne vi få forkerte resultater i nogle scenarier.
Vi kan tage dette videre ved at indlæse data i en separat tabel, forudsat at vi ønskede at løse problemet permanent (en slags dataoprydning).
-- Liste 7:Forespørgsel til specifik BRUG DB2GOSELECT ID, TRIM(DBTypeNameA) DBTypeNameA, TRIM(DBTypeNameB) DBTypeNameB FROM DBType; 
Sammenlign resultaterne fra liste 7 (figur 5) med resultaterne fra liste 3 (figur 1). Vi kan også oprette en anden tabel med dette resultatsæt for at rydde op i dataene (se liste 8).
-- Liste 8:Opret en ny tabel (Dataoprydning)BRUG DB2GOSELECT ID, TRIM(DBTypeNameA) DBTypeNameA, TRIM(DBTypeNameB) DBTypeNameB INTO DBType_New FROM DBType;SELECT * FROM DBType_New; På denne måde kan vi løse vores problemer permanent og fjerne omkostningerne ved at udføre funktioner, hver gang vi skal udtrække data fra vores tabel.
Konklusion
SQL Server TRIM()-funktionerne kan bruges til at fjerne både indledende og efterfølgende mellemrum fra strenge. LTRIM og RTRIM er to varianter af denne funktion, der fokuserer på henholdsvis førende (VENSTRE) og efterfølgende (HØJRE) mellemrum.
Vi kan anvende TRIM() on the fly for at rydde op i resultatsættet og sikre, at vi får det korrekte resultatsæt. Vi kan også bruge det til at fjerne mellemrum, mens vi flytter dataene pænt fra en tabel til en anden.
Relaterede artikler
Hvordan analyserer man strenge som en professionel ved hjælp af SQL SUBSTRING()-funktionen?