Rozwiązanie problemu numerowania wierszy w MySQL jest niezwykle proste. Wystarczy zdefiniować zmienną globalną, która będzie przechowywać licznik i wyświetlić ją jako argument polecenia SELECT. Może to wyglądać w następujący sposób:

set @row = 0;
select @row := @row + 1 as "Lp.",
imie,
nazwisko
from klienci

Niestety, sytuacja zaczyna się komplikować, gdy rozbudujemy zapytanie. Wzbogacając je o złączenia, klauzulę WHERE oraz sortowania, możemy spodziewać się błędnego numerowania wierszy. Widać to na poniższym przykładzie pobierania danych dotyczących statystyk odwiedzin strony www:

SET @a:=0;
SELECT @a:=@a+1 AS "row",
IP
FROM `stats` st JOIN
`sources` so ON st.source_id = st.source_id
WHERE st.created_at BETWEEN "2011-01-01 00:000:00" AND "2011-01-01 23:59:59"
AND st.IP LIKE "1%"
AND st.source_id=1
ORDER BY st.IP

Wynik takiego wywołania będzie następujący:

row     IP
------  ---------------
77      100.113.10.222
50      100.113.10.222
23      100.113.10.222
60      104.87.121.89
33      104.87.121.89
6       104.87.121.89
[…]

Sposobem na rozwiązanie tego problemu będzie podzapytanie w klauzuli FROM. Wystarczy umieścić numerowanie wierszy w zewnętrznym zapytaniu i dodać do niego pozostałe interesujące nas kolumny, które będą pobierane z wewnętrznego zapytania, odpowiedzialnego za filtrowanie oraz sortowanie. Zapytanie SQL po modyfikacji może więc wyglądać w następujący sposób:

SET @a:=0;
SELECT @a:=@a+1, IP FROM (
SELECT st.IP
FROM `stats` st JOIN
`sources` so ON st.source_id = st.source_id
WHERE st.created_at BETWEEN "2011-01-01 00:000:00" AND "2011-01-01 23:59:59"
AND st.IP LIKE "1%"
AND st.source_id=1
ORDER BY st.IP
) AS sub

Numerowanie wierszy w wyniku powyższej modyfikacji będzie poprawne:

row     IP
------  ---------------
1       100.113.10.222
2       100.113.10.222
3       100.113.10.222
4       104.87.121.89
5       104.87.121.89
6       104.87.121.89
[...]

Do poniższych przykładów będzie wykorzystana fikcyjna, uproszczona baza danych, zawierająca statystyki wejść na stronę www. Tabela stats zawiera dane na temat wejść i jest powiązana z tabelą sources zawierającą źródła wejść (bezpośrednie, wyszukiwarka, odnośnik).

Do wypełnienia tabeli fikcyjnymi danymi można użyć poniższej procedury:

DELIMITER $$

CREATE DEFINER=`root`@`%` PROCEDURE `randstats`(insertLimit INT)
BEGIN
DECLARE i INT DEFAULT 0;
DECLARE randIP VARCHAR(15);
DECLARE randSoudce_id INT;
DECLARE randCreated_at DATETIME;

WHILE i < insertLimit DO
SET randIP = CONCAT_WS('.', FLOOR(1 + (RAND() * 255)), FLOOR(1 + (RAND() * 255)), 
FLOOR(1 + (RAND() * 255)), FLOOR(1 + (RAND() * 255)));
SET randSoudce_id = FLOOR(1 + (RAND() * 3));
SET randCreated_at = '2010-01-01 00:00:00' + INTERVAL FLOOR(1 + (RAND() * 60*24*7*4*12*2)) MINUTE;

INSERT INTO `stats`(source_id, created_at, IP) VALUES (randSoudce_id, randCreated_at, randIP);

SET i = i + 1;
END WHILE;
END $$

DELIMITER ;

call randstats(100000);

Grupowanie względem dnia

Powiedzmy, że zależy nam na wyciągnięciu statystyk wejść na stronę www z ostatniego miesiąca, z podziałem na poszczególne dni. W tym celu wystarczy skorzystać z funkcji DATE(), która zwraca samą datę z wyrażenia typu datetime.

SELECT
DATE(created_at) AS dzien,
COUNT(*) AS ilosc
FROM stats
WHERE created_at BETWEEN "2011-01-01 00:00:00" AND "2011-01-31 23:59:59"
GROUP BY dzien
ORDER BY dzien;

Wynik wywołania zapytania będzie następujący:

dzien       ilosc
----------  ------
2011-01-01  168
2011-01-02  187
2011-01-03  190
2011-01-04  201
...

Grupowanie względem tygodnia

Oczywiście sytuacja jest analogiczna do powyższego, będziemy jednak pobierali statystyki z ostatniego roku. Do odpowiedniego grupowania potrzebna będzie funkcja DATE_FORMAT() lub YEARWEEK(). Lepiej będzie skorzystać z tej drugiej, z uwagi na lepszą wydajność.

Funkcja YEARWEEK() zwraca w MySQL sześciocyfrowy ciąg, określający rok oraz numer tygodnia. Pierwszym parametrem jest data, natomiast drugim, opcjonalnym, tryb w jakim ma działać. Określa czy tydzień zaczyna się od niedzieli, czy też od poniedziałku (domyślną wartością jest zmienna systemowa default_week_format).

SELECT
YEARWEEK(created_at) AS tydzien,
COUNT(*) AS ilosc
FROM stats
WHERE created_at BETWEEN "2011-01-03 00:00:00" AND "2011-04-31 23:59:59"
GROUP BY tydzien
ORDER BY tydzien;

Wynik wywołania zapytania będzie następujący:

tydzien  ilosc
-------  ------
201101   1320
201102   1320
201103   1321
201104   1250
...

Grupowanie względem miesiąca

W tym przypadku najlepiej będzie skorzystać z funkcji EXTRACT() z odpowiednim parametrem YEAR_MONTH, dzięki czemu otrzymamy sześcioznakowy ciąg: połączenie roku oraz miesiąca. Pobranie pogrupowanych statystyk na dany miesiąc w roku 2011 może więc wyglądać następująco:

SELECT
EXTRACT(YEAR_MONTH FROM created_at) AS miesiac,
COUNT(*) AS ilosc
FROM stats
WHERE created_at BETWEEN "2011-01-01 00:00:00" AND "2011-12-31 23:59:59"
GROUP BY miesiac
ORDER BY miesiac;

Wynik wywołania zapytania będzie następujący:

miesiac  ilosc
-------  ------
201101   5738
201102   5130
201103   5713
201104   5405
...

Grupowanie względem roku

W tym przypadku sprawa jest prosta – wystarczy wykorzystać funkcję YEAR(), która zwraca rok z przekazanej daty:

SELECT
YEAR(created_at) AS rok,
COUNT(*) AS ilosc
FROM stats
GROUP BY rok
ORDER BY rok;

Wynik wywołania zapytania będzie następujący:

rok     ilosc
------  ------
2010    66793
2011    56547

Grupowanie z uwzględnieniem typu

Na zakończenie mała ciekawostka, czyli sposób na policzenie ilości wejść na stronę z podziałem na źródła. Do tego celu wykorzystamy pierwsze zapytanie (grupowanie na dzień), wymaga ono jednak pewnej modyfikacji, w postaci odpowiedniego wywołania funkcji SUM().

Na początek należy przypomnieć, że źródła wejść w tabeli sources przedstawiają się następująco:

source_id  source_name
---------  -------------
1          bezpośrednie
2          wyszukiwarka
3          odnośnik

Tak, więc aby zliczyć wystąpienia poszczególnych źródeł w podziale na dni, należy użyć odpowiednio instrukcji CASE w połączeniu z SUM(). Widać to na poniższym przykładzie:

SELECT
DATE(created_at) AS dzien,
SUM(CASE WHEN`source_id` = 1 THEN 1 ELSE 0 END) AS bezposrednie,
SUM(CASE WHEN`source_id` = 2 THEN 1 ELSE 0 END) AS wyszukiwarka,
SUM(CASE WHEN`source_id` = 3 THEN 1 ELSE 0 END) AS odnosnik
FROM stats
WHERE created_at BETWEEN "2011-01-01 00:00:00" AND "2011-01-31 23:59:59"
GROUP BY dzien
ORDER BY dzien;

Wynik wywołania zapytania będzie następujący:

dzien       bezposrednie  wyszukiwarka  odnosnik
----------  ------------  ------------  ---------
2011-01-01  50            69            49
2011-01-02  77            47            63
2011-01-03  61            66            63
2011-01-04  62            55            84
2011-01-05  55            57            56
2011-01-06  69            64            59
...

Artykuł został oparty na tekście ze strony http://www.techfounder.net

Podstawowym sposobem na wyszukiwania według określonego formatu jest w MySQL konstrukcja LIKE. Możemy w niej skorzystać z następujących konstrukcji:

• _ – każdy pojedynczy znak
• % – wiele dowolnych znaków (włączając w to ich brak)

Przykładowe zapytanie:

select x from tabela where y like "a_cd%h";

zwróci wszystkie rekordy, dla których kolumna “x” rozpoczyna się od znaku „a”, po którym występuje jeden dowolny znak, następnie ciąg „cd”, nieokreślona liczba dowolnych znaków i na końcu znak „h”.

Takie wyszukiwania są jednak mocno ograniczone, często potrzebujemy wyboru bardziej szczegółowego formatu. Z pomocą mogą tu przyjść wyrażenia regularne, z którym możemy korzystać w MySQL poprzez konstrukcje REGEXP oraz NOT REGEXP (lub ich synonimy RLIKE oraz NOT RLIKE). W MySQL obowiązuje format Perla, czyli na przykład:

select * from tabela where pole regexp '^[a-c]{1,3}X[0-9]*';

Wyrażenia regularne w MySQL mogą zawierać następujące konstrukcje:

• ^ – wyrażanie regularne rozpoczyna się od zdefiniowanego wzorca, np. ^x oznacza dowolny ciąg zaczynający się od znaku „x”
• $ – wyrażanie regularne kończy się na zdefiniowanym wzorcu, np. x$ oznacza dowolny ciąg kończący się znakiem „x”
• . – dowolny pojedynczy znak
• * – zero lub więcej znaków, po jakim została umieszczona gwiazdka, np. x* oznacza dowolną liczbę wystąpień litery „x”, [0-9]* oznacza dowolną liczbę wystąpień jakiejkolwiek cyfry, (abc)* dowolną liczbę wystąpień ciągu „abc”, natomiast .* dowolny ciąg znaków
• + – jedno lub więcej wystąpienie określonego ciągu po jakim został umieszczony +, np. x+ oznacza jeden lub więcej „x”, [a-c]+ oznacza jedną lub więcej literę a, b lub c
• ? – zero lub jedno wystąpienie poprzedzającego znaku, np. x? oznacz zero lub jedno wystąpienie znaku „x”
• [..] – zakres znaków, np. [a-zA-GXYZ5-9] oznacza wszystkie małe litery, duże od A do G oraz X, Y, Z, cyfry od 5-9. Można stosować zaprzeczenie poprzez ^, np. [^3-5] oznacza wszystkie ciągi, które nie zawierają liczb 3, 4 oraz 5.
• | – logiczne lub, np. abc|def oznacza ciąg abc lub def
• {n}, {n, m} – określa liczbę wystąpień poprzedzającego wyrażenia, np. a{4} oznacza znak „a” występujący dokładnie 4 razy, [a-c]{2,3} oznacza znak a, b lub c występujący od 2 do 3 razy. Można także stosować konstrukcję {0,}, która jest tożsama z operatorem * oraz {1,}, który oznacza to samo co +

Aby użyć znaku specjalnego (+, -, *, &, itp) musimy posłużyć się podwójnymi slashami. Przykładowo, aby odnaleźć ciąg 1+2 należy zastosować wyrażenie regularne w postaci 1\\+2.

Znaki w wyrażaniach regularnych możemy pisać wprost ([abc], \\+, \\’ itp.) lub stosując specjalną konstrukcję w postaci [.znaki.] . Przykładowo, aby znaleźć ciągi zawierające tyldę możemy posłużyć się zapytaniami:

SELECT x FROM tabela REGEXP '\\~';
SELECT x FROM tabela REGEXP '[[.~.]]';
SELECT x FROM tabela REGEXP '[[.tilde.]]';

Tego typu zapisów jest dość sporo, przykładowe to:

• newline – nowa linia \n
• tab – tabulacja \t
• apostrophe – pojedynczy apostrof ‚
• carriage-return – znak powrotu karetki \r
• plus-sign – znak „plus” +

Można także stosować klasy znaków, zawierające okresloną grupę wzorców. Na przykład [:alnum:] oznacza wszystkie znaki alfanumeryczne. Inne możliwości są następujące:

• alnum – znaki alfanumeryczne
• alpha – litery alfabetu
• blank – białe znaki
• cntrl – znaki kontrolne
• digit – cyfry
• graph – znaki graficzne
• lower – małe litery alfabetu
• print – znaki graficzne lub spacje
• punct – znaki interpunkcyjne
• space – spacja, tabulacja, znak nowej linii oraz powrotu karetki
• upper – duże litery alfabetu
• xdigit – znaki heksadecymalne

InnoDB domyślnym typem tabel

Dotychczas zakładając tabele w MySQL, domyślnym typem był MyISAM. Zalecenia specjalistów są jednak jednoznaczne – znacznie lepiej korzystać z InnoDB. Stanowi ono rozwiązanie wydajniejsze, oferujące transakcje, klucze obce oraz odzyskiwanie danych w przypadku awarii. Dlatego ten typ stał się domyłbym rozwiązaniem w nowej wersji bazy. Dodatkowo Oracle twierdzi, że w MySQL 5.5 InnoDB zostało zoptymalizowane pod kątem wielordzeniowych procesorów oraz poprawiono skalowalność.

Poprawiona replikacja

Wprowadzono dwa nowe mechanizmy. Półsynchroniczna replikacja poprawia niezawodność dzięki temu, że węzeł master może czekać, aż ostatni slave zaloguje transakcję. Drugim rozwiązaniem jest tzw. Replication HeartBeat. Dzięki temu użytkownik jest powiadamiany, że replikacja przestała działać. Realizowane jest to dzięki przesyłaniu w regularnych odstępach czasu od węzła master do węzłów slave informacji o pracy. Jeśli z jakiegoś powodu informacja taka nie dotrze, węzeł slave uzyska wiadomość, że połączenie z głównym serwerem nie działa prawidłowo.

Zwiększona wydajność

Oracle chwali się, że po aktualizacji do MySQL 5.5 wzrośnie ona wielokrotnie. Szczególnie ma to mieć miejsce w środowisku Windows, gdzie wg oficjalnych komunikatów producenta wydajność ma się poprawić nawet o 1500% w trybie Read/Write (benchmark SysBench). Nie ucieszy to jednak zbyt wielu osób, produkcyjne środowiska oparte na Winodws należą do rzadkości.

Jednak wzrost wydajności nastąpił także w przypadku Linux. W trybie Read/Write benchmark SysBench notował polepszenie do 360%, w trybie Read only do 200%. Jeśli wyniki te potwierdzą się w normalnych serwisach produkcyjnych, mogą znacząco wpłynąć na poprawę wydajności korzystających z nich aplikacji.

Ładowanie danych z XML

Pojawiła się nowa komenda LOAD XML, dzięki której można importować dane zawarte w pliku XML bezpośrednio do tabeli w bazie. Komenda ma następującą postać:

LOAD XML [LOW_PRIORITY | CONCURRENT] [LOCAL] INFILE 'file_name'
[REPLACE | IGNORE]
INTO TABLE [db_name.]tbl_name
[CHARACTER SET charset_name]
[ROWS IDENTIFIED BY '<tagname>']
[IGNORE number [LINES | ROWS]]
[(column_or_user_var,...)]
[SET col_name = expr,...]

Polecenie umożliwia import z plików XML przygotowanych w trzech różnych formatach:

<row column1="value1" column2="value2" .../>

<row>
<column1>value1</column1>
<column2>value2</column2>
</row>

<row><field name='column1'>value1</field>
<field name='column2'>value2</field>
</row>

Funkcja TO_SECONDS()

Nowa funkcja, która pomaga w zarządzaniu datami i czasem. Przyjmuje jako parametr datę z ewentualnym czasem, zwraca natomiast liczbę sekund jaka upłynęła od roku 0. Poniżej przedstawiono przykładowe działanie:

mysql> SELECT TO_SECONDS(950501);
 -> 62966505600
mysql> SELECT TO_SECONDS('2009-11-29');
 -> 63426672000
mysql> SELECT TO_SECONDS('2009-11-29 13:43:32');
 -> 63426721412
mysql> SELECT TO_SECONDS( NOW() );
 -> 63426721458

Oprócz tego…

Z innych zmian wprowadzonych w MySQL 5.5 warto wymienić lepsze mechanizmy zarządzania, ulepszone partycjonowanie tabel, zmianę w składni SIGNAL/RESIGNAL oraz poprawę diagnostyki w postaci nowego PERFORMANCE_SCHEMA.

Pełna lista zmian została przedstawiona w dokumencie, który możemy zamówić na maila na stronie projektu MySQL.