Co to jest "nowa wersja programu"? - Program, w którym poprawiono stare błędy i zrobiono nowe....
Wbudowane funkcje MySQL
  |   Wstęp  |   Operatory logiczne  |   Operatory porównania  |   Funkcje łańcuchowe  |   Funkcje numeryczne  |  
  |   Funkcje bitowe  |   Funkcje daty i czasu  |   Pozostałe funkcje  |  

Funkcje instrukcji SELECT i klauzul WHERE / HAVING

W liście pól instrukcji SELECT oraz w klauzulach WHERE i HAVING można - oprócz pół tabel - budować wyrażenia z wykorzystaniem omówionych tutaj funkcji.

Obowiązuje reguła, że jeżeli chociaż jeden z argumentów funkcji ma wartość NULL, to funkcja zawsze zwraca wartość NULL. Istnieje kilka wyjątków, o których informacje znajdziesz przy opisie konkretnych funkcji.

Pamiętaj o tym, że między nazwą funkcji, a nawiasem otwierającym listę argumentów nie może wystąpić znak spacji. Jeżeli zostawisz po nazwie funkcji choćby 1 spację, to nazwa będzie traktowana jako nazwa pola, a nie funkji, co najczęściej kończy się błędem wykonania instrukcji. W liście argumentów oraz po nawiasie zamykającym tą listę możesz wstawiać spacje bez żadnych ograniczeń: to już nie ma wpływu na wykonanie instrukcji.

 

Operatory logiczne

Wszystkie operacje logiczne zwracają wartość 1 (PRAWDA) lub 0 (FAŁSZ):

AND
&&
Logiczna koniunkcja. Zwraca 0 jeżeli chociaż jeden argument jest 0 lub NULL, w przeciwnym razie 1:
mysql> SELECT 1 && NULL;
    -> 0
mysql> SELECT 1 && 0;
    -> 0

OR
||
Logiczna alternatywa. Zwraca 1 jeżeli oba argumenty nie są 0 ani NULL:
mysql> SELECT 1 || 0;
    -> 1
mysql> SELECT 0 || 0;
    -> 0
mysql> SELECT 1 || NULL;
    -> 1
NOT
!
Logiczne zaprzeczenie. Zwraca 1 jeśli argumentem jest 0, w przeciwnym wypadku zwraca 0.
Wyjątek: NOT NULL zwraca NULL:
mysql> SELECT NOT 1;
    -> 0
mysql> SELECT NOT NULL;
    -> NULL
mysql> SELECT ! (1 + 1);
    -> 0
mysql> SELECT ! 1 + 1;
    -> 1
Ostatni przykład zwraca 1, ponieważ wyrażenie jest rozwijane w ten sam sposób: (!1) + 1.

 

Operatory porównania

Operatory porównania zwracają wartość 1 (PRAWDA), 0 (FAŁSZ) lub NULL. Operują zarówno na liczbach jak i na łańcuchach znaków. Łańcuchy znaków są automatycznie przekształcane na liczby i - jeśli zachodzi taka potrzeba -liczby na łańcuchy znaków.

MySQL wykonuje porównania zgodnie z poniższymi zasadami:

  • jeżeli jeden lub oba argumenty są NULL, wynikiem porównania jest NULL, wyjątkiem jest operator <=>;
     
  • jeżeli oba argumenty w porównaniu są łańcuchami, są one porównywane jako łańcuchy znaków;
     
  • jeżeli oba argumenty są liczbami całkowitymi, są one porównywane jako liczby całkowite;
     
  • wartości szesnastkowe są traktowane jako binarne łańcuchy znaków, jeśli nie są porównywane z liczbą;
     
  • jeżeli jeden z argumentów jest kolumną typu TIMESTAMP lub DATETIME a drugi argument jest stałą, stała ta jest przekształcana do typu TIMESTAMP przed wykonaniem porównania;
     
  • we wszystkich innych przypadkach, argumenty są porównywane jako liczby zmiennoprzecinkowe.
     

Domyślnie, porównywanie łańcuchów odbywa się w trybie ignorowania wielkości liter i używa aktualnej strony kodowej (domyślnie ISO-8859-1 Latin1).

Poniższe przykłady ilustrują konwersję łańcucha znaków do liczb w celu wykonania porównania:

mysql> SELECT 1 > '6x';
     -> 0
mysql> SELECT 7 > '6x';
     -> 1
mysql> SELECT 0 > 'x6';
     -> 0
mysql> SELECT 0 = 'x6';
     -> 1

Jeżeli przy porównywaniu łańcuchów co najmniej jedno wyrażenie jest wrażliwe na wielkość liter, to cała operacja porównania przeprowadzana jest w trybie uwzględniającym wielkość liter.

=
Równy:
mysql> SELECT 1 = 0;
    -> 0
mysql> SELECT '0' = 0;
    -> 1
mysql> SELECT '0.0' = 0;
    -> 1
mysql> SELECT '0.01' = 0;
    -> 0
mysql> SELECT '.01' = 0.01;
    -> 1
<>
!=
Nie równy (różnt):
mysql> SELECT '.01' != '0.01';
    -> 1
mysql> SELECT .01 != '0.01';
    -> 0
mysql> SELECT 'zapp' <> 'zappp';
    -> 1
<=
Mniejszy lub równy:
mysql> SELECT 0.1 <= 2;
    -> 1
<
Mniejszy niż:
mysql> SELECT 2 &lt;= 2;
    -> 1
>=
Większy lub równy:
mysql> SELECT 2 >= 2;
    -> 1
>
Większy niż:
mysql> SELECT 2 > 2;
    -> 0
<=>
Różny od:
mysql> SELECT 1 <=> 1, NULL <=> NULL, 1 <=> NULL;
    -> 1 1 0
IS NULL
IS NOT NULL
Sprawdza, czy wartość jest czy nie jest NULL:
mysql> SELECT 1 IS NULL, 0 IS NULL, NULL IS NULL:
    -> 0 0 1
mysql> SELECT 1 IS NOT NULL, 0 IS NOT NULL, NULL IS NOT NULL;
    -> 1 1 0
wyrażenie BETWEEN min AND max
Jeżeli wyrażenie jest większe lub równe min i wyrażenie jest mniejsze lub równe max, to BETWEEN zwraca 1, w przeciwnym wypadku zwraca 0. Jeśli wszystkie argumenty są tego samego typu jest to równoważne wyrażeniu (min <= wyrażenie AND wyrażenie <= max). Pierwszy argument (wyrażenie) decyduje o sposobie porównania:
  • jeżeli wyrażenie jest kolumną typu TIMESTAMP, data lub DATETIME, MIN() i MAX() będą sformatowane tak, jakby były stałymi;
     
  • jeżeli wyrażenie jest łańcuchem bez odróżniania wielkości liter (lub takim wyrażeniem), to przeprowadzane jest porównanie łańcuchów bez odróżniania wielkości liter;
     
  • jeżeli wyrażenie jest łańcuchem odróżniającym wielkość liter (lub takim wyrażeniem), to przeprowadzane jest porównanie łańcuchów z uwzględnieniem wielkości liter;
     
  • jeżeli wyrażenie jest liczbą całkowitą, to przeprowadzane jest porównywanie całkowite;
     
  • w każdym innym przypadku dokonywane jest porównywanie zmiennoprzecinkowe.
     
>mysql> SELECT 1 BETWEEN 2 AND 3;
    -> 0
mysql> SELECT 'b' BETWEEN 'a' AND 'c';
    -> 1
mysql> SELECT 2 BETWEEN 2 AND '3';
    -> 1
mysql> SELECT 2 BETWEEN 2 AND 'x-3';
    -> 0
wyrażenier IN (wartość,...)
Zwraca 1 jeśli wyrażenie jest jedną z wartości z listy IN, w przeciwnym wypadku zwraca 0. Jeśli wszystkie wartości są stałymi, to wszystkie one są przekształcane do typu wyrażenia i sortowane. Wykorzystywane jest przeszukiwanie binarne co oznacza, że IN jest bardzo szybkie, jeśli lista wartości IN składa się tylko ze stałych. Jeśli wyrażenie jest łańcuchem odróżniającym wielkość liter, to porównanie wykonywane jest z uwzględnieniem tej cechy:
mysql> SELECT 2 IN (0,3,5,'wefwf');
    -> 0
mysql> SELECT 'wefwf' IN (0,3,5,'wefwf');
    -> 1
wyrażenie NOT IN (wartość,...)
Jest to równoważne: NOT (wyrażenie IN (wartość,...)).
 
ISNULL(wyrażenie)
Jeśli wyrażenie ma wartość NULL, to ISNULL() zwraca 1. W przeciwnym wypadku zwraca 0:
mysql> SELECT ISNULL(1+1);
    -> 0
mysql> SELECT ISNULL(1/0);
    -> 1
Pamiętaj, że porównywanie wartości NULL przy użyciu operatora = zawsze zwraca fałsz!
 
COALESCE(lista)
Zwraca pierwszy element z listy, którego wartość jest różna od NULL:
mysql> SELECT COALESCE(NULL,1);
    -> 1
mysql> SELECT COALESCE(NULL,NULL,NULL);
    -> NULL
INTERVAL(N, N1, N2, N3, ...)
Zwraca 0, jeżeli N < N1, 1, jeśli N < N2 i tak dalej. Wszystkie argumenty traktowane są jako liczby całkowite. Do poprawnej pracy tej funkcji konieczne jest, aby N1 < N2 < N3 < ... < Nn. Wynika to z użycia przeszukiwania binarnego.
mysql> SELECT INTERVAL(23, 1, 15, 17, 30, 44, 200);
    -> 3
mysql> SELECT INTERVAL(10, 1, 10, 100, 1000);
    -> 2
mysql> SELECT INTERVAL(22, 23, 30, 44, 200);
    -> 0
wyrażenie LIKE wzór [ESCAPE 'znak-escape']
Porównanie łańcuchów wyrażenie z wzorcem przy użyciu prostego wyrażenia regularnego. Zwraca 1 lub 0. Używając LIKE można stosować we wzorze 2 symbole wieloznaczne:
% zastępuje ciąg znaków o długości >= 0
_ zastępuje dokładnie 1 znak
mysql> SELECT 'David!' LIKE 'David_';
    -> 1
mysql> SELECT 'David!' LIKE '%D%v%';
    -> 1
Aby sprawdzić wystąpienie literału maski, poprzedź odpowiedni znak znakiem escape. Jeśli nie podasz własnego znaku ESCAPE, przyjmowany jest '\':
\%porównuje z 1 znakiem %
\_ porównuje z 1 znakiem _
mysql> SELECT 'David!' LIKE 'David\_';
    -> 0
mysql> SELECT 'David_' LIKE 'David\_';
    -> 1
Aby użyć innego znaku escape, użyj klauzuli ESCAPE:
mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|';
    -> 1
Operator LIKE może również pracować na wyrażeniach numerycznych.
mysql> SELECT 10 LIKE '1%';
    -> 1
Uwaga: Ponieważ MySQL używa w łańcuchach składni escape zaczerpniętej z C (na przykład '\n'), to musisz zdublować każde wystąpienie '\', jakie znajduje się w łańcuchach instrukcji LIKE. Na przykład, aby znaleźć '\n', zapisz to wyrażenie jako '\\n'. Aby znaleźć '\', zapisz to jako '\\\\' (jeden backslash jest obcinany przez parser, drugi po dopasowaniu do wzoru, pozostawiając do dopasowania pojedynczy backslash).
 
wyrażenie NOT LIKE wzór [ESCAPE 'znak-ucieczki']
Jest to równoważne: NOT (wyrażenie LIKE wzór [ESCAPE 'znak-escape']).
 
wyrażenie REGEXP wzór
wyrażenie RLIKE wzór
Wykonuje porównanie wyrażenia wyrażenie z wzorem wzór. Wzór może być rozszerzonym wyrażeniem regularnym. Zwraca 1 jeśli wyrażenie pasuje do wzorca, w przeciwnym wypadku zwraca 0. RLIKE jest synonimem REGEXP wprowadzonym dla zgodności z mSQL. Od wersji 3.23.4 REGEXP jest niewrażliwy na wielkość liter w nie binarnych łańcuchach:
mysql> SELECT 'Monty!' REGEXP 'm%y%%';
    -> 0
mysql> SELECT 'Monty!' REGEXP '.*';
    -> 1
mysql> SELECT 'new*
*line' REGEXP 'new\*.\*line';
    -> 1
mysql> SELECT "a" REGEXP "A", "a" REGEXP BINARY "A";
    -> 1 0
REGEXP i RLIKE stosują bieżącą stronę kodową (domyślnie ISO-8859-1 Latin1).
 
wyrażenie NOT REGEXP wzór
wyrażenie NOT RLIKE wzór
Jest to równoważne: NOT (wyrażenie REGEXP wzór).
 
STRCMP(expr1,expr2)
STRCMP() zwraca 0, jeżeli łańcuchy są takie same, -1, jeżeli pierwszy argument jest mniejszy od drugiego i 1, jeżeli pierwszy argument jest większy od drugiego:
mysql> SELECT STRCMP('text', 'text2');
    -> -1
mysql> SELECT STRCMP('text2', 'text');
    -> 1
mysql> SELECT STRCMP('text', 'text');
    -> 0

 

Funkcje łańcuchowe

Funkcje operujące na pozycji łańcuchach znaków rozpoczynają numerację znaków w łańcuchu od 1.

ASCII(łańcuch)
Zwraca kod ASCII znaku będącego pierwszym od lewej w łańcuchu łańcuch. Jeśli łańcuch jest pusty funkcja zwróci 0. Jeśli łańcuch ma wartość NULL funkcja również zwróci NULL:
mysql> SELECT ASCII('2');
    -> 50
mysql> SELECT ASCII(2);
    -> 50
mysql> SELECT ASCII('dx');
    -> 100
BIN(N)
Zwraca łańcuchową reprezentację binarnej wartości N, przy czym N jest liczbą typu BIGINT. Jest to ekwiwalent polecenia CONV(N, 10, 2). Funkcja zwraca NULL, jeśli N ma wartość NULL:
mysql> SELECT BIN(12);
    -> '1100'
OCT(N)
Zwraca łańcuchową reprezentację ósemkowej wartości N, przy czym N jest liczbą typu BIGINT. Jest to ekwiwalent funkcji CONV(N, 10, 8). Funkcja zwraca NULL, jeśli N ma wartość NULL:
mysql> SELECT OCT(12);
    -> '14'
CHAR(N,...)
Funkcja CHAR() odczytuje argumenty jako liczby całkowite i zwraca łańcuch składający się ze znaków, których reprezentację ASCII stanowią przekazane argumenty. Wartości NULL są pomijane:
mysql> SELECT CHAR(77,121,83,81,'76');
    -> 'MySQL'
mysql> SELECT CHAR(77,77.3,'77.3');
    -> 'MMM'
CHAR_LENGTH(łańcuch)
Zobacz LENGTH(łańcuch)
 
CHARACTER_LENGTH(łańcuch)
Zobacz LENGTH(łańcuch)
 
CONCAT(łańcuch1, łańcuch2,...)
Funkcja zwraca łańcuch będący wynikiem połączenia argumentów. Zwraca NULL jeśli jakikolwiek argument ma wartość NULL. Funkcja może przyjąć więcej niż 2 argumenty. Argumenty liczbowe są przekształcane na ich łańcuchowe odpowiedniki:
mysql> SELECT CONCAT('My', 'S', 'QL');
    -> 'MySQL'
mysql> SELECT CONCAT('My', NULL, 'QL');
    -> NULL
mysql> SELECT CONCAT(14.3);
    -> '14.3'
CONCAT_WS(separator, łańcuch1, łańcuch2,...)
CONCAT_WS() jest odpowiednikiem funkcji CONCAT z Separatorami (WS - With Separator) i jest specjalną odmianą CONCAT(). Pierwszy argument jest separatorem reszty argumentów. Separator, jak również reszta argumentów, może być łańcuchem. Jeśli separator ma wartość NULL, wynikiem również będzie NULL. Funkcja pomija wszystkie argumenty puste i z wartością NULL występujące po separatorze. Znak separatora będzie wstawiony pomiędzy łańcuchy mające zostać połączone:
mysql> SELECT CONCAT_WS(', ', 'Jan', 'Karol', 'Lech');
    -> 'Jan, Karol, Lech'
CONV(N, podstawa_źródłowa, podstawa_docelowa)
Konwertuje liczby pomiędzy różnymi systemami liczbowymi. Zwraca łańcuchową reprezentację liczby N przekształconej z systemu o podstawie_źródłoweje na system o podstawie_docelowej. Funkcja zwraca NULL, gdy chociaż jeden z jej argumentów ma wartość NULL. Argument N interpretowany jest jako liczba całkowita, jednak może być podany też w formie łańcucha. Minimalną podstawą systemu liczbowego jest 2, natomiast maksymalną 36. Jeśli podstawa_docelowa jest liczbą ujemną przyjmuje się, że N jest liczbą ze znakiem. W przeciwnym wypadku N traktowane jest jak liczba bez znaku. Funkcja CONV działa z 64 bitową precyzją:
mysql> SELECT CONV('a', 16, 2);
    -> '1010'
mysql> SELECT CONV('6E', 18, 8);
    -> '172'
mysql> SELECT CONV(-17, 10, -18);
    -> '-H'
mysql> SELECT CONV(10 + '10' +' 10' + 0xa, 10, 10);
    -> '40'
ELT(N, łańcuch_1, łańcuch_2, ...)
Zwraca łańcuch_1 jeżeli N = 1, łańcuch_2 jeżeli N = 2, itd. Zwraca NULL jeżeli N < 1 lub > od ilości argumentów.
mysql> SELECT ELT(2, 'a', 'b', 'c', 'd');
    -> 'b'
EXPORT_SET(bity, on, off, [separator, [ile_bitów]])
Zwraca łańcuch, w którym każdemu bitowi = 1 w bity odpowiada łańcuch podany w on, a każdemu bitowi =0 odpowiada łańcuch podany w off. Łańcuchy w zwracanej liści oddzielone są znakiem separator (domyślnie przecinek), a lista zawiera ile_bitów elementów (domyślnie 64):
mysql> SELECT EXPORT_SET(5, 'Y', 'N', ',', 4)
    -> 'Y,N,Y,N'
FIELD(łańcuch, łańcuch_1, łańcuch_2, ...)
Zwraca indeks łańcucha w liście łańcuch_1, łańcuch_2, .... Zwraca 0 jeżeli łańcuch nie został znaleziony.
mysql> SELECT FIELD('c', 'abcd', 'bc', 'c', 'de');
    -> 3
FIND_IN_SET(łańcuch, lista)
Zwraca indeks łańcucha w liście lista. lista składa się z łańcuchów oddzielonych znakiem przecinka. Zwraca 0, jeżeli łańcuch nie występuje w liście lub lista jest pusta. Zwraca NULL, jeżeli oba argumenty maja wartość NULL. Funkcja działa błędnie, jeżeli pierwszy argument zawiera przecinek:
mysql> SELECT FIND_IN_SET('b','a,b,c,d');
    -> 2
HEX(N)
Zwraca łańcuchową reprezentację szesnastkowej wartości N, przy czym N jest liczbą typu BIGINT. Jest to ekwiwalent funkcji CONV(N, 10, 16). Funkcja zwraca NULL, jeśli N ma wartość NULL:
SELECT HEX(255);
    -> 'FF'
INSERT(łańcuch, od, ile, nowy_łańcuch)
Zwraca łańcuch, w którym poczynając od znaku od ile znaków zostaje zastąpionych przez nowy_łańcuch:
mysql> SELECT INSERT('abcdefghijk', 3, 4, 'XYX');
    -> 'abXYXghijk'
INSTR(łańcuch, podłańcuch)
Zwraca pozycję pierwszego wystąpienia podłańcucha w łańcuchu. Jest to odpowiednik dwuargumentowej postaci funkcji LOCATE() z tym wyjątkiem, że kolejność argumentów jest zamieniona:
mysql> SELECT INSTR('foobarbar', 'bar');
    -> 4
mysql> SELECT INSTR('xbar', 'foobar');
    -> 0
LCASE(łańcuch)
Zamienia w łańcuchu wszystkie litery na małe. Używa aktualnej strony kodowej (domyślnie ISO-8859-1 Latin1):
mysql> SELECT LCASE('AbCdEf');
    -> 'abcdef'
LEFT(łańcuch, N)
Zwraca N pierwszych znaków łańcucha:
mysql> SELECT LEFT('foobarbar', 5);
    -> 'fooba'
LENGTH(łańcuch)
Wszystkie powyższe funkcje zwracają długość łańcucha:
mysql> SELECT LENGTH('tekst');
    -> 5
mysql> SELECT OCTET_LENGTH('tekst');
    -> 5
LOAD_FILE(file_name)
Funkcja wczytuje zawartość pliku i zwraca ją jako łańcuch znaków. Plik musi znajdować się na serwerze i musisz mieć prawa do jego odczytu. Nazwa pliku musi zawierać pełną ścieżkę dostępu. Jeżeli plik nie istnieje lub nie masz odpowiednich uprawnień, to funkcja zwróci wartość NULL:
mysql> UPDATE table_name
      SET myBlobField = LOAD_FILE('/tmp/picture')
      WHERE id=1;
LOCATE(podłańcuch, łańcuch)
Funkcja zwraca pozycję pierwszego wystąpienia podłańcucha w łańcuchu. Zwraca 0, jeśli podłańcuch nie występuje w łańcuchu:
mysql> SELECT LOCATE('bar', 'foobarbar');
    -> 4
mysql> SELECT LOCATE('xbar', 'foobar');
    -> 0
LOCATE(podłańcuch, łańcuch, pozycja)
Zwraca pozycję pierwszego wystąpienia podłańcucha w łańcuchu rozpoczynając od pozycji. Zwraca 0, jeśli podłańcuch nie występuje w łańcuchu:
mysql> SELECT LOCATE('bar', 'foobarbar',5);
    -> 7
LOWER(łańcuch)
Zobacz LCASE(łańcuch)
 
LPAD(łańcuch, długość,wypełniacz)
Zwraca łańcuch składający się z łańcucha uzupełnionego z lewej strony wypełniaczami do długości długość znaków:
mysql> SELECT LPAD('hi', 4, '.');
    -> '..hi'
LTRIM(łańcuch)
Zwraca łańcuch bez początkowych znaków spacji:
mysql> SELECT LTRIM('    barbar');
    -> 'barbar'
MAKE_SET(bity, łańcuch_1, łańcuch_2, ...)
Zwraca listę oddzielonych przecinkami łańcuchów wybranych z listy argumentów łańcuch_1, łańcuch_2, ..., które występują na pozycjach odpowiadających ustawionym bitom parametru bity. Wartości NULL są ignorowane:
mysql> SELECT MAKE_SET(1,'a','b','c');
    -> 'a'
mysql> SELECT MAKE_SET(1 | 4,'hello','nice','world');
    -> 'hello,world'
mysql> SELECT MAKE_SET(0,'a','b','c');
    -> ''
MID(łańcuch, pozycja, długość)
Zobacz SUBSTRING(łańcuch, pozycja, długość)
 
OCTET_LENGTH(łańcuch)
Zobacz LENGTH(łańcuch)
 
ORD(łańcuch)
Jeśli pierwszy od lewej znak w łańcuchu jest znakiem zapisanym w postaci więcej niż jednego bajta, funkcja zwraca jego kod przez w postaci wartości kodu ASCII w formacie ((kod ASCII pierwszego bajtu) * 256 + (znak ASCII drugiego bajtu) ) [ * 256 + kod ASCII trzeciego bajtu ...]. Jeśli znak pierwszy od lewej jest zapisany w jednym bajcie, funkcja zwraca tą samą wartość co funkcja ASCII():
mysql> SELECT ORD('2');
    -> 50
POSITION(podłańcuch IN łańcuch)
Zobacz LOCATE(podłańcuch, łańcuch)
 
REPEAT(łańcuch, N)
Zwraca łańcuch zawierający N powtórzeń łańcucha. Jeżeli N <= 0, to zwracany jest pusty łańcuch. Zwraca NULL, jeżeli łańcuch lub NNULL:
mysql> SELECT REPEAT('MySQL', 3);
    -> 'MySQLMySQLMySQL'
REPLACE(łańcuch, szukaj, wstaw)
Zwraca łańcuch, w którym wszystkie wystąpienia szukaj są zastąpione przez wstaw:
mysql> SELECT REPLACE('www.mysql.com', 'w', 'Ww');
    -> 'WwWwWw.mysql.com'
REVERSE(łańcuch)
Odwraca kolejność znaków w łańcuchu:
mysql> SELECT REVERSE('abc');
    -> 'cba'
RIGHT(łańcuch, N)
Zwraca N ostatnich znaków łańcucha:
mysql> SELECT RIGHT('foobarbar', 4);
    -> 'rbar'
RPAD(łańcuch, długość, wypełniacz)
Zwraca łańcuch składający się z łańcucha uzupełnionego z prawej strony wypełniaczami do długości długość znaków:
mysql> SELECT RPAD('hi',5,'.');
    -> 'hi...'
RTRIM(łańcuch)
Zwraca łańcuch bez końcowych znaków spacji:
mysql> SELECT RTRIM('barbar  ');
    -> 'barbar'
SPACE(N)
Zwraca łańcuch zawierający N znaków spacji:
mysql> SELECT SPACE(6);
    -> '      '
SUBSTRING(łańcuch, pozycja, długość)
Zwraca podłańcuch o długości długość znaków z łańcucha, poczynając od pozycji. Wariant ze słowem kluczowym FROM jest zgodny ze składnią ANSI SQL92:
mysql> SELECT SUBSTRING('Quadratically',5,6);
    -> 'ratica'
SUBSTRING(łańcuch FROM pozycja FOR długość)
Zobacz SUBSTRING(łańcuch, pozycja, długość)
 
SUBSTRING(łańcuch, pozycja)
Zwraca ciąg znaków z łańcucha rozpoczynając od pozycji:
mysql> SELECT SUBSTRING('Quadratically',5);
    -> 'ratically'
mysql> SELECT SUBSTRING('foobarbar' FROM 4);
    -> 'barbar'
SUBSTRING(łańcuch FROM pozycja)
Zobacz SUBSTRING(łańcuch, pozycja)
 
TRIM([[BOTH | LEADING | TRAILING] [usuń] FROM] (łańcuch))
Zwraca łańcuch z obciętymi początkowymi i/lub końcowymi znakami usuń. Jeżeli nie podasz BOTH, LEADING ani TRAILING, to przyjmowane jest BOTH. Jeżeli nie podasz usuń, to usuwane są spacje:
mysql> SELECT TRIM(' bar  ');
    -> 'bar'
mysql> SELECT TRIM(BOTH 'x' FROM 'xxxbarxxx');
    -> 'bar'
UCASE(łańcuch)
Zamienia w łańcuchu wszystkie litery na wielkie. Używa aktualnej strony kodowej (domyślnie ISO-8859-1 Latin1):
mysql> SELECT LCASE('AbCdEf');
    -> 'ABCDEF'
UPPER(łańcuch)
Zobacz UCASE(łańcuch)
 

 

Funkcje matematyczne

Wszystkie funkcje matematyczne w przypadku błędu zwracają wartość NULL.

ABS(X)
Zwraca wartość bezwzględną X:
mysql> SELECT ABS(2);
    -> 2
mysql> SELECT ABS(-32);
    -> 32
ACOS(X)
Zwraca wartość arcus cosine X. Zwraca NULL jeśli X jest spoza zakresu [-1 ; 1]:
mysql> SELECT ACOS(1);
    -> 0.000000
mysql> SELECT ACOS(1.0001);
    -> NULL
mysql> SELECT ACOS(0);
    -> 1.570796
ASIN(X)
Zwraca wartość arcus sinus liczby X. Zwraca NULL jeśli X jest spoza zakresu [-1 ; 1]:
mysql> SELECT ASIN(0.2);
    -> 0.201358
mysql> SELECT ASIN('foo');
    -> 0.000000
ATAN(X)
Zwraca wartość arcus tangens liczby X:
mysql> SELECT ATAN(2);
    -> 1.107149
mysql> SELECT ATAN(-2);
    -> -1.107149
ATAN2(X, Y)
Zwraca arcus tangens dwóch zmiennych X i Y.
mysql> SELECT ATAN(-2, 2);
    -> -0.785398
mysql> SELECT ATAN(PI(), 0);
    -> 1.570796
CEILING(X)
Zwraca najmniejszą wartość całkowitą nie mniejszą niż X:
mysql> SELECT CEILING(1.23);
    -> 2
mysql> SELECT CEILING(-1.23);
    -> -1
COS(X)
Zwraca cosinus liczby X, gdzie X podane jest w radianach:
mysql> SELECT COS(PI());
    -> -1.000000
COT(X)
Zwraca cotangens liczby X:
mysql> SELECT COT(12);
    -> -1.57267341
mysql> SELECT COT(0);
    -> NULL
DEGREES(X)
Zwraca argument X przekształcony z radianów na stopnie:
mysql> SELECT DEGREES(PI());
    -> 180.000000
EXP(X)
Zwraca wartość e (podstawa logarytmu naturalnego) podniesionego do potęgi X:
mysql> SELECT EXP(2);
    -> 7.389056
mysql> SELECT EXP(-2);
    -> 0.135335
FLOOR(X)
Zwraca największą wartość całkowitą nie większą niż X:
mysql> SELECT FLOOR(1.23);
    -> 1
mysql> SELECT FLOOR(-1.23);
    -> -2
GREATEST(X,Y,...)
Zwraca argument o największej wartości. Argumenty porównywane są według tych samych zasad, co w przypadku funkcji LEAST:
mysql> SELECT GREATEST(2, 0);
    -> 2
mysql> SELECT GREATEST(34.0, 3.0, 5.0, 767.0);
    -> 767.0
mysql> SELECT GREATEST("B", "A", "C");
    -> "C"
LEAST(X, Y, ...)
Przy dwóch lub więcej argumentach, zwraca argument o najmniejszej wartości. Argumenty porównywane są według następujących zasad:
  • jeżeli zwracana wartość użyta jest w kontekście liczb całkowitych lub wszystkie argumenty są liczbami całkowitymi, to argumenty porównywane są jako liczby całkowite;
     
  • jeżeli funkcja zostanie wywołana w kontekście liczb zmiennoprzecinkowych lub wszystkie argumenty są liczbami zmiennoprzecinkowymi, są one porównywane jako liczby zmiennoprzecinkowe;
     
  • jeżeli co najmniej jeden argument jest łańcuchem binarnym (rozróżniającym wielkość liter), argumenty porównywane są jako łańcuchy w trybie wrażliwości na wielkość liter;
     
  • w innych przypadkach, argumenty porównywane są jako łańcuchy nie rozróżniające wielkości liter.
     
mysql> SELECT LEAST(2, 0);
    -> 0
mysql> SELECT LEAST(34.0, 3.0, 5.0, 767.0);
    -> 3.0
mysql> SELECT LEAST("B", "A", "C");
    -> "A"
LOG(X)
Zwraca wartość logarytmu naturalnego z X:
mysql> SELECT LOG(2);
    -> 0.693147
mysql> SELECT LOG(-2);
    -> NULL
Jeżeli musisz obliczyć logarytm o dowolnej podstawie B z liczby X , to użyj zapisu LOG(X)/LOG(B).
 
LOG10(X)
Zwraca wartość logarytmu dziesiętnego z liczby X:
mysql> SELECT LOG10(2);
    -> 0.301030
mysql> SELECT LOG10(100);
    -> 2.000000
mysql> SELECT LOG10(-100);
    -> NULL
MOD(N, M)
N % M
Modulo. Zwraca resztę z dzielenia całkowitego N przez M:
mysql> SELECT MOD(234, 10);
    -> 4
mysql> SELECT 253 % 7;
    -> 1
mysql> SELECT MOD(29, 9);
    -> 2
PI()
Zwraca wartość PI:
mysql> SELECT PI();
    -> 3.141593
POW(X, Y)
Zwraca liczbę X podniesioną do potęgi Y:
mysql> SELECT POW(2, 2);
    -> 4.000000
mysql> SELECT POW(2, -2);
    -> 0.250000
POWER(X, Y)
Zobacz POW(X, Y)
 
RAND()
Zwraca losową liczbę zmiennoprzecinkową z zakresu od (0 ; 1.0]. Jeśli podano argument N (liczba całkowita), to jest ona używana do inicjalizacji generatora liczb losowych:
mysql> SELECT RAND();
    -> 0.5925
mysql> SELECT RAND(20);
    -> 0.1811
RADIANS(X)
Zwraca argument X przekształcony ze stopni na radiany:
mysql> SELECT RADIANS(90);
    -> 1.570796
RAND( [N] )
Zobacz RAND()
 
ROUND(X)
Zwraca liczbę X zaokrąglony do najbliższej wartości całkowitej:
mysql> SELECT ROUND(-1.23);
    -> -1
mysql> SELECT ROUND(-1.58);
    -> -2
mysql> SELECT ROUND(1.58);
    -> 2
ROUND(X, D)
Zwraca liczbę X zaokrągloną do D cyfr dziesiętnych. Jeśli D wynosi 0 wynik nie będzie posiadał części ułamkowej. Jeżeli D < 0, to liczba będzie zokrąglona odpowiednio do 10-ek, 100-ek, itd.:
mysql> SELECT ROUND(1.298, 1);
    -> 1.3
mysql> SELECT ROUND(12345, -2);
    -> 12300
SIGN(X)
Zwraca znak argumentu jako -1, 0 lub 1 zależnie od tego, czy X jest ujemne, = 0 lub dodatnie:
mysql> SELECT SIGN(-32);
    -> -1
mysql> SELECT SIGN(0);
    -> 0
mysql> SELECT SIGN(234);
    -> 1
SIN(X)
Zwraca sinus liczby X, gdzie X podane jest w radianach:
mysql> SELECT SIN(PI());
    -> 0.000000
SQRT(X)
Zwraca nieujemną wartość pierwiastka kwadratowego z liczby X:
mysql> SELECT SQRT(4);
    -> 2.000000
mysql> SELECT SQRT(20);
    -> 4.472136
TAN(X)
Zwraca tangens liczby X, gdzie X podane jest w radianach:
mysql> SELECT TAN(PI()+1);
    -> 1.557408
TRUNCATE(X, D)
Zwraca liczbę X obciętą do D cyfr dziesiętnych. W przypadku, gdy D = 0, liczba jest obcinana do części całkowitej. Dla D <= 0 "zerowane" są odpowiednio jedności, dziesiątki, itd.:
mysql> SELECT TRUNCATE(1.223, 1);
    -> 1.2
mysql> SELECT TRUNCATE(999, -2);
    -> 900

 

Funkcje bitowe

MySQL dla operacji bitowych stosuje arytmetykę BIGINT (64 bitową), więc operatory działań mają zakres również 64 bitów.

|
Bitowe OR:
mysql> SELECT 29 | 15;
    -> 31
&
Bitowe AND:
mysql> SELECT 29 & 15;
    -> 13
<<
Przesuwa bity liczby (BIGINT) w lewo o podaną ilość pozycji:
mysql> SELECT 1 << 2
    -> 4
>>
Przesuwa bity liczby (BIGINT) w prawo o podaną ilość pozycji:
mysql> SELECT 4 >> 2
    -> 1
~
Odwraca wszystkie bity (nadaje wartości przeciwne):
mysql> SELECT ~5
    -> 2
BIT_COUNT(N)
Zwraca liczbę ustawionych bitów (bitów o wartości = 1) w argumencie N:
mysql> SELECT BIT_COUNT(29);
    -> 4

 

Funkcje daty i czasu

ADDDATE(data, INTERVAL wartość typ)
Zobacz DATE_ADD(data, INTERVAL wartość typ)
 
CURDATE()
Zwraca bieżącą datę w formacie 'YYYY-MM-DD' lub YYYYMMDD, zależnie od tego czy jest użyta jako łańcuch znaków, czy jako liczba:
mysql> SELECT CURDATE();
    -> '2005-06-30'
mysql> SELECT CURDATE() + 0;
    -> 20050630
CURRENT_DATE
Zobacz CURDATE()
 
CURRENT_TIME
Zobacz CURTIME()
 
CURRENT_TIMESTAMP
Zobacz
 
CURTIME()
Zwraca bieżący czas w formacie 'HH:MM:SS' lub HHMMSS, zależnie od tego czy jest użyta jako łańcuch znaków, czy jako liczba:
mysql> SELECT CURTIME();
    -> '23:50:26'
mysql> SELECT CURTIME() + 0;
    -> 235026
DATE_ADD(data, INTERVAL wartość typ)
Funkcje arytmetyczne na datach. ADDDATE() i SUBDATE() są synonimami dla DATE_ADD() i DATE_SUB(). Można używać znaków + i - zamiast DATE_ADD() i DATE_SUB(), jeżeli wyrażenie po prawej stronie jest datą lub czasem. data musi mieć typ DATETIME lub DATE. wartość podaje ilość dodawanych lub odejmowanych od daty okresów (może być również liczbą ujemną). typ określa typ okesu (ptrz tabel niżej). Funkcja EXTRACT(typ FROM data) zwraca typ okresu z daty.
TypOpis
SECONDsekundy
MINUTEminuty
HOURgodziny
DAYdni
MONTHmiesiące
YEARlata
MINUTE_SECONDminuty i sekundy w formacie MM:SS
HOUR_MINUTEgodziny i minuty w formacie HH:MM
DAY_HOURdni i godziny w formacie DD HH
YEAR_MONTHYEARS-MONTHS
HOUR_SECONDczas w formacie HH:MM:SS
DAY_MINUTEdata i czas w formacie DD HH:MM
DAY_SECONDdata i czas w formacie DD HH:MM:SS
mysql> SELECT '1997-12-31 23:59:59' + INTERVAL 1 SECOND;
    -> 1998-01-01 00:00:00
mysql> SELECT INTERVAL 1 DAY + '1997-12-31';
    -> 1998-01-01
mysql> SELECT '1998-01-01' - INTERVAL 1 SECOND;
    -> 1997-12-31 23:59:59
mysql> SELECT DATE_ADD('1997-12-31 23:59:59',
              INTERVAL 1 SECOND);
    -> 1998-01-01 00:00:00
mysql> SELECT DATE_ADD('1997-12-31 23:59:59',
              INTERVAL 1 DAY);
    -> 1998-01-01 23:59:59
mysql> SELECT DATE_ADD('1997-12-31 23:59:59',
              INTERVAL '1:1' MINUTE_SECOND);
    -> 1998-01-01 00:01:00
mysql> SELECT DATE_SUB('1998-01-01 00:00:00',
              INTERVAL '1 1:1:1' DAY_SECOND);
    -> 1997-12-30 22:58:59
mysql> SELECT DATE_ADD('1998-01-01 00:00:00',
              INTERVAL '-1 10' DAY_HOUR);
    -> 1997-12-30 14:00:00
mysql> SELECT DATE_SUB('1998-01-02', INTERVAL 31 DAY);
    -> 1997-12-02
mysql> SELECT EXTRACT(YEAR FROM '1999-07-02');
    -> 1999
mysql> SELECT EXTRACT(YEAR_MONTH FROM '1999-07-02 01:02:03');
    -> 199907
mysql> SELECT EXTRACT(DAY_MINUTE FROM '1999-07-02 01:02:03');
    -> 20102
mysql> SELECT date_add('1999-01-01', interval 1 day);
    -> 1999-01-02
mysql> SELECT date_add('1999-01-01', interval 1 hour);
    -> 1999-01-01 01:00:00
mysql> SELECT DATE_ADD('1998-01-30', Interval 1 month);
    -> 1998-02-28
DATE_FORMAT(data, format)
Formatuje datę zgodnie z podanym formatem:
%MNazwa miesiąca (January..December)
%WDzień tygodnia (Sunday..Saturday)
%DDzień miesiąca z angielskim sufiksem (1st, 2nd, 3rd, itd.)
%YRok, 4 cyfry
%yRok, 2 cyfry
%XRok dla tygodnia zaczynającego się od niedzieli, 4 cyfry, używane z %V
%xRok dla tygodnia zaczynającego się od poniedziałku, 4 cyfry, używane z %v
%aSkrócona nazwa dnia tygodnia (Sun..Sat)
%dDzień miesiąca (00..31)
%eDzień miesiąca (0..31)
%mMiesiąc (01..12)
%cMiesiąc (1..12)
%bSkrócona nazwa miesiąca (Jan..Dec)
%jDzień roku (001..366)
%HGodzina (00..23)
%kGodzina (0..23)
%hGodzina (01..12)
%IGodzina (01..12)
%lGodzina (1..12)
%iMinuty (00..59)
%rCzas w systemie 12-godzinnym (hh:mm:ss [AP]M)
%TCzas w systemie 24-godzinnym (hh:mm:ss)
%SSekundy (00..59)
%sSekundy (00..59)
%pAM lub PM
%wDzień tygodnia (0=Sunday..6=Saturday)
%UTydzień (0..53), zaczyna się od niedzieli
%uTydzień (0..53), zaczyna się od poniedziałku
%VTydzień (1..53), zaczyna się od niedzieli, używany z %X
%vTydzień (1..53), zaczyna się od poniedziałku, używany z %x
%%Znak '%'

Wszystkie inne znaki formatu są dokładnie kopiowane.

mysql> SELECT DATE_FORMAT('2005-06-30 12:00:00', '%W %M %Y');
    -> 'Thursday June 2005'
mysql> SELECT DATE_FORMAT('2005-06-30 12:00:00', '%H:%i:%s');
    -> '12:00:00'
mysql> SELECT DATE_FORMAT('2005-06-30 12:00:00', '%D %y %a %d %m %b %j');
    -> '30th 05 Thu 30 06 Jun 181'
mysql> SELECT DATE_FORMAT('2005-06-30 12:00:00', '%H %k %I %r %T %S %w');
    -> '12 12 12 12:00:00 PM 12:00:00 00 4'
DATE_SUB(data, INTERVAL wartość typ)
Zobacz DATE_ADD(data, INTERVAL wartość typ)
 
DAYNAME(data)
Zwraca nazwę dnia tygodnia dla data (po angielsku):
mysql> SELECT DAYNAME("2005-06-30");
    -> 'Thursday'
DAYOFMONTH(data)
Zwraca numer dnia miesiąca dla data z zakresu 1 do 31:
mysql> SELECT DAYOFMONTH('2005-06-30');
    -> 30
DAYOFWEEK(data)
Zwraca numer dnia tygodnia dla daty (1 = niedziela, 2 = poniedziałek, ... 7 = sobota):
mysql> SELECT DAYOFWEEK('2005-06-30');
    -> 5
DAYOFYEAR(data)
Zwraca numer dnia w roku dla data z zakresu 1 do 366:
mysql> SELECT DAYOFYEAR('2005-06-30');
    -> 181
FROM_DAYS(N)
Zwraca datę dla podanego numeru dnia N:
mysql> SELECT FROM_DAYS(732492);
    -> '2005-06-30'
FROM_UNIXTIME(unix_czas)
Zwraca datę w formacie 'YYYY-MM-DD HH:MM:SS' lub YYYYMMDDHHMMSS, zależnie od tego czy jest użyta jako łańcuch znaków, czy jako liczba:
mysql> SELECT FROM_UNIXTIME(1120125600);
    -> '2005-06-30 12:00:00'
mysql> SELECT FROM_UNIXTIME(1120125600) + 0;
    -> 20050630120000
FROM_UNIXTIME(unix_czas, format)
Zwraca sformatowaną datę i czas w formacie format, który jest identyczny jak dla DATE_FORMAT():
mysql> SELECT FROM_UNIXTIME(1120125600, '%Y %D %M %h:%i:%s %x');
    -> '2005 30th June 12:00:00 2005'
HOUR(czas)
Zwraca godzinę dla argumentu czas z zakresu 0 do 23:
mysql> SELECT HOUR('10:05:03');
    -> 10
MINUTE(czas)
Zwraca minuty dla argumentu czas z zakresu 0 do 59:
mysql> SELECT MINUTE('98-02-03 10:05:03');
    -> 5
MONTH(data)
Zwraca numer miesiąca w roku dla data z zakresu 1 do 12:
mysql> SELECT MONTH('2005-06-30');
    -> 6
MONTHNAME(data)
Zwraca nazwę miesiąca dla data (po angielsku):
mysql> SELECT MONTHNAME("2005-06-30");
    -> 'June'
NOW()
Zwraca bieżącą datę i czas w formacie 'YYYY-MM-DD HH:MM:SS' lub YYYYMMDDHHMMSS, zależnie od tego czy jest użyta jako łańcuch znaków, czy jako liczba:
mysql> SELECT NOW();
    -> '2005-06-30 23:50:26'
mysql> SELECT NOW() + 0;
    -> 2005-630235026
PERIOD_ADD(P, N)
Dodaje N miesięcy do okresu P (w formacie YYMM lub YYYYMM). Zwraca wartość w formacie YYYYMM:
mysql> SELECT PERIOD_ADD(0501, 5);
    -> 200506
PERIOD_DIFF(P1, P2)
Zwraca ilość miesięcy między okresami P1 i P2. P1 i P2 muszą mieć format YYMM lub YYYYMM:
mysql> SELECT PERIOD_DIFF(0506, 200501);
    -> 5
QUARTER(data)
Zwraca numer kwartału w roku dla data z zakresu 1 do 4:
mysql> SELECT QUARTER('2005-06-30');
    -> 2
SEC_TO_TIME(sekundy)
Zwraca sekundy skonwertowane na czas w formacie 'HH:MM:SS' lub HHMMSS, zależnie od tego czy jest użyta jako łańcuch znaków, czy jako liczba:
mysql> SELECT SEC_TO_TIME(2378);
    -> '00:39:38'
mysql> SELECT SEC_TO_TIME(2378) + 0;
    -> 3938
SECOND(czas)
Zwraca sekundy dla argumentu czas z zakresu 0 do 59:
mysql> SELECT SECOND('98-02-03 10:05:03');
    -> 3
SUBDATE(data, INTERVAL wartość typ)
Zobacz DATE_ADD(data, INTERVAL wartość typ)
 
SYSDATE()
Zobacz NOW()
 
TIME_FORMAT(czas, format)
Działa tak, jak DATE_FORMAT() opisana powyżej, ale argument może podawac tylko godziny, minuty i sekundy.
 
TIME_TO_SEC(czas)
Zwraca czas przeliczony na sekundy:
mysql> SELECT TIME_TO_SEC('22:23:00');
    -> 80580
mysql> SELECT TIME_TO_SEC('00:39:38');
    -> 2378
TO_DAYS(data)
Dla argumentu data zwraca numer dnia licząc od roku 0:
mysql> SELECT TO_DAYS(20050630);
    -> 732492
mysql> SELECT TO_DAYS('2005-06-30');
    -> 732492
UNIX_TIMESTAMP()
Zwraca ilość sekund od 1970-01-01 00:00:00 GMT dla podanej daty lub daty bieżącej. data może byś typu DATE, DATETIME, TIMESTAMP lub liczbą w postaci YYMMDD lub YYYYMMDD:
mysql> SELECT UNIX_TIMESTAMP();
    -> 1117029211
mysql> SELECT UNIX_TIMESTAMP(20050630120000);
    -> 1120125600
UNIX_TIMESTAMP(data)
Zobacz UNIX_TIMESTAMP()
 
WEEK(data)
WEEK(data [, początek])
Zwraca numer tygodnia w roku dla data z zakresu 0 do 53, licząc niedzielę jako początek każdego tygodnia. Drugi argument może być uzyty do określenia 1-go dnia tygodnia: 0 - niedziela lub 1 - poniedziałek:
mysql> SELECT WEEK('2005-06-26');
    -> 26
mysql> SELECT WEEK('2005-06-26', 0);
    -> 26
mysql> SELECT WEEK('2005-06-26', 1);
    -> 25
WEEKDAY(data)
Zwraca numer dnia tygodnia dla daty (0= poniedziałek, ... 6 = sobota):
mysql> SELECT WEEKDAY('2005-06-30');
    -> 3
YEAR(data)
Zwraca numer roku dla data z zakresu 1000 do 9999:
mysql> SELECT YEAR('05-06-30');
    -> 2005
YEARWEEK(data)
Zwraca numer roku i tygodnia dla data. Drugi argument jest identyczny jak dlaWEEK():
mysql> SELECT YEARWEEK('2005-06-30');
    -> 200526
YEARWEEK(data [, początek])
Zobacz YEARWEEK(data)
 

 

Pozostałe funkcje

CASE wyr WHEN [wart_1] THEN wynik1 [WHEN [wart_2] THEN wynik2 ...] [ELSE wynikN] END
CASE WHEN [war_1] THEN wynik1 [WHEN [war_2] THEN wynik2 ...] [ELSE wynikN] END
Pierwsza wersja zwraca wynikX tam, gdzie wyr = wart_X. Wersja druga zwraca wartość pierwszego spełnionego warunku. Jeśli nie ma żadnego, to zwraca jest wartość podana po ELSE. W przypadku braku części ELSE zwracana jest wartość NULL:
mysql> SELECT CASE 1 WHEN 1 THEN "aaa" WHEN 2 THEN "bbb" ELSE "ccc" END;
    -> "aaa"
mysql> SELECT CASE WHEN 1 > 0 THEN "tak" ELSE "nie" END;
    -> "tak"
mysql> SELECT CASE BINARY "B" when "a" then 1 when "b" then 2 END;
    -> NULL
CONNECTION_ID()
Zwraca identyfikator połączenia do bazy:
mysql> SELECT CONNECTION_ID();
    -> 1
DATABASE()
Zwraca nazwę bieżącej bazy danych. Jeżeli żadna baza nie jest otwarta, to zwraca pusty łańcuch znaków:
mysql> SELECT DATABASE();
    -> 'test'
DECODE(zakodowane_hasło, tekst)
Rozkodowuje zakodowane_hasło używając argumentu tekst. zakodowane_hasło jest łańcuchem zwróconym przez funkcje ENCODE().
ENCODE(hasło, tekst)
Koduje hasło używając argumentu tekst. Tak zakodowane hasło można odtworzyć używając funkcji DECODE(). Wynikiem jest łańcuch o długości argumentu hasło.
FORMAT(X, D)
Formatuje liczbę X do szablonu #,###,###.##, zaokrąglając ją do D miejsc po kropce dziesiętnej:
mysql> SELECT FORMAT(12332.123456, 4);
    -> '12,332.1235'
mysql> SELECT FORMAT(12332.1, 4);
    -> '12,332.1000'
mysql> SELECT FORMAT(12332.2, 0);
    -> '12,332'
IF(warunek, wyrażenie2, wyrażenie3)
Jeżeli warunek ma wartość TRUE i wyrażenie1 <> 0 i wyrażenie1 <> NULL, to IF() zwraca wyrażenie2, w przeciwnym wypadku wyrażenie3. IF() zwraca wartość liczbową lub łańcuch, zależnie od kontekstu, w którym zostało użyte:
mysql> SELECT IF(1&gt;2, 2, 3);
    -> 3
mysql> SELECT IF(1&lt;2, 'tak', 'nie');
    -> 'tak'
mysql> SELECT IF(strcmp('test', 'test1'), 'nie', 'tak');
    -> 'nie'
warunek jest traktowany jako wartość całkowita co oznacza, że jeśli testujesz wyrażenie zmiennoprzecinkowe lub łańcuch, powinieneś zapisać całą instrukcję w następujący sposób używając operatora porównania:
mysql> SELECT IF(0.1, 1, 0);
    -> 0
mysql> SELECT IF(0.1&lt;&gt;0, 1, 0);
    -> 1
W pierwszym z powyższych przypadków, IF(0.1) zwraca 0, ponieważ 0.1 jest przekształcane do wartości całkowitej, co w sumie daje testowanie IF(0). Może to nie być tym, czego oczekujesz. W drugim przypadku, porównanie sprawdza pierwotną wartość zmiennoprzecinkową czy nie jest ona = 0. Rezultat tego porównania użyty jest jako liczba całkowita.
 
IFNULL(wyrażenie1, wyrażenie2)
Jeżeli wyrażenie1 nie ma wartości NULL, IFNULL() zwraca wyrażenie1, w przeciwnym wypadku zwraca wrażenier2. IFNULL() zwraca wartość liczbową lub string, zależnie od kontekstu w jakim zostanie użyte:
mysql> SELECT IFNULL(1,0);
    -> 1
mysql> SELECT IFNULL(NULL,10);
    -> 10
mysql> SELECT IFNULL(1/0,10);
    -> 10
mysql> SELECT IFNULL(1/0,'tak');
    -> 'tak'
LAST_INSERT_ID([wyrażenia])
Zwraca ostatnio wygenerowaną wartość dla kolumny z atrybutem AUTO_INCREMENT.
mysql> SELECT LAST_INSERT_ID();
    -> 195
Podanie argumentu wyrażenie, powoduje, że funkcja zwróci jego wartość. Mozna to wykorzystać do tworzenia sekwencji liczb w kolejnych rekordach tabeli:
mysql> CREATE TABLE sequence (id int NOT NULL);
mysql> INSERT INTO sequence VALUES (0);
mysql> UPDATE sequence SET id=LAST_INSERT_ID(id+1);
MD5(tekst)
Oblicza liczbę kontrolną MD5 dla podanego argumentu tekst. Zwraca 32 cyfrową liczbę hexadecymalna:
mysql> SELECT md5('haslo');
    -> '207023ccb44feb4d7dadca005ce29a64'
NULLIF(wyrażenie1, wyrażenie2)
Jeżeli wyrażenie1 = wyrażenie2, to funkcja zwraca NULL, w przeciwnym wypadku zwraca wyrażenie1:
mysql> SELECT NULLIF(1,1);
    -> NULL
mysql> SELECT NULLIF(1,2);
    -> 1
PASSWORD(tekst)
Koduje hasło dla podanego argumentu tekst. Funkcja jest używana do kodowania hasła użytkownika MySQL w kolumnie Password tabeli user. nie ma funkcji rozkodowującej hasło:
mysql> SELECT PASSWORD('badpwd');
    -> '7f84554057dd964b'
VERSION()
Zwraca wersję serwera MySQL:
mysql> SELECT VERSION();
    -> '4.0.24-nt'
« wstecz   dalej »