· 7 years ago · Dec 06, 2018, 06:18 PM
1Utworzenie bazy danych:
2CREATE database nazwa_bazy;
3
4Wybranie bazy danych:
5USE nazwa_bazy;
6
7Aktualnie wybrana baza:
8SELECT database();
9
10Lista istniejÄ…cych baz danych:
11SHOW databases;
12
13//----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
14
15TYPY DANYCH:
16 TINYINT 1-bajtowe pole, przechowujące wartości całkowite bez znaku z przedziału od 0 do 255 lub ze znakiem z przedziału od -127 do 127
17 SMALLINT 2-bajtowa wartość całkowita. Zakres wartości bez znaku od 0 do 65 535 lub ze znakiem od -32 768 do 32 768
18 MEDIUMINT 3-bajtowa wartość całkowita. Zakres wartości od 0 do 16 777 215 lub ze znakiem od -8 388 608 do 8 388 608
19 INT 4-bajtowa wartość całkowita. Zakres wartości ze znakiem od -2 147 483 648 do 2 147 483 647 lub bez znaku od 0 do 4 294 967 295
20 BIGINT 8-bajtowa wartość całkowita. Typ BIGINT jest używany podczas przeprowadzania obliczeń. Stosując pola tego typu we własnej bazie danych należy uważać, aby ich wartości nie były zbyt duże, ponieważ użyte w obliczeniach mogą doprowadzić do błędu przepełnienia
21 FLOAT(dokładność) Liczba zmiennoprzecinkowa z precyzją wyrażaną liczbą bajtów. Dwie wartości akceptowane jako precyzja to 4 i 8. Użycie 4 tworzy liczbę zmiennoprzecinkową o pojedynczej precyzji, natomiast 8 - liczbę zmiennoprzecinkową o podwójnej precyzji. Szczegóły dotyczące tych dwóch typów danych opisują pola FLOAT i DOUBLE
22 FLOAT 4-bajtowa liczba zmiennoprzecinkowa z zakresu od -1.402823466E+38 do -1.175494351E-38, 0 i 1.175494351E-38 do 3.402823466E+38
23 DOUBLE 8-bajtowa liczba zmiennoprzecinkowa przechowująca wartości z zakresu od -1.7976931348623157E+308 do -2.2250738585072014E-308, 0, i 2.2250738585072014E-308 do 1.7976931348623157E+308
24 DECIMAL Pole zmiennoprzecinkowe o takiej samej pojemności jak DOUBLE. Liczba, zamiast zostać zredukowana do postaci szesnastkowej, pamiętana jest w formacie znakowym
25 DATE Data (bez czasu), wyświetlana w formacie RRRR-MM-DD. Akceptuje daty w różnych formatach z zakresu od 1000-01-01 do 9999-12-31
26 DATETIME Pole daty z czasem dnia wyświetlane według formatu RRRR-MM-DD GG:MM:SS. Może przechowywać wartości z zakresu od 1000-01-01 00:00:00 do 9999-12-31 23:59:59
27 TIMESTAMP Data i czas liczony od początku epoki systemu UNIX, 1970-01-01 00:00:00, do momentu kiedy 32-bitowe pole przechowujące liczbę sekund, jaka upłynęła od tej daty ulegnie przepełnieniu w roku 2037. Jeśli polu temu nie została nadana wartość przez wyrażenie INSERT lub UPDATE, domyślnie otrzyma ono wartość daty bieżącej
28 TIME Czas mieszczÄ…cy siÄ™ w przedziale od -838:59:59 do 838:59:59
29 YEAR Rok. Dozwolone wartości to przedział od 1901 do 2155 oraz wartość 0000. MySQL wyświetla wartość typu YEAR w formacie RRRR
30 CHAR Pole znakowe o stałej długości z zakresu od 1 do 255 bajtów. Po wstawieniu wartości puste miejsca pola CHAR są uzupełniane z prawej strony spacjami
31 VARCHAR Pole znakowe o zmiennej długości z zakresu od 1 do 255 bajtów. Zajmowany jest jedynie taki obszar pamięci, jakiego wymaga wartość wstawiona w to pole
32 TINYBLOB Kolumna binarna o rozmiarze nie przekraczającym 255 bajtów
33 TINYTEXT Kolumna tekstowa o rozmiarze nie przekraczającym 255 bajtów
34 BLOB, TEXT Kolumna binarna lub tekstowa o rozmiarze nie przekraczającym 65 535 bajtów
35 MEDIUMBLOB, MEDIUMTEXT Kolumna binarna lub tekstowa o rozmiarze nie przekraczającym 16 777 215 bajtów
36 LONGBLOB, LONGTEXT Kolumna binarna lub tekstowa o rozmiarze nie przekraczającym 4 294 967 295 bajtów
37 ENUM('elem1', 'elem2',...) Kolumna łańcuchowa, która może zawierać jedną z wartości wymienionych na liście wartości w definicji tej kolumny
38 SET('elem1', 'elem2',...) Kolumna łańcuchowa, która może zawierać dowolną liczbę wartości spośród wartości występujących na liście w definicji tej kolumny
39
40PARAMETRY PÓL:
41 PRIMARY KEY - dane pole jest niepowtarzalne, jednoznacznie identyfikuje wiersz, tylko jedno może być w tabeli
42 UNIQUE - to samo co PRIMARY KEY z tym że może być kilka takich pól
43 AUTO_INCREMENT - automatyczna numeracja pól, pole powinno być także PRIMARY KEY
44 NULL - pole może być puste
45 NOT NULL - pole nie może być puste
46 UNSIGNED - liczba bez znaku
47 DEFAULT - wartość domyślna
48
49
50// NAZWA_POLA TYP(dokładność_typu) PARAMETRY
51
52Utworzenie nowej tabeli:
53CREATE TABLE nazwa_tabeli
54(
55 id int(5) NOT NULL AUTO_INCREMENT PRIMARY KEY,
56 imie varchar(15) NOT NULL,
57 nazwisko varchar(20) NOT NULL,
58 email varchar(50) NULL,
59 ulica varchar(50) NULL,
60 miasto varchar(50) NULL,
61 data_ur date NULL DEFAULT '0000-00-00'
62);
63
64Utworzenie nowej tabeli jeśli tabela o takiej nazwie jeszcze nie istnieje:
65CREATE TABLE IF NO EXISTS nazwa_tabeli
66(
67 id int(5) NOT NULL AUTO_INCREMENT PRIMARY KEY,
68 imie varchar(15) NOT NULL,
69 nazwisko varchar(20) NOT NULL,
70 email varchar(50) NULL,
71 ulica varchar(50) NULL,
72 miasto varchar(50) NULL,
73 data_ur date NULL DEFAULT '0000-00-00'
74);
75
76PARAMETRY TABELI:
77 ENGINE – mechanizm składowanie danych, MyISAM jest domyślnym dla MySQL
78 DEFAULT CHARSET – kodowanie bazy danych
79 COLLATE – metoda porównywania napisów (kończące się na CI nie rozpoznają wielkości liter, a z BIN i CS tak)
80
81Tworzenie nowej tabeli z dodatkowymi ustawieniami:
82CREATE TABLE nazwa_tabeli
83(
84 id int(5) NOT NULL AUTO_INCREMENT PRIMARY KEY,
85 imie varchar(15) NOT NULL,
86 nazwisko varchar(20) NOT NULL,
87 email varchar(50) NULL,
88 ulica varchar(50) NULL,
89 miasto varchar(50) NULL,
90 data_ur date NULL DEFAULT '0000-00-00'
91) ENGINE=MyISAM DEFAULT CHARSET=utf8 COLLATE=utf8_polish_ci;
92
93
94Wyświetla strukturę tabeli:
95describe nazwa_tabeli;
96
97Lista tabel w aktualnie wybranej bazie:
98SHOW tables;
99
100Usunięcie tabeli:
101DROP TABLE nazwa_tabeli;
102
103//----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
104
105Utwórz nowy wiersz i uzupełnij wartościami:
106INSERT INTO nazwa_tabeli VALUES (lista_wartości)
107
108Utwórz nowy wiersz i uzupełnij wymienione kolumny konkretnymi wartościami:
109INSERT INTO nazwa_tabeli (nazwy_kolumn) VALUES (lista_wartości);
110
111//----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
112
113Pobierz wszystkie wiersze z tabeli:
114SELECT * FROM nazwa_tabeli;
115
116Pobierz wszystkie wiersze w których spełniony jest warunek:
117SELECT * FROM nazwa_tabeli WHERE warunki_które_muszą_spełniać_dane;
118
119Pobierz poszczególne kolumny z wszystkich wierszy tabeli:
120SELECT nazwy_kolumn FROM nazwa_tabeli;
121
122Pobierz poszczególne kolumny z wierszy tabeli w których spełniony jest warunek:
123SELECT nazwy_kolumn FROM nazwa_tabeli WHERE warunki_które_muszą_spełniać_dane;
124
125//----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
126
127OPERATORY PORÓWNANIA:
128 < mniejsze niż
129 <= mniejsze niż lub równe
130 = równe
131 != lub <> nierówne
132 >= większe niż lub równe
133 > większe niż
134
135Pobierz wszystkie wiersze z tabeli gdzie spełnione jest porównanie:
136SELECT * FROM nazwa_tabeli WHERE nazwa_kolumny > wartość;
137
138//----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
139
140OPERATORY LOGICZNE:
141 AND logiczne „iâ€
142 OR logiczne „lubâ€
143 NOT logiczne przeczenie
144 IN zawiera siÄ™ w zadanym zbiorze
145 BETWEEN zawiera siÄ™ w zadanym przedziale
146
147Pobierz wszystkie wiersze z tabeli gdzie spełnione są oba porównania:
148SELECT * FROM nazwa_tabeli WHERE nazwa_kolumny_1 != wartość_1 AND nazwa_kolumny_2 <= wartość_2;
149
150Pobierz wszystkie wiersze z tabeli w których pole ma jedną z podanych wartości:
151SELECT * FROM nazwa_tabeli WHERE nazwa_kolumny IN (wartosci);
152
153Pobierz wszystkie wiersze z tabeli w których pole mieści się w podanym zakresie:
154SELECT * FROM nazwa_tabeli WHERE nazwa_kolumny BETWEEN wartosc_1 AND wartosc_2;
155
156//----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
157
158TYPY SORTOWAŃ:
159 DESC malejÄ…ce
160 ASC rosnÄ…ce
161
162Zwróć wszystkie wiersze tabeli posortowane malejąco względem wybranej kolumny:
163SELECT * FROM nazwa_tabeli ORDER BY nazwa_kolumny DESC;
164
165Zwróć wszystkie wiersze tabeli posortowane rosnąco względem wybranej kolumny:
166SELECT * FROM nazwa_tabeli ORDER BY nazwa_kolumny ASC;
167
168Najpierw posortowana zostanie kolumna2, a potem zostanie posortowana kolumna1:
169SELECT * FROM nazwa_tabeli ORDER BY nazwa_kolumny_1 ASC, nazwa_kolumny_2 DESC;
170
171//----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
172
173Pobierz konkretną ilość rekordów:
174SELECT * FROM nazwa_tabeli LIMIT ilość_rekordów;
175
176Pobierz konkretną ilość rekordów zaczynając od konkretnego rekordu:
177SELECT * FROM nazwa_tabeli LIMIT od_rekordu, ilość_rekordów; //numeracja od 0
178
179//----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
180
181ÅÄ…czy dwie kolumny w jednÄ…. W tym przypadku oddziela ich wartoÅ›ci spacjÄ…. PoÅ‚Ä…czenie obu kolumn jest dostÄ™pne jako nowa nazwa kolumny którÄ… podaliÅ›my:
182SELECT CONCAT(nazwa_kolumny_1," ",nazwa_kolumny_2) AS "Nazwa_połączonych_kolumn" FROM nazwa_tabeli;
183
184//----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
185
186WYRAŻENIA REGULARNE:
187 % - dowolna ilość znaków
188 _ - 1 znak
189
190Pobierz wszystkie wiersze gdzie wartość kolumny to dowolny wyraz zaczynający się od szt:
191SELECT * FROM nazwa_tabeli WHERE nazwa_kolumny LIKE 'szt%';
192
193Pobierz wszystkie wiersze gdzie wartość kolumny to dowolny wyraz składający się dokładnie z 5 znaków:
194SELECT * FROM nazwa_tabeli WHERE nazwa_kolumny LIKE '_____';
195
196//----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
197
198Pomijane są rekordy, które zawierają powtarzające się wartości we wszystkich wybieranych polach:
199SELECT DISTINCT nazwy_kolumn FROM nazwa_tabeli;
200
201Pomijane są rekordy, które się powtarzają na podstawie całego wiersza, a nie tylko wybranych pól:
202SELECT DISTINCTROW nazwy_kolumn FROM nazwa_tabeli;
203
204//----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
205
206Ilość wszytskich wierszy w tabeli. Nie pomija NULL:
207SELECT COUNT(*) FROM nazwa_tabeli;
208
209Ilość wierszy spełniających warunek. Nie pomija NULL:
210SELECT COUNT(*) FROM nazwa_tabeli WHERE warunek;
211
212Ilość wierszy w których wartość wskazanej kolumny nie jest równa NULL:
213SELECT COUNT(nazwa_kolumny) FROM nazwa_tabeli;
214
215Ilość wierszy z unikalną wartością wskazanej kolumny:
216SELECT COUNT(DISTINCT nazwa_kolumny) FROM nazwa_tabeli;
217
218Ilość unikalnych wierszy:
219SELECT COUNT(DISTINCTROW nazwa_kolumny) FROM nazwa_tabeli;
220
221//----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
222
223Zwraca sumę wartości we wskazanej kolumnie. Wartości NULL są pomijane. Tylko dla liczb:
224SELECT SUM(nazwa_kolumny) FROM nazwa_tabeli;
225
226Zwraca sumę wartości we wskazanej kolumnie z wierszy spełniających warunek. Wartości NULL są pomijane. Tylko dla liczb:
227SELECT SUM(nazwa_kolumny) FROM nazwa_tabeli WHERE warunek;
228
229//----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
230
231Zwraca wartość średnią we wskazanej kolumnie. Wartości NULL są pomijane. Tylko dla liczb:
232SELECT AVG(nazwa_kolumny) FROM nazwa_tabeli;
233
234Zwraca wartość średnią we wskazanej kolumnie z wierszy spełniających warunek. Wartości NULL są pomijane. Tylko dla liczb:
235SELECT AVG(nazwa_kolumny) FROM nazwa_tabeli WHERE warunek;
236
237//----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
238
239MAX i MIN znajdują największą i najmniejszą liczbę, najodleglejszą i najbliższą datę, najdłuższy i najkrótszy tekst, w zależności od typu danych w kolumnie.
240
241Zwraca najmniejszą wartość we wskazanej kolumnie. Wartości NULL są pomijane:
242SELECT MIN(nazwa_kolumny) FROM nazwa_tabeli;
243
244Zwraca największą wartość we wskazanej kolumnie. Wartości NULL są pomijane:
245SELECT MAX(nazwa_kolumny) FROM nazwa_tabeli;
246
247//----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
248
249GROUP BY pozwala na grupowanie wyników względem zawartości wybranych kolumn. Podobnie jak DISTINCT zwraca po 1 unikalnym rekordzie dla każdej grupy:
250SELECT * FROM nazwa_tabeli GROUP BY nazwa_kolumny;
251
252Funkcje typu COUNT, MAX, MIN, AVG, SUM zwracają wartości dla całej kolumny lub wybranego fragmentu kolumny. Z użyciem GROUP BY mogą zwracać także wartość dla każdej z grup.
253
254Ilość wierszy w poszczególnych grupach:
255SELECT COUNT(*) FROM nazwa_tabeli GROUP BY nazwa_kolumny;
256
257Suma wartości w poszczególnych grupach:
258SELECT SUM(nazwa_kolumny_1) FROM nazwa_tabeli GROUP BY nazwa_kolumny_2;
259
260HAVING to warunek ale wykonywany już po pobraniu danych, dzięki czemu możemy użyć w nim takie funkcje jak COUNT, MAX, MIN, SUM:
261SELECT * FROM nazwa_tabeli GROUP BY nazwa_kolumny HAVING warunek;
262
263Wyświetl sumę wartości z grup o ilości elementów większych niż podana wartość:
264SELECT * FROM SUM(nazwa_kolumny_1) GROUP BY nazwa_kolumny_2 HAVING COUNT(*) > wartosc;
265
266//----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
267
268Wyświetla zwrócone wartości z kolumny w jednej linii oddzielone od siebie przecinkiem:
269SELECT GROUP_CONCAT(nazwa_kolumny) FROM nazwa_tabeli;
270
271Wyświetla zwrócone wartości z kolumny w jednej lini oddzielone od siebie wskazanym separatorem(tu spacja):
272SELECT GROUP_CONCAT(nazwa_kolumny SEPARATOR ' ') FROM nazwa_tabeli;
273
274Jak wyżej tylko że wartości pól łączy spacją, a wiersze przecinkiem:
275SELECT GROUP_CONCAT(nazwa_kolumny_1," ",nazwa_kolumny_2 SEPARATOR ', ') FROM nazwa_tabeli;
276
277//----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
278
279Czyści całą tabelę:
280DELETE FROM nazwa_tabeli;
281
282Usuwa wiersze spełniające warunek:
283DELETE FROM nazwa_tabeli WHERE warunek_jakie_musza_spelniac_wiersze;
284
285//----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
286
287Aktualizuj wszystkie wiersze zmieniając wartości pól w poszczególnych kolumnach:
288UPDATE nazwa_tabeli SET nazwa_kolumny_1=wartosc_pola_1, nazwa_kolumny_2=wartosc_pola_2
289
290Aktualizuj wszystkie wiersze spełniające warunek zmieniając wartości pól w poszczególnych kolumnach:
291UPDATE nazwa_tabeli SET nazwa_kolumny_1=wartosc_pola_1, nazwa_kolumny_2=wartosc_pola_2 WHERE warunek
292
293//----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
294
295Dodanie nowej kolumny do tabeli:
296ALTER TABLE nazwa_tabeli ADD COLUMN nazwa_kolumny;
297
298Usunięcie kolumny z tabeli:
299ALTER TABLE nazwa_tabeli DROP COLUMN nazwa_kolumny;
300
301Zmiana nazwy tabeli:
302ALTER TABLE nazwa_tabeli_1 RENAME TO nazwa_tabeli_2;
303
304Zmiana struktury kolumny:
305ALTER TABLE nazwa_tabeli CHANGE COLUMN nazwa_kolumny nazwa_kolumny TYP_DANYCH PARAMETRY_POLA;
306
307//----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
308
309ZÅÄ„CZENIA TABEL:
310 Złączenia pobierają pola z obu tabel. Wynikiem jest tabela z kolumnami obu tabel. Za warunek złączenia trzeba podać któreś z pól.
311
312 Rysunek pokazujący poszczególne złączenia:
313 http://i.imgur.com/lrL56IT.jpg
314
315Pozwala pobrać wszystkie rekordy z tabeli1 mające odpowiedniki w tabeli2. Część wspólna obu tabel:
316SELECT * FROM nazwa_tabeli_1 INNER JOIN nazwa_tabeli_2 ON nazwa_tabeli_1.nazwa_kolumny = nazwa_tabeli_2.nazwa_kolumny;
317
318Pozwala pobrać wszystkie rekordy z tabeli1 wraz z odpowiadającymi im rekordami z tabeli2 nawet jak w tabeli2 nie ma odpowiedników dla rekordów z tabeli1:
319SELECT * FROM nazwa_tabeli_1 LEFT JOIN nazwa_tabeli_2 ON nazwa_tabeli_1.nazwa_kolumny = nazwa_tabeli_2.nazwa_kolumny;
320
321Pozwala pobrać wszystkie rekordy z tabeli1, które nie mają odpowiedników w tabeli2:
322SELECT * FROM nazwa_tabeli_1 LEFT JOIN nazwa_tabeli_2 ON nazwa_tabeli_1.nazwa_kolumny = nazwa_tabeli_2.nazwa_kolumny WHERE nazwa_tabeli_2.nazwa_kolumny IS NULL;
323
324Pozwala pobrać wszystkie rekordy z tabeli2 wraz z odpowiadającymi im rekordami z tabeli1 nawet jak w tabeli1 nie ma odpowiedników dla rekordów z tabeli2:
325SELECT * FROM nazwa_tabeli_1 RIGHT JOIN nazwa_tabeli_2 ON nazwa_tabeli_1.nazwa_kolumny = nazwa_tabeli_2.nazwa_kolumny;
326
327Pozwala pobrać wszystkie rekordy z tabeli2, które nie mają odpowiedników w tabeli1:
328SELECT * FROM nazwa_tabeli_1 RIGHT JOIN nazwa_tabeli_2 ON nazwa_tabeli_1.nazwa_kolumny = nazwa_tabeli_2.nazwa_kolumny WHERE nazwa_tabeli_1.nazwa_kolumny IS NULL;
329
330Złączenie zwracające wszystkie rekordy z tabeli1 i tabeli2, które nie mają swoich odpowiedników w drugiej z tabel. Wszystko poza częśćią wspólną. Domyślnie nie obsługiwana przez MySQL:
331SELECT * FROM nazwa_tabeli_1 FULL OUTER JOIN nazwa_tabeli_2 ON nazwa_tabeli_1.nazwa_kolumny = nazwa_tabeli_2.nazwa_kolumny WHERE nazwa_tabeli_1.nazwa_kolumny IS NULL OR nazwa_tabeli_2.nazwa_kolumny IS NULL;
332
333Złączenie zwracające wszystkie rekordy z tabeli1 i tabeli2 odpowiednio ze sobą połączone. Całość. Domyślnie nie obsługiwana przez MySQL:
334SELECT * FROM nazwa_tabeli_1 FULL OUTER JOIN nazwa_tabeli_2 ON nazwa_tabeli_1.nazwa_kolumny = nazwa_tabeli_2.nazwa_kolumny;
335
336//----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
337
338ÅÄ…czy dwa zestawy danych w jeden. Usuwa powtórzenia. Warunek użycia UNION jest taki że musi być tyle samo kolumn w obu zapytaniach SELECT. Druga tabela jest doklejana na dół pierwszej:
339(SELECT nazwy_kolumn_1 FROM nazwa_tabeli) UNION (SELECT nazwy_kolumn_2 FROM nazwa_tabeli);
340
341Jak wyżej tylko że z sortowaniem:
342(SELECT nazwy_kolumn_1 FROM nazwa_tabeli) UNION (SELECT nazwy_kolumn_2 FROM nazwa_tabeli) ORDER BY ASC;
343
344ÅÄ…czy dwa zestawy danych w jeden jak wyżej. Nie usuwa powtórzeÅ„:
345(SELECT nazwy_kolumn_1 FROM nazwa_tabeli) UNION ALL (SELECT nazwy_kolumn_2 FROM nazwa_tabeli);
346
347//----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
348
349Pobieranie danych z innej bazy niż obecnie wybrana:
350SELECT * FROM nazwa_bazy.nazwa_tabeli;
351
352//----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
353
354Utworzenie kopii tabeli pod innÄ… nazwÄ…:
355CREATE TABLE nowa_tabela (SELECT * FROM stara_tabela);
356
357Tworzenie nowej tabeli z rezultatu dowolnego polecenia typu SELECT:
358CREATE TABLE nowa_tabela (SELECT nazwy_kolumn FROM stara_tabela WHERE warunek);
359
360//----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
361
362Uzupełnienie istniejącej tabeli wartościami z innej tabeli:
363INSERT INTO nazwa_tabeli_1 SELECT * FROM nazwa_tabeli_2;
364
365Uzupełnienie poszczególnych kolumn istniejącej tabeli wynikiem zwróconym przez select:
366INSERT INTO nazwa_tabeli_1 (nazwy_kolumn_1) (SELECT nazwy_kolumn_2 FROM nazwa_tabeli_2 WHERE warunek);
367
368//----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
369
370Zmiana metody porównywania napisów dla warunku. Gdy używamy kodowania kończącego się na CI, a chcemy rozpoznać wielkość liter należy podać tu kodowanie kończące się na BIN lub CS:
371SELECT * FROM nazwa_tabeli WHERE warunek COLLATE kodowanie;
372
373//----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
374
375Tworzy kombinację wszystkich wierszy tabeli1 z wierszami tabeli2. Nie używać dla dużych tabel. Ilość wierszy w zwróconej tabeli to iloczyn ilości wierszy w poszczególnych tabelach:
376SELECT * FROM nazwa_tabeli_1, nazwa_tabeli_2;
377
378Jeśli w obu tabelach istnieje pole o takiej samej nazwie pobiera się je wskazując na tabelę z której pochodzi:
379SELECT nazwa_tabeli_1.nazwa_kolumny, nazwa_tabeli_2.nazwa_kolumny FROM nazwa_tabeli_1, nazwa_tabeli_2;
380
381//----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
382
383Tabala której ma dotyczyć klucz obcy:
384CREATE TABLE tabelaKraj
385{
386 id INT(5) NOT NULL AUTO_INCREMENT PRIMARY KEY,
387 nazwaKraju VARCHAR(50) NOT NULL
388};
389
390Utworzenie nowej tabeli z kluczem obcym:
391CREATE TABLE zawodnik
392{
393 id INT(5) NOT NULL AUTO_INCREMENT PRIMARY KEY,
394 idKraju INT(5),
395 FOREIGN KEY (idkraju) REFERENCES tabelaKraj(id)
396};
397
398Klucz obcy powoduje, że do tabeli "zawodnik" mogą zostać dodane tylko takie rekordy w których pole "idKraju" ma wartość która istnieje również w polu "id" w tabeli "tabelaKraj".
399Dzięki temu zawodnik nie będzie posiadał id kraju który nie istnieje.
400Wiąże się to także z tym że standardowo po dodaniu rekordu do tabeli "zawodnik" nie można usunąć powiązanego rekordu z tabeli "tabelaKraj".
401
402Nadanie klucza obcego dla istniejącej już tabeli:
403ALTER TABLE zawodnik ADD FOREIGN KEY (idKraju) REFERENCES tabelaKraj(id);
404
405
406Klucze obce możemy także jednocześnie nazywać.
407
408Utworzenie nowej tabeli z nazwanym kluczem obcym:
409CREATE TABLE zawodnik
410{
411 id INT(5) NOT NULL AUTO_INCREMENT PRIMARY KEY,
412 idKraju INT(5),
413 CONSTRAINT nazwa_klucza_obcego FOREIGN KEY (idkraju) REFERENCES tabelaKraj(id)
414};
415
416Nadanie nazwanego klucza obcego dla istniejącej już tabeli:
417ALTER TABLE zawodnik ADD CONSTRAINT nazwa_klucza_obcego FOREIGN KEY (idKraju) REFERENCES tabelaKraj(id);
418
419Usunięcie klucza obcego po nazwie:
420ALTER TABLE zawodnik DROP FOREIGN KEY nazwa_klucza_obcego;
421
422
423Jest możliwość ustalenia jak mają się zachowywać rekordy z kluczem obcym w chwili gdy będziemy chcieli usunąć(ON DELETE) lub edytować(ON UPDATE) powiązany rekord.
424 CASCADE – jeżeli obiekt, do którego klucz obcy się odnosi zostanie usunięty/zedytowany to samo stanie się z rekordem referującym (czyli – usunięty zostaje zespół, automatycznie usunięte zostają wszystkie powiązania do niego zawodników)
425 RESTRICT lub NO ACTION – jeżeli obiekt, do którego klucz obcy się odnosi zostanie usunięty/zedytowany, a dalej posiada on rekordy, które się do niego odnoszą to akcja zostanie anulowana (a więc nie będzie można usunąć zespołu, jeżeli ma on przypisanych zawodników)
426 SET NULL - jeżeli obiekt, do którego klucz obcy się odnosi zostanie usunięty/zedytowany, a dalej posiada on rekordy, które się do niego odnoszą to kluczom obcym zostaną przypisane wartości puste (NULL)
427 SET DEFAULT - jeżeli obiekt, do którego klucz obcy się odnosi zostanie usunięty/zedytowany, a dalej posiada on rekordy, które się do niego odnoszą to kluczom obcym zostaną przypisane wartości domyślne dla tego pola
428
429ALTER TABLE zawodnik ADD FOREIGN KEY(idKraju) REFERENCES tabelaKraj(id) ON DELETE CASCADE;
430
431ALTER TABLE zawodnik ADD FOREIGN KEY(idKraju) REFERENCES tabelaKraj(id) ON UPDATE RESTRICT;
432
433ALTER TABLE zawodnik ADD FOREIGN KEY(idKraju) REFERENCES tabelaKraj(id) ON DELETE CASCADE ON UPDATE RESTRICT;