Mysql
 sql >> база данни >  >> RDS >> Mysql

SQL заявката връща данни от множество таблици

Част 1 – Обединения и съюзи

Този отговор обхваща:

  1. Част 1
  2. Част 2
    • Подзаявки – какво представляват, къде могат да се използват и за какво да внимавате
    • Картезиан се присъединява към AKA – О, мизерията!

Има няколко начина за извличане на данни от множество таблици в база данни. В този отговор ще използвам синтаксис за присъединяване ANSI-92. Това може да е различно от редица други уроци, които използват по-стария синтаксис ANSI-89 (и ако сте свикнали с 89, може да изглежда много по-малко интуитивен - но всичко, което мога да кажа, е да го опитате), тъй като е много по-лесно за разбиране, когато заявките започнат да стават по-сложни. Защо да го използвате? Има ли повишаване на производителността? Краткият отговор е не, но е по-лесно за четене, след като свикнете. По-лесно е да се четат заявки, написани от други хора, използвайки този синтаксис.

Също така ще използвам концепцията за малка каросерия, която има база данни, за да следя какви коли има на разположение. Собственикът ви е наел като свой компютърен специалист по ИТ и очаква да можете да му изпратите данните, които той иска, веднага.

Направих няколко справочни таблици, които ще бъдат използвани от финалната маса. Това ще ни даде разумен модел, от който да работим. За да започна, ще изпълнявам заявките си към примерна база данни, която има следната структура. Ще се опитам да помисля за често срещаните грешки, които се допускат при стартиране, и ще обясня какво се обърка с тях - както и разбира се да покажа как да ги коригирам.

Първата таблица е просто списък с цветове, за да знаем какви цветове имаме в автомобилния двор.

mysql> create table colors(id int(3) not null auto_increment primary key, 
    -> color varchar(15), paint varchar(10));
Query OK, 0 rows affected (0.01 sec)

mysql> show columns from colors;
+-------+-------------+------+-----+---------+----------------+
| Field | Type        | Null | Key | Default | Extra          |
+-------+-------------+------+-----+---------+----------------+
| id    | int(3)      | NO   | PRI | NULL    | auto_increment |
| color | varchar(15) | YES  |     | NULL    |                |
| paint | varchar(10) | YES  |     | NULL    |                |
+-------+-------------+------+-----+---------+----------------+
3 rows in set (0.01 sec)

mysql> insert into colors (color, paint) values ('Red', 'Metallic'), 
    -> ('Green', 'Gloss'), ('Blue', 'Metallic'), 
    -> ('White' 'Gloss'), ('Black' 'Gloss');
Query OK, 5 rows affected (0.00 sec)
Records: 5  Duplicates: 0  Warnings: 0

mysql> select * from colors;
+----+-------+----------+
| id | color | paint    |
+----+-------+----------+
|  1 | Red   | Metallic |
|  2 | Green | Gloss    |
|  3 | Blue  | Metallic |
|  4 | White | Gloss    |
|  5 | Black | Gloss    |
+----+-------+----------+
5 rows in set (0.00 sec)

Таблицата с марките идентифицира различните марки на колите, които разградницата може да продаде.

mysql> create table brands (id int(3) not null auto_increment primary key, 
    -> brand varchar(15));
Query OK, 0 rows affected (0.01 sec)

mysql> show columns from brands;
+-------+-------------+------+-----+---------+----------------+
| Field | Type        | Null | Key | Default | Extra          |
+-------+-------------+------+-----+---------+----------------+
| id    | int(3)      | NO   | PRI | NULL    | auto_increment |
| brand | varchar(15) | YES  |     | NULL    |                |
+-------+-------------+------+-----+---------+----------------+
2 rows in set (0.01 sec)

mysql> insert into brands (brand) values ('Ford'), ('Toyota'), 
    -> ('Nissan'), ('Smart'), ('BMW');
Query OK, 5 rows affected (0.00 sec)
Records: 5  Duplicates: 0  Warnings: 0

mysql> select * from brands;
+----+--------+
| id | brand  |
+----+--------+
|  1 | Ford   |
|  2 | Toyota |
|  3 | Nissan |
|  4 | Smart  |
|  5 | BMW    |
+----+--------+
5 rows in set (0.00 sec)

Таблицата с модели ще обхваща различни типове автомобили, за това ще бъде по-лесно да се използват различни типове автомобили, а не действителни модели автомобили.

mysql> create table models (id int(3) not null auto_increment primary key, 
    -> model varchar(15));
Query OK, 0 rows affected (0.01 sec)

mysql> show columns from models;
+-------+-------------+------+-----+---------+----------------+
| Field | Type        | Null | Key | Default | Extra          |
+-------+-------------+------+-----+---------+----------------+
| id    | int(3)      | NO   | PRI | NULL    | auto_increment |
| model | varchar(15) | YES  |     | NULL    |                |
+-------+-------------+------+-----+---------+----------------+
2 rows in set (0.00 sec)

mysql> insert into models (model) values ('Sports'), ('Sedan'), ('4WD'), ('Luxury');
Query OK, 4 rows affected (0.00 sec)
Records: 4  Duplicates: 0  Warnings: 0

mysql> select * from models;
+----+--------+
| id | model  |
+----+--------+
|  1 | Sports |
|  2 | Sedan  |
|  3 | 4WD    |
|  4 | Luxury |
+----+--------+
4 rows in set (0.00 sec)

И накрая, да вържем всички тези други маси, масата, която свързва всичко заедно. Полето за ID всъщност е уникалният номер на партидата, използван за идентифициране на автомобили.

mysql> create table cars (id int(3) not null auto_increment primary key, 
    -> color int(3), brand int(3), model int(3));
Query OK, 0 rows affected (0.01 sec)

mysql> show columns from cars;
+-------+--------+------+-----+---------+----------------+
| Field | Type   | Null | Key | Default | Extra          |
+-------+--------+------+-----+---------+----------------+
| id    | int(3) | NO   | PRI | NULL    | auto_increment |
| color | int(3) | YES  |     | NULL    |                |
| brand | int(3) | YES  |     | NULL    |                |
| model | int(3) | YES  |     | NULL    |                |
+-------+--------+------+-----+---------+----------------+
4 rows in set (0.00 sec)

mysql> insert into cars (color, brand, model) values (1,2,1), (3,1,2), (5,3,1), 
    -> (4,4,2), (2,2,3), (3,5,4), (4,1,3), (2,2,1), (5,2,3), (4,5,1);
Query OK, 10 rows affected (0.00 sec)
Records: 10  Duplicates: 0  Warnings: 0

mysql> select * from cars;
+----+-------+-------+-------+
| id | color | brand | model |
+----+-------+-------+-------+
|  1 |     1 |     2 |     1 |
|  2 |     3 |     1 |     2 |
|  3 |     5 |     3 |     1 |
|  4 |     4 |     4 |     2 |
|  5 |     2 |     2 |     3 |
|  6 |     3 |     5 |     4 |
|  7 |     4 |     1 |     3 |
|  8 |     2 |     2 |     1 |
|  9 |     5 |     2 |     3 |
| 10 |     4 |     5 |     1 |
+----+-------+-------+-------+
10 rows in set (0.00 sec)

Това ще ни даде достатъчно данни (надявам се), за да покрием примерите по-долу за различни типове обединения и също така ще даде достатъчно данни, за да ги направим полезни.

Така че навлизайки в същността на нещата, шефът иска да знае идентификационните номера на всички спортни коли, които има .

Това е просто свързване на две таблици. Имаме таблица, която идентифицира модела и таблицата с наличния запас в нея. Както можете да видите, данните в model колона на cars таблицата се отнася до models колона от cars маса, която имаме. Сега знаем, че таблицата с модели има ID от 1 за Sports така че нека напишем присъединяването.

select
    ID,
    model
from
    cars
        join models
            on model=ID

Така че тази заявка изглежда добре, нали? Идентифицирахме двете таблици и съдържаме информацията, от която се нуждаем, и използваме обединяване, което идентифицира правилно кои колони да се присъединим.

ERROR 1052 (23000): Column 'ID' in field list is ambiguous

О, не! Грешка в първата ни заявка! Да, и това е слива. Виждате ли, заявката наистина е получила правилните колони, но някои от тях съществуват и в двете таблици, така че базата данни се обърква каква действителна колона имаме предвид и къде. Има две решения за решаване на това. Първият е приятен и прост, можем да използваме tableName.columnName за да кажем на базата данни какво точно имаме предвид, така:

select
    cars.ID,
    models.model
from
    cars
        join models
            on cars.model=models.ID

+----+--------+
| ID | model  |
+----+--------+
|  1 | Sports |
|  3 | Sports |
|  8 | Sports |
| 10 | Sports |
|  2 | Sedan  |
|  4 | Sedan  |
|  5 | 4WD    |
|  7 | 4WD    |
|  9 | 4WD    |
|  6 | Luxury |
+----+--------+
10 rows in set (0.00 sec)

Другият вероятно се използва по-често и се нарича псевдоним на таблица. Таблиците в този пример имат хубави и кратки прости имена, но изписват нещо като KPI_DAILY_SALES_BY_DEPARTMENT вероятно ще остарее бързо, така че един прост начин е да назовете таблицата по следния начин:

select
    a.ID,
    b.model
from
    cars a
        join models b
            on a.model=b.ID

Сега да се върнем към искането. Както можете да видите, имаме необходимата информация, но също така имаме информация, която не е поискана, така че трябва да включим клауза Къде в изявлението, за да получим само спортните автомобили, както беше поискано. Тъй като предпочитам метода за псевдоним на таблица, вместо да използвам имената на таблицата отново и отново, ще се придържам към него от този момент нататък.

Ясно е, че трябва да добавим клауза where към нашата заявка. Можем да идентифицираме спортните автомобили по ID=1 или model='Sports' . Тъй като идентификационният номер е индексиран и първичният ключ (и се случва да не пише по-малко), нека го използваме в нашата заявка.

select
    a.ID,
    b.model
from
    cars a
        join models b
            on a.model=b.ID
where
    b.ID=1

+----+--------+
| ID | model  |
+----+--------+
|  1 | Sports |
|  3 | Sports |
|  8 | Sports |
| 10 | Sports |
+----+--------+
4 rows in set (0.00 sec)

Бинго! Шефът е доволен. Разбира се, тъй като е шеф и никога не е доволен от това, което е поискал, той разглежда информацията, след което казва Искам и цветовете .

Добре, значи имаме вече написана голяма част от нашата заявка, но трябва да използваме трета таблица, която е цветове. Сега, нашата основна информационна таблица cars съхранява идентификатора на цвета на автомобила и това се свързва обратно към колоната за идентификация на цветовете. Така че, по подобен начин на оригинала, можем да се присъединим към трета таблица:

select
    a.ID,
    b.model
from
    cars a
        join models b
            on a.model=b.ID
        join colors c
            on a.color=c.ID
where
    b.ID=1

+----+--------+
| ID | model  |
+----+--------+
|  1 | Sports |
|  3 | Sports |
|  8 | Sports |
| 10 | Sports |
+----+--------+
4 rows in set (0.00 sec)

По дяволите, въпреки че таблицата беше правилно присъединена и свързаните колони бяха свързани, забравихме да изтеглим действителната информация от новата таблица, която току-що свързахме.

select
    a.ID,
    b.model,
    c.color
from
    cars a
        join models b
            on a.model=b.ID
        join colors c
            on a.color=c.ID
where
    b.ID=1

+----+--------+-------+
| ID | model  | color |
+----+--------+-------+
|  1 | Sports | Red   |
|  8 | Sports | Green |
| 10 | Sports | White |
|  3 | Sports | Black |
+----+--------+-------+
4 rows in set (0.00 sec)

Да, това е шефът на гърба ни за момент. Сега, за да обясня някои от това малко по-подробно. Както можете да видите, from клауза в нашето изявление свързва основната ни таблица (често използвам таблица, която съдържа информация, а не таблица за справка или размери. Заявката би работила също толкова добре с всички таблици, които се превключват, но има по-малко смисъл, когато се върнем към тази заявка да го прочетете след няколко месеца, така че често е най-добре да се опитате да напишете заявка, която ще бъде хубава и лесна за разбиране - изложете я интуитивно, използвайте хубав отстъп, така че всичко да е възможно най-ясно. Ако продължете да учите другите, опитайте се да внушите тези характеристики в техните заявки – особено ако ще ги отстранявате.

Напълно възможно е да продължите да свързвате все повече и повече таблици по този начин.

select
    a.ID,
    b.model,
    c.color
from
    cars a
        join models b
            on a.model=b.ID
        join colors c
            on a.color=c.ID
        join brands d
            on a.brand=d.ID
where
    b.ID=1

Въпреки че забравих да включа таблица, където може да искаме да обединим повече от една колона в join изявление, ето един пример. Ако models таблицата имаше специфични за марката модели и следователно имаше и колона, наречена brand който е свързан обратно към brands таблица на ID поле, може да се направи по следния начин:

select
    a.ID,
    b.model,
    c.color
from
    cars a
        join models b
            on a.model=b.ID
        join colors c
            on a.color=c.ID
        join brands d
            on a.brand=d.ID
            and b.brand=d.ID
where
    b.ID=1

Можете да видите, заявката по-горе не само свързва обединените таблици с основните cars таблица, но също така посочва връзки между вече присъединените таблици. Ако това не е направено, резултатът се нарича декартово присъединяване - което е dba говори за лошо. Декартово присъединяване е това, при което се връщат редове, тъй като информацията не казва на базата данни как да ограничи резултатите, така че заявката връща всички редовете, които отговарят на критериите.

И така, за да дадем пример за декартово присъединяване, нека изпълним следната заявка:

select
    a.ID,
    b.model
from
    cars a
        join models b

+----+--------+
| ID | model  |
+----+--------+
|  1 | Sports |
|  1 | Sedan  |
|  1 | 4WD    |
|  1 | Luxury |
|  2 | Sports |
|  2 | Sedan  |
|  2 | 4WD    |
|  2 | Luxury |
|  3 | Sports |
|  3 | Sedan  |
|  3 | 4WD    |
|  3 | Luxury |
|  4 | Sports |
|  4 | Sedan  |
|  4 | 4WD    |
|  4 | Luxury |
|  5 | Sports |
|  5 | Sedan  |
|  5 | 4WD    |
|  5 | Luxury |
|  6 | Sports |
|  6 | Sedan  |
|  6 | 4WD    |
|  6 | Luxury |
|  7 | Sports |
|  7 | Sedan  |
|  7 | 4WD    |
|  7 | Luxury |
|  8 | Sports |
|  8 | Sedan  |
|  8 | 4WD    |
|  8 | Luxury |
|  9 | Sports |
|  9 | Sedan  |
|  9 | 4WD    |
|  9 | Luxury |
| 10 | Sports |
| 10 | Sedan  |
| 10 | 4WD    |
| 10 | Luxury |
+----+--------+
40 rows in set (0.00 sec)

Господи, това е грозно. Но що се отнася до базата данни, това е точно каквото беше поискано. В заявката поискахме ID от cars и model от models . Тъй като обаче не посочихме как за да се присъедини към таблиците, базата данни съответства на всеки ред от първата таблица с всеки ред от втората таблица.

Добре, значи шефът се върна и отново иска повече информация. Искам същия списък, но също така включвам 4WD в него .

Това обаче ни дава чудесно извинение да разгледаме два различни начина да постигнем това. Бихме могли да добавим друго условие към клаузата where, както следва:

select
    a.ID,
    b.model,
    c.color
from
    cars a
        join models b
            on a.model=b.ID
        join colors c
            on a.color=c.ID
        join brands d
            on a.brand=d.ID
where
    b.ID=1
    or b.ID=3

Въпреки че горното ще работи перфектно, нека го погледнем по различен начин, това е чудесно извинение да покажем как union заявката ще работи.

Знаем, че следното ще върне всички спортни коли:

select
    a.ID,
    b.model,
    c.color
from
    cars a
        join models b
            on a.model=b.ID
        join colors c
            on a.color=c.ID
        join brands d
            on a.brand=d.ID
where
    b.ID=1

И следното ще върне всички 4WD:

select
    a.ID,
    b.model,
    c.color
from
    cars a
        join models b
            on a.model=b.ID
        join colors c
            on a.color=c.ID
        join brands d
            on a.brand=d.ID
where
    b.ID=3

Така че чрез добавяне на union all клауза между тях, резултатите от втората заявка ще бъдат добавени към резултатите от първата заявка.

select
    a.ID,
    b.model,
    c.color
from
    cars a
        join models b
            on a.model=b.ID
        join colors c
            on a.color=c.ID
        join brands d
            on a.brand=d.ID
where
    b.ID=1
union all
select
    a.ID,
    b.model,
    c.color
from
    cars a
        join models b
            on a.model=b.ID
        join colors c
            on a.color=c.ID
        join brands d
            on a.brand=d.ID
where
    b.ID=3

+----+--------+-------+
| ID | model  | color |
+----+--------+-------+
|  1 | Sports | Red   |
|  8 | Sports | Green |
| 10 | Sports | White |
|  3 | Sports | Black |
|  5 | 4WD    | Green |
|  7 | 4WD    | White |
|  9 | 4WD    | Black |
+----+--------+-------+
7 rows in set (0.00 sec)

Както можете да видите, резултатите от първата заявка се връщат първи, последвани от резултатите от втората заявка.

В този пример, разбира се, би било много по-лесно просто да използвате първата заявка, но union запитванията могат да бъдат чудесни за конкретни случаи. Те са чудесен начин за връщане на конкретни резултати от таблици от таблици, които не се свързват лесно - или в този смисъл напълно несвързани таблици. Има обаче няколко правила, които трябва да се спазват.

  • Типовете колони от първата заявка трябва да съвпадат с типовете колони от всяка друга заявка по-долу.
  • Имената на колоните от първата заявка ще бъдат използвани за идентифициране на целия набор от резултати.
  • Броят на колоните във всяка заявка трябва да е еднакъв.

Сега може би се чудите какво на разликата е между използването на union и union all . union заявката ще премахне дубликатите, докато union all няма да. Това означава, че има малък спад в производителността при използване на union над union all но резултатите може да си заслужават - няма да спекулирам с подобни неща в това.

В тази връзка може би си струва да отбележите някои допълнителни бележки тук.

  • Ако искаме да подредим резултатите, можем да използваме order by но вече не можете да използвате псевдонима. В заявката по-горе, добавяне на order by a.ID би довело до грешка - що се отнася до резултатите, колоната се нарича ID вместо a.ID - въпреки че един и същ псевдоним е използван и в двете заявки.
  • Можем да имаме само една order by изявление и то трябва да бъде като последното изявление.

За следващите примери добавям няколко допълнителни реда към нашите таблици.

Добавих Holden към таблицата с марките. Добавих и ред в cars който има color стойност на 12 - която няма препратка в таблицата с цветове.

Добре, шефът се върна отново, лае молби - *Искам бройка на всяка марка, която носим и броя на колите в нея!` - Типично, стигаме до интересна част от нашата дискусия и шефът иска повече работа .

Добре, така че първото нещо, което трябва да направим, е да получим пълен списък на възможните марки.

select
    a.brand
from
    brands a

+--------+
| brand  |
+--------+
| Ford   |
| Toyota |
| Nissan |
| Smart  |
| BMW    |
| Holden |
+--------+
6 rows in set (0.00 sec)

Сега, когато присъединим това към нашата таблица с автомобили, получаваме следния резултат:

select
    a.brand
from
    brands a
        join cars b
            on a.ID=b.brand
group by
    a.brand

+--------+
| brand  |
+--------+
| BMW    |
| Ford   |
| Nissan |
| Smart  |
| Toyota |
+--------+
5 rows in set (0.00 sec)

Което, разбира се, е проблем - не виждаме никакво споменаване на прекрасния Holden марка, която добавих.

Това е така, защото обединението търси съвпадащи редове в и двете маси. Тъй като в автомобилите няма данни, които са от тип Holden не се връща. Тук можем да използваме outer присъединяване. Това ще върне всички резултатите от една таблица, независимо дали съвпадат в другата таблица или не:

select
    a.brand
from
    brands a
        left outer join cars b
            on a.ID=b.brand
group by
    a.brand

+--------+
| brand  |
+--------+
| BMW    |
| Ford   |
| Holden |
| Nissan |
| Smart  |
| Toyota |
+--------+
6 rows in set (0.00 sec)

Сега, когато имаме това, можем да добавим прекрасна агрегатна функция, за да получим броене и да премахнем шефа за момент.

select
    a.brand,
    count(b.id) as countOfBrand
from
    brands a
        left outer join cars b
            on a.ID=b.brand
group by
    a.brand

+--------+--------------+
| brand  | countOfBrand |
+--------+--------------+
| BMW    |            2 |
| Ford   |            2 |
| Holden |            0 |
| Nissan |            1 |
| Smart  |            1 |
| Toyota |            5 |
+--------+--------------+
6 rows in set (0.00 sec)

И с това, шефът се крие.

Сега, за да обясня това по-подробно, външните съединения могат да бъдат от left или right Тип. Лявото или дясното определя коя таблица е напълно включени. left outer join ще включва всички редове от таблицата вляво, докато (се досещате) right outer join пренася всички резултати от таблицата вдясно в резултатите.

Някои бази данни позволяват full outer join което ще върне резултати (независимо дали съвпадащи или не) от и двете таблици, но това не се поддържа във всички бази данни.

Вероятно смятам, че в този момент се чудите дали можете или не да обедините типове присъединяване в заявка - и отговорът е да, абсолютно можете.

select
    b.brand,
    c.color,
    count(a.id) as countOfBrand
from
    cars a
        right outer join brands b
            on b.ID=a.brand
        join colors c
            on a.color=c.ID
group by
    a.brand,
    c.color

+--------+-------+--------------+
| brand  | color | countOfBrand |
+--------+-------+--------------+
| Ford   | Blue  |            1 |
| Ford   | White |            1 |
| Toyota | Black |            1 |
| Toyota | Green |            2 |
| Toyota | Red   |            1 |
| Nissan | Black |            1 |
| Smart  | White |            1 |
| BMW    | Blue  |            1 |
| BMW    | White |            1 |
+--------+-------+--------------+
9 rows in set (0.00 sec)

И така, защо това не е очакваните резултати? Това е така, защото въпреки че сме избрали външното обединяване от автомобили към марки, то не е посочено в свързването с цветове - така че конкретното обединяване ще върне само резултати, които съвпадат и в двете таблици.

Ето заявката, която би работила, за да получи резултатите, които очаквахме:

select
    a.brand,
    c.color,
    count(b.id) as countOfBrand
from
    brands a
        left outer join cars b
            on a.ID=b.brand
        left outer join colors c
            on b.color=c.ID
group by
    a.brand,
    c.color

+--------+-------+--------------+
| brand  | color | countOfBrand |
+--------+-------+--------------+
| BMW    | Blue  |            1 |
| BMW    | White |            1 |
| Ford   | Blue  |            1 |
| Ford   | White |            1 |
| Holden | NULL  |            0 |
| Nissan | Black |            1 |
| Smart  | White |            1 |
| Toyota | NULL  |            1 |
| Toyota | Black |            1 |
| Toyota | Green |            2 |
| Toyota | Red   |            1 |
+--------+-------+--------------+
11 rows in set (0.00 sec)

Както виждаме, имаме две външни обединявания в заявката и резултатите идват според очакванията.

Сега, какво ще кажете за другите видове присъединявания, които питате? Ами кръстовища?

Е, не всички бази данни поддържат intersection но почти всички бази данни ще ви позволят да създадете пресечна точка чрез присъединяване (или поне добре структуриран оператор where).

Пресечната точка е вид присъединяване, донякъде подобно на union както е описано по-горе - но разликата е, че само връща редове с данни, които са идентични (и имам предвид идентични) между различните отделни заявки, присъединени от съюза. Ще бъдат върнати само редове, които са идентични във всяко отношение.

Един прост пример би бил такъв:

select
    *
from
    colors
where
    ID>2
intersect
select
    *
from
    colors
where
    id<4

Докато нормално union query ще върне всички редове на таблицата (първата заявка връща нещо над ID>2 и второто нещо, което има ID<4 ), което би довело до пълен набор, заявка за пресичане ще върне само реда, съответстващ на id=3 тъй като отговаря и на двата критерия.

Сега, ако вашата база данни не поддържа intersect заявка, горното може лесно да бъде постигнато със следната заявка:

select
    a.ID,
    a.color,
    a.paint
from
    colors a
        join colors b
            on a.ID=b.ID
where
    a.ID>2
    and b.ID<4

+----+-------+----------+
| ID | color | paint    |
+----+-------+----------+
|  3 | Blue  | Metallic |
+----+-------+----------+
1 row in set (0.00 sec)

Ако искате да извършите пресичане в две различни таблици, използвайки база данни, която по същество не поддържа заявка за пресичане, ще трябва да създадете присъединяване на всяка колона от таблиците.



  1. Database
    2.   
  2. Mysql
    3.   
  3. Oracle
    4.   
  4. Sqlserver
    5.   
  5. PostgreSQL
    6.   
  6. Access
    7.   
  7. SQLite
    8.   
  8. MariaDB

  1. Достъпът е отказан за потребител 'root'@'localhost' при опит за предоставяне на привилегии. Как да дам привилегии?

  2. Как да търсите точно съвпадаща дума с MySql Query

  3. MySQL - Използване на COUNT(*) в клаузата WHERE

  4. MySQL заявка низ съдържа

  5. Избор на float в MySQL