SQL string functions are used primarily for string manipulation. The following table details the important string functions −
| Sr.No., SUBSTR()
Returns the substring as specified |
|
|---|---|
| 46 | TRIM()
Removes leading and trailing spaces |
| 47 | UCASE()
Synonym for UPPER() |
| 48 | UNHEX()
Converts each pair of hexadecimal digits to a character |
| 49 | UPPER()
Converts to uppercase |
ASCII(str)
Returns the numeric value of the leftmost character of the string str., Returnează 0 dacă str este șirul gol. Returnează NULL dacă str este nul. ASCII () funcționează pentru caractere cu valori numerice de la 0 la 255.
SQL> SELECT ASCII('2');+---------------------------------------------------------+| ASCII('2') |+---------------------------------------------------------+| 50 |+---------------------------------------------------------+1 row in set (0.00 sec)SQL> SELECT ASCII('dx');+---------------------------------------------------------+| ASCII('dx') |+---------------------------------------------------------+| 100 |+---------------------------------------------------------+1 row in set (0.00 sec)
BIN(N)
returnează o reprezentare șir a valorii binare a lui N, unde N este un număr LONGLONG (BIGINT). Aceasta este echivalentă cu CONV (N,10,2). Returnează NULL dacă N este NULL.
SQL> SELECT BIN(12);+---------------------------------------------------------+| BIN(12) |+---------------------------------------------------------+| 1100 |+---------------------------------------------------------+1 row in set (0.00 sec)
BIT_LENGTH(str)
Returnează lungimea șirului str în biți.
SQL> SELECT BIT_LENGTH('text');+---------------------------------------------------------+| BIT_LENGTH('text') |+---------------------------------------------------------+| 32 |+---------------------------------------------------------+1 row in set (0.00 sec)
CHAR(N,…, )
CHAR () interpretează fiecare argument N ca un număr întreg și returnează un șir format din caracterele date de valorile de cod ale acelor numere întregi. Valorile nule sunt omise.
SQL> SELECT CHAR(77,121,83,81,'76');+---------------------------------------------------------+| CHAR(77,121,83,81,'76') |+---------------------------------------------------------+| MySQL |+---------------------------------------------------------+1 row in set (0.00 sec)
CHAR_LENGTH(str)
returnează lungimea str șir măsurată în caractere. Un caracter multi-octet contează ca un singur caracter. Aceasta înseamnă că pentru un șir care conține cinci caractere de doi octeți, LENGTH() returnează 10, în timp ce CHAR_LENGTH () returnează 5.
SQL> SELECT CHAR_LENGTH("text");+---------------------------------------------------------+| CHAR_LENGTH("text") |+---------------------------------------------------------+| 4 |+---------------------------------------------------------+1 row in set (0.00 sec)
CHARACTER_LENGTH(str)
CHARACTER_LENGTH() este un sinonim pentru CHAR_LENGTH().,
CONCAT(str1,str2,…)
returnează șirul care rezultă din concatenarea argumentelor. Poate avea unul sau mai multe argumente. Dacă toate argumentele sunt șiruri non-binare, rezultatul este un șir non-binar. Dacă argumentele includ orice șiruri binare, rezultatul este un șir binar. Un argument numeric este transformat în echivalentul său binar șir de formă; dacă doriți, pentru a evita acest lucru, puteți utiliza un tip explicit exprimate, ca în acest exemplu,
SQL> SELECT CONCAT('My', 'S', 'QL');+---------------------------------------------------------+| CONCAT('My', 'S', 'QL') |+---------------------------------------------------------+| MySQL |+---------------------------------------------------------+1 row in set (0.00 sec)
CONCAT_WS(separator,str1,str2,…,)
CONCAT_WS () înseamnă concatenat cu Separator și este o formă specială de CONCAT(). Primul argument este separatorul pentru restul argumentelor. Separatorul este adăugat între șirurile care urmează să fie concatenate. Separatorul poate fi un șir, ca și restul argumentelor. Dacă separatorul este nul, rezultatul este nul.
SQL> SELECT CONCAT_WS(',','First name','Last Name' );+---------------------------------------------------------+| CONCAT_WS(',','First name','Last Name' ) |+---------------------------------------------------------+| First name,Last Name |+---------------------------------------------------------+1 row in set (0.00 sec)
CONV(N,from_base,to_base)
Convertește numere între diferite numărul de baze. Returnează o reprezentare șir de numărul N, convertit de la bază from_base la to_base. Returnează NULL dacă orice argument este NULL., Argumentul N este interpretat ca un număr întreg, dar poate fi specificat ca un număr întreg sau un șir. Baza minimă este 2, iar baza maximă este 36. Dacă to_base este un număr negativ, N este considerat ca un număr semnat. În caz contrar, N este tratat ca nesemnat. CONV () funcționează cu o precizie de 64 de biți.
SQL> SELECT CONV('a',16,2);+---------------------------------------------------------+| CONV('a',16,2) |+---------------------------------------------------------+| 1010 |+---------------------------------------------------------+1 row in set (0.00 sec)
ELT(N,str1,str2,str3,…)
returnează str1 dacă N = 1, str2 dacă N = 2 și așa mai departe. Returnează NULL dacă N este mai mică 1 sau mai mare decât numărul de argumente. ELT () este complementul câmpului ().,
SQL> SELECT ELT(1, 'ej', 'Heja', 'hej', 'foo');+---------------------------------------------------------+| ELT(1, 'ej', 'Heja', 'hej', 'foo') |+---------------------------------------------------------+| ej |+---------------------------------------------------------+1 row in set (0.00 sec)
EXPORT_SET(bits,pe,off])
Returnează un șir astfel încât pentru fiecare set în valoare de biți, veți obține un șir și pentru fiecare bit setat în valoare, veți obține un șir de caractere. Biți în biți sunt examinați de la dreapta la stânga (de la biți de ordin scăzut la biți de ordin înalt). Șiruri de caractere sunt adăugate la rezultatul de la stânga la dreapta, separate de șirul separator (implicit fiind caracterul virgulă .,.). Numărul de biți examinați este dat de number_of_bits (implicit la 64).
SQL> SELECT EXPORT_SET(5,'Y','N',',',4);+---------------------------------------------------------+| EXPORT_SET(5,'Y','N',',',4) |+---------------------------------------------------------+| Y,N,Y,N |+---------------------------------------------------------+1 row in set (0.00 sec)
TEREN(str,str1,str2,str3,…,)
returnează indexul (poziția începând cu 1) de str în str1, str2, str3,… listă. Returnează 0 dacă str nu este găsit.
SQL> SELECT FIELD('ej', 'Hej', 'ej', 'Heja', 'hej', 'foo');+---------------------------------------------------------+| FIELD('ej', 'Hej', 'ej', 'Heja', 'hej', 'foo') |+---------------------------------------------------------+| 2 |+---------------------------------------------------------+1 row in set (0.00 sec)
FIND_IN_SET(str,strlist)
Returnează o valoare în intervalul de la 1 la N dacă șirul str este în lista string strlist constând din N siruri de caractere.
SQL> SELECT FIND_IN_SET('b','a,b,c,d');+---------------------------------------------------------+| SELECT FIND_IN_SET('b','a,b,c,d') |+---------------------------------------------------------+| 2 |+---------------------------------------------------------+1 row in set (0.00 sec)
FORMAT(X,D)
SQL> SELECT FORMAT(12332.123456, 4);+---------------------------------------------------------+| FORMAT(12332.123456, 4) |+---------------------------------------------------------+| 12,332.1235 |+---------------------------------------------------------+1 row in set (0.00 sec)
HEX(N_or_S)
Dacă N_or_S este un număr, întoarce un șir de reprezentare de valoarea hexazecimală a N, unde N este un longlong (BIGINT) numărul. Aceasta este echivalentă cu CONV (N,10,16).,
Dacă N_or_S este un șir de caractere, se întoarce un șir hexazecimal reprezentarea N_or_S în cazul în care fiecare personaj în N_or_S este convertit la două cifre hexazecimale.
SQL> SELECT HEX(255);+---------------------------------------------------------+| HEX(255) |+---------------------------------------------------------+| FF |+---------------------------------------------------------+1 row in set (0.00 sec)SQL> SELECT 0x616263;+---------------------------------------------------------+| 0x616263 |+---------------------------------------------------------+| abc |+---------------------------------------------------------+1 row in set (0.00 sec)
INSERT(str,pos,len,newstr)
a se Întoarce string str, cu subșir începând de la poziția pos și len caractere înlocuite cu șirul newstr. Returnează șirul original dacă pos nu se află în lungimea șirului. Înlocuiește restul șirului din poziția pos dacă len nu se află în lungimea restului șirului. Returnează NULL dacă orice argument este NULL.,
SQL> SELECT INSERT('Quadratic', 3, 4, 'What');+---------------------------------------------------------+| INSERT('Quadratic', 3, 4, 'What') |+---------------------------------------------------------+| QuWhattic |+---------------------------------------------------------+1 row in set (0.00 sec)
INSTR(str,substr)
returnează poziția primei apariții a substring substr în string str. Aceasta este aceeași cu forma cu două argumente a LOCATE (), cu excepția faptului că ordinea argumentelor este inversată.
SQL> SELECT INSTR('foobarbar', 'bar');+---------------------------------------------------------+| INSTR('foobarbar', 'bar') |+---------------------------------------------------------+| 4 |+---------------------------------------------------------+1 row in set (0.00 sec)
LCASE(str)
LCASE() este un sinonim pentru LOWER().
LEFT (str,len)
returnează caracterele Len din stânga șirului str, sau NULL dacă orice argument este nul.
SQL> SELECT LEFT('foobarbar', 5);+---------------------------------------------------------+| LEFT('foobarbar', 5) |+---------------------------------------------------------+| fooba |+---------------------------------------------------------+1 row in set (0.00 sec)
LENGTH(str)
returnează lungimea șirului str, măsurată în octeți., Un caracter multi-octet contează ca mai mulți octeți. Aceasta înseamnă că pentru un șir care conține cinci caractere de doi octeți, LENGTH() returnează 10, în timp ce CHAR_LENGTH () returnează 5.
SQL> SELECT LENGTH('text');+---------------------------------------------------------+| LENGTH('text') |+---------------------------------------------------------+| 4 |+---------------------------------------------------------+1 row in set (0.00 sec)
LOAD_FILE(file_name)
Citește fișierul și returnează conținutul fișierului ca șir. Pentru a utiliza această funcție, fișierul trebuie să fie localizat pe gazda serverului, trebuie să specificați numele complet al fișierului și trebuie să aveți privilegiul fișierului. Fișierul trebuie să poată fi citit de toți și dimensiunea sa mai mică decât octeții max_allowed_packet.,
Dacă fișierul nu există sau nu poate fi citit deoarece una dintre condițiile precedente nu este îndeplinită, funcția returnează NULL.
începând cu SQL 5.0.19, variabila de sistem character_set_filesystem controlează interpretarea numelor de fișiere care sunt date ca șiruri literale.
SQL> UPDATE table_test -> SET blob_col=LOAD_FILE('/tmp/picture')-> WHERE id=1;...........................................................
LOCATE(substr,str), LOCATE(substr,str,pos)
prima sintaxă returnează poziția primei apariții a substring substr în string str. A doua sintaxă returnează poziția primei apariții a substring substr în string str, începând de la poziția pos., Returnează 0 dacă substr nu este în str.
SQL> SELECT LOCATE('bar', 'foobarbar');+---------------------------------------------------------+| LOCATE('bar', 'foobarbar') |+---------------------------------------------------------+| 4 |+---------------------------------------------------------+1 row in set (0.00 sec)
LOWER(str)
returnează str-ul șirului cu toate caracterele modificate cu litere mici în funcție de maparea curentă a setului de caractere.
SQL> SELECT LOWER('QUADRATICALLY');+---------------------------------------------------------+| LOWER('QUADRATICALLY') |+---------------------------------------------------------+| quadratically |+---------------------------------------------------------+1 row in set (0.00 sec)
LPAD(str,len,padstr)
a se Întoarce string str, stânga-căptușit cu șirul padstr la o lungime de len caractere. Dacă str este mai lung decât Len, valoarea returnată este scurtată la caracterele len.
SQL> SELECT LPAD('hi',4,'??');+---------------------------------------------------------+| LPAD('hi',4,'??') |+---------------------------------------------------------+| ??hi |+---------------------------------------------------------+1 row in set (0.00 sec)
LTRIM(str)
returnează str șir cu caractere spațiu de conducere eliminate.,
SQL> SELECT LTRIM(' barbar');+---------------------------------------------------------+| LTRIM(' barbar') |+---------------------------------------------------------+| barbar |+---------------------------------------------------------+1 row in set (0.00 sec)
MAKE_SET(bits,str1,str2,…)
returnează o valoare setată (un șir care conține substrings separate prin .,. caractere) constând din șiruri care au bitul corespunzător în biți setat. str1 corespunde bitului 0, str2 la bitul 1 și așa mai departe. Valori nule în str1, str2,… nu sunt anexate la rezultat.
SQL> SELECT MAKE_SET(1,'a','b','c');+---------------------------------------------------------+| MAKE_SET(1,'a','b','c') |+---------------------------------------------------------+| a |+---------------------------------------------------------+1 row in set (0.00 sec)
MID(str,pos,len)
MID(str,pos,len) este un sinonim pentru SUBSTRING(str,pos,len).
OCT (N)
returnează o reprezentare șir a valorii octale a lui N, unde N este un număr LONGLONG (BIGINT)., Aceasta este echivalentă cu CONV (N,10,8). Returnează NULL dacă N este NULL.
SQL> SELECT OCT(12);+---------------------------------------------------------+| OCT(12) |+---------------------------------------------------------+| 14 |+---------------------------------------------------------+1 row in set (0.00 sec)
OCTET_LENGTH(str)
OCTET_LENGTH() este un sinonim pentru LUNGIME().
ORD(str)
Dacă cel mai din stânga caractere ale șirului str este un multi-byte de caractere, returnează un cod pentru acel personaj, calculată din valorile numerice ale sale constitutive bytes folosind formula asta −
(1st byte code)+ (2nd byte code . 256)+ (3rd byte code . 2562) ...
Dacă cel mai din stânga caractere nu este un multi-byte de caractere, ORD() returnează valoarea ASCII() funcție.,
SQL> SELECT ORD('2');+---------------------------------------------------------+| ORD('2') |+---------------------------------------------------------+| 50 |+---------------------------------------------------------+1 row in set (0.00 sec)
POSITION(substr în str)
POSITION(substr în str) este un sinonim pentru localiza(substr,str).
QUOTE (str)
citează un șir pentru a produce un rezultat care poate fi folosit ca o valoare de date scăpată în mod corespunzător într-o instrucțiune SQL. Șirul este returnat închis de ghilimele unice și cu fiecare instanță a unui singur citat (‘), backslash (‘\’), ASCII NUL și Control-Z precedat de un backslash. Dacă argumentul este nul, valoarea returnată este cuvântul „NULL” fără a include ghilimele unice.,
SQL> SELECT QUOTE('Don\'t!');+---------------------------------------------------------+| QUOTE('Don\'t!') |+---------------------------------------------------------+| 'Don\'t!' |+---------------------------------------------------------+1 row in set (0.00 sec)
notă − verificați dacă instalarea dvs. are vreo eroare cu această funcție, apoi nu utilizați această funcție.
expr regexp pattern
această funcție efectuează o potrivire model de expr împotriva model. Returnează 1 dacă expr meciuri pat; în caz contrar se întoarce 0. Dacă expr sau pat este nul, rezultatul este nul. REGEXP nu este sensibil la majuscule, cu excepția cazului în care este utilizat cu șiruri binare.,
SQL> SELECT 'ABCDEF' REGEXP 'A%C%%';+---------------------------------------------------------+| 'ABCDEF' REGEXP 'A%C%%' |+---------------------------------------------------------+| 0 |+---------------------------------------------------------+1 row in set (0.00 sec)
un Alt exemplu este −
SQL> SELECT 'ABCDE' REGEXP '.*';+---------------------------------------------------------+| 'ABCDE' REGEXP '.*' |+---------------------------------------------------------+| 1 |+---------------------------------------------------------+1 row in set (0.00 sec)
Să vedem un exemplu mai mult −
SQL> SELECT 'new*\n*line' REGEXP 'new\\*.\\*line';+---------------------------------------------------------+| 'new*\n*line' REGEXP 'new\\*.\\*line' |+---------------------------------------------------------+| 1 |+---------------------------------------------------------+1 row in set (0.00 sec)
REPETARE(str., număr)
Returnează un șir format din șirul str repetă contele de ori. Dacă numărul este mai mic 1, returnează un șir gol. Returnează NULL dacă str sau count sunt NULL.
SQL> SELECT REPEAT('SQL', 3);+---------------------------------------------------------+| REPEAT('SQL', 3) |+---------------------------------------------------------+| SQLSQLSQL |+---------------------------------------------------------+1 row in set (0.00 sec)
REPLACE(str,from_str,to_str)
a se Întoarce șirul str cu toate aparițiile șirului from_str înlocuite cu șirul to_str. REPLACE () efectuează o potrivire sensibilă la litere mari și mici atunci când caută from_str.,
SQL> SELECT REPLACE('www.mysql.com', 'w', 'Ww');+---------------------------------------------------------+| REPLACE('www.mysql.com', 'w', 'Ww') |+---------------------------------------------------------+| WwWwWw.mysql.com |+---------------------------------------------------------+1 row in set (0.00 sec)
REVERSE(str)
returnează șirul str cu ordinea caracterelor inversate.
SQL> SELECT REVERSE('abcd');+---------------------------------------------------------+| REVERSE('abcd') |+---------------------------------------------------------+| dcba |+---------------------------------------------------------+1 row in set (0.00 sec)
RIGHT(str,len)
returnează caracterele Len din dreapta șirului str, sau NULL dacă orice argument este NULL.
SQL> SELECT RIGHT('foobarbar', 4);+---------------------------------------------------------+| RIGHT('foobarbar', 4) |+---------------------------------------------------------+| rbar |+---------------------------------------------------------+1 row in set (0.00 sec)
RPAD(str,len,padstr)
a se Întoarce string str, bine căptușit cu șirul padstr la o lungime de len caractere. Dacă str este mai lung decât Len, valoarea returnată este scurtată la caracterele len.,
SQL> SELECT RPAD('hi',5,'?');+---------------------------------------------------------+| RPAD('hi',5,'?') |+---------------------------------------------------------+| hi??? |+---------------------------------------------------------+1 row in set (0.00 sec)
RTRIM(str)
returnează str șir cu caractere spațiu la sfârșit eliminate.
SQL> SELECT RTRIM('barbar ');+---------------------------------------------------------+| RTRIM('barbar ') |+---------------------------------------------------------+| barbar |+---------------------------------------------------------+1 row in set (0.00 sec)
SOUNDEX(str)
returnează un șir soundex din str. Două șiruri care sună aproape la fel ar trebui să aibă șiruri soundex identice. Un șir standard soundex are patru caractere, dar funcția SOUNDEX () returnează un șir arbitrar de lung. Puteți utiliza SUBSTRING () pe rezultat pentru a obține un șir soundex standard. Toate caracterele non-alfabetice din str sunt ignorate., Toate caracterele alfabetice Internaționale din afara intervalului A-Z sunt tratate ca vocale.
SQL> SELECT SOUNDEX('Hello');+---------------------------------------------------------+| SOUNDEX('Hello') |+---------------------------------------------------------+| H400 |+---------------------------------------------------------+1 row in set (0.00 sec)
expr1 PARE CA expr2
Acest lucru este la fel ca SOUNDEX(expr1) = SOUNDEX(expr2).
SPACE (N)
returnează un șir format din n caractere spațiale.
SQL> SELECT SPACE(6);+---------------------------------------------------------+| SELECT SPACE(6) |+---------------------------------------------------------+| ' ' |+---------------------------------------------------------+1 row in set (0.00 sec)
STRCMP(str1, str2)
Compara doua siruri de caractere și returnează 0 dacă ambele siruri sunt egale, se returnează -1 dacă primul argument este mai mic decât al doilea în funcție de ordinea de sortare curentă altfel returnează 1.,
SQL> SELECT STRCMP('MOHD', 'MOHD');+---------------------------------------------------------+| STRCMP('MOHD', 'MOHD') |+---------------------------------------------------------+| 0 |+---------------------------------------------------------+1 row in set (0.00 sec)
un Alt exemplu este −
SQL> SELECT STRCMP('AMOHD', 'MOHD');+---------------------------------------------------------+| STRCMP('AMOHD', 'MOHD') |+---------------------------------------------------------+| -1 |+---------------------------------------------------------+1 row in set (0.00 sec)
Să vedem un exemplu mai mult −
SQL> SELECT STRCMP('MOHD', 'AMOHD');+---------------------------------------------------------+| STRCMP('MOHD', 'AMOHD') |+---------------------------------------------------------+| 1 |+---------------------------------------------------------+1 row in set (0.00 sec)
SUBȘIR(str DE la pos)
SUBȘIR(str DE la pos PENTRU len)
formele fără len argument reveni un subșir de la string str incepand de la pozitia pos. Formularele cu un argument Len returnează caractere Len substring lungi de la string str, începând de la poziția pos. Formele care utilizează de la sunt sintaxa SQL standard. De asemenea, este posibil să se utilizeze o valoare negativă pentru pos., În acest caz, începutul substringului este caracterele pos de la sfârșitul șirului, mai degrabă decât începutul. O valoare negativă poate fi utilizată pentru pos în oricare dintre formele acestei funcții.
SUBSTRING_INDEX(str,delim,conta)
a se Întoarce subșirul din string str înainte de a număra aparițiile delimitator delim. Dacă numărul este pozitiv, totul din stânga delimitatorului final (numărarea din stânga) este returnat. Dacă numărul este negativ, totul din dreapta delimitatorului final (numărarea din dreapta) este returnat., SUBSTRING_INDEX () efectuează o potrivire sensibilă la litere mari și mici atunci când caută delim.
SQL> SELECT SUBSTRING_INDEX('www.mysql.com', '.', 2);+---------------------------------------------------------+| SUBSTRING_INDEX('www.mysql.com', '.', 2) |+---------------------------------------------------------+| www.mysql |+---------------------------------------------------------+1 row in set (0.00 sec)
TRIM( FROM] str)
returnează șirul str cu toate prefixele sau sufixele remstr eliminate. În cazul în care nici unul dintre specificatorii ambele, de conducere, sau la final este dat, ambele se presupune. remstr este opțională și, dacă nu este specificat, spațiile sunt eliminate.
UCASE(str)
UCASE() este un sinonim pentru UPPER().
UNHEX (str)
efectuează operația inversă a HEX(str)., Adică interpretează fiecare pereche de cifre hexazecimale din argument ca număr și o convertește la caracterul reprezentat de număr. Caracterele rezultate sunt returnate ca un șir binar.
SQL> SELECT UNHEX('4D7953514C');+---------------------------------------------------------+| UNHEX('4D7953514C') |+---------------------------------------------------------+| SQL |+---------------------------------------------------------+1 row in set (0.00 sec)
UPPER(str)
returnează șirul str cu toate caracterele modificate în majuscule în funcție de maparea curentă a setului de caractere.
SQL> SELECT UPPER('Allah-hus-samad');+---------------------------------------------------------+| UPPER('Allah-hus-samad') |+---------------------------------------------------------+| ALLAH-HUS-SAMAD |+---------------------------------------------------------+1 row in set (0.00 sec)