UTILIZAREA SERVER-ULUI MYSQL

1. Conectarea la server
2. Crearea utilizatorilor. Privilegiile utilizatorilor
3. Crearea bazelor de date si a tabelelor
4. Tipuri de campuri
5. Inserarea de inregistrari
6. Actualizarea inregistrarilor
7. Extragerea inregistrarilor cu SELECT
8. Join-uri intre tabele
9. Stergerea inregistrarilor si a tabelelor
10.Crearea indecsilor
11. Modificarea tabelelor

1. CONECTAREA SI DECONECTAREA DE LA SERVER

Primul lucru pe care trebuie sa-l observati este ca fiecare comanda
data server-ului se termina cu ';'. Fara acest terminator nu se va intampla
nimic. Asta inseamna ca puteti avea linii noi in mijlocul unei comenzi sau
puteti da mai multe comenzi pe aceeasi linie:
1. mysql> SELECT VERSION(); SELECT NOW();
2. mysql> SELECT
-> USER()
-> ,
-> CURRENT_DATE;
3. mysql> grant select
->

Acest ultim prompt insemna ca MySQL mai asteapta sa fie introdus ceva
(asteapta ';').
Alta caracteristica de notat este ca declaratiile SQL (Structured Query
Language - un limbaj de interogare a bazelor de date) nu sunt case
sensitive
Daca vreti sa nu mai executati o comanda pe care ati scris-o partial, o
puteti anula cu '\c':
mysql> SELECT
-> USER()
-> \c
mysql>
Ce insemna prompt-urile
mysql> Gata pentru o noua comanda.
-> Asteapta urmatoarea linie dintr-o comanda. multi-linie.
'> Astepta continuarea unui sir de caractere care incepe cu '.

1|Page
"> Astepta continuarea unui sir de caractere care incepe cu ".
Este important de stiut ce inseamna prompt-urile '> and "> , deoarece
daca din greseala introduceti un sir neterminat, orice altceva ce veti tasta
(chiar si quit) nu va fi luat in seama.
Pentru a va conecta la server, de obicei sunteti nevoiti sa dati numele de
utilizator si parola:
shell> mysql -h host -u user -p
Enter password: ********

Comanda mysql invoca programul-monitor MySQL, un program client care

va conecteaza la server.
-h specifica numele gazdei (host) la care va ve-ti conecta (doar daca va
conectati pe alta statie de lucru).
-u specifica numele tau de utilizator ('root' daca aveti MySQL pe propria
statie, sau alt nume dat de administrator..).
-p spune server-ului ca va veti conecta folosind o parola.
shell> mysql -h host -u user -p
Enter password: ********
mysql>

In cazul nostru la instalare

host =’localhost’
user =’root’
C:\> mysql -h localhost -u root -p
Enter password: ********

2|Page
In functie de cum ati instalat si configurat MySQL, ati putea fi lasat sa va
conectezi la server fara nume de utilizator sau parola:
shell> mysql
Dupa ce va-ti conectat cu succes la server va puteti deconecta cu
comanda QUIT sau apasand CTRL+D
mysql> QUIT

2. CREAREA UTILIZATORILOR

SISTEMUL DE PRIVILEGII AL MYSQL

Una dinte cele mai bune caracteristici ale MySQL este ca suporta un sistem
de privilegii (dreptul de a face o anumita actiune asupra unui obiect)
pentru utilizatori foarte sofisticati. Cand veti crea un utilizator, ii veti da
acces la un set de privilegii pentru a specifica ce anume poate sa faca si ce
nu poate sa faca un utilizator. Un utilizator ar trebui sa aiba cel mai mic
nivel de privilegii necesar pentru a-si indeplini sarcina.
Crearea drepturilor pentru utilizatori se face cu comanda GRANT, iar
retragerea drepturilor cu REVOKE
Pentru a crea un administrator:
mysql> grant all
-> on *
-> to fred identified by ‘mnb123’
-> with grant option;

Pentru a-i retrag drepturile acestui utilizator:

mysql> revoke all
-> on *
-> from fred;

Exemplu de acordare drepturi pentru un utilizator:

mysql> grant select, insert, update, delete, index, alter,
create, drop
-> on carti.*
-> to alina;

3. CREAREA BAZELOR DE DATE SI A TABELELOR

Vom crea o baza de date angajati pe care o vom folosi si in alte ocazii:
Pe Windows:
create database angajati;

3|Page
 Sa vedem cate baze de date sunt in sistem:
show databases;
+----------------+
| Database |
+----------------+
| angajati |
| mysql |
| test |
+----------------+
3 rows in set (0.00 sec)
DESCHIDEREA UNEI BAZE DE DATE SE POATE FACE CU UNA DIN
METODELE:

 Cu comanda USE:
 mysql>USE angajati;

Daca nu specificam o baza de date cand lucram cu MySQL, se va genera

o eroare!
Pentru baza noastra de date vom avea o tabela cu detalii despre angajati
si o tabela cu date personale. Dupa ce ati selectat baza de date
angajati selectati urmatoarea comanda:
mysql> CREATE TABLE angajati_data
-> (
-> emp_id int not null auto_increment primary key,
-> f_name varchar(20),
-> l_name varchar(20),
-> title varchar(30),
-> age int,
-> yos int,
-> salary int,
-> perks int,
-> email varchar(60)
-> );
Query OK, 0 rows affected (0.01 sec)
CREATE TABLE e urmata de numele tabelei si apoi de numele si tipul de
date al campurilor din baza de date. 'varchar' inseamna caractere de
lungime variabile. Numarul din paranteza este lungimea maxima de
caractere admise.'not null' specifica ca nu avem voie sa avem valori nule
pe acel camp in inregistrari. 'int' inseamna numar inreg, iar 'unsigned'
numar pozitiv. 'auto_increment' specifica pentru MySQL sa atribuie o
valoare automat la o noua adaugare de inregistrare cu o valoare mai
mare cu 1 decat cea mai mare valoare din acel camp (necesar pentru un

4|Page
camp ID). 'primary key' specifica ca acel camp va fi indexat (fiecare
valoare va fi unicat).
4. TIPURI DE CAMPURI
Cele trei tipuri de baza pentru campuri sunt: numeric, data si timp si
sir de caractere(string). Cand alegeti un anumit tip sau subtip, puteti
specifica si lungimea maxima admisa (M, maxim 255).
Tipurile de date numerice
Pentru numerele in virgula flotanta (float), puteti specifica cu D numarul
de cifre dupa puctul zecimal. Pentru numerele intregi puteti sa specifici
daca vor fi doar pozitive cu 'unsigned'.
Tipuri de date intregi
Tip Interval (Bytes) Descriere
TINYINT[(M)] -127..128 1 Foarte mic integers
or 0..255
SMALLINT[(M)] -32768..32767 2 Intregi mici
or 0..65535
MEDIUMINT[(M)] -8388608.. 3 Marime medie
8388607
or 0..16777215
INT[(M)] -231..231-1 4 Intregi normali
or 0..232-1
INTEGER[(M)] Sinonim cu INT
BIGINT[(M)] -263..263-1 8 Intregi mari
or 0..264-1

Tipuri de date flotante

Tip Interval (Bytes) Descriere
FLOAT(precision) depinde Precizie simpla sau
precizie dubla
FLOAT[(M,D)] ±1.175494351E-38 4 Precizie simpla
±3.402823466E+38
DOUBLE[(M,D)] ±1.7976931348623157E 8 Precizie dubla
+308
±2.2250738585072014E
-308
DOUBLE PRECISION[(M,D)] la fel

REAL[(M,D)] la fel

DECIMAL[(M[,D])] variaza M+2 Float stocat ca

char.

NUMERIC[(M,D)] la fel Sinonim cu DECIMAL.

Tipurile pentru data si timp

Tip Interval Descriere
DATE 1000-01-01 O data(YYYY-MM-DD).
9999-12-31

5|Page
TIME -838:59:59 Un time(HH:MM:SS).
838:59:59
DATETIME 1000-01-01 Data si timp(YYYY-MM-DDHH:MM:SS).
00:00:00
9999-12-31
23:59:59
TIMESTAMP 1970-01-01 Un timestamp, folosit in tranzactii.
[(M)] 00:00:00
YEAR[(2|4)] 70–69 Un an in format cu 2 sau 4 cifre You can
specify 2 or 4 digit format.
1901–2155

TIMESTAMP-uri
Type Specified Display
TIMESTAMP YYYYMMDDHHMMSS
TIMESTAMP(14) YYYYMMDDHHMMSS
TIMESTAMP(12) YYMMDDHHMMSS
TIMESTAMP(10) YYMMDDHHMM
TIMESTAMP(8) YYYYMMDD
TIMESTAMP(6) YYMMDD
TIMESTAMP(4) YYMM
TIMESTAMP(2) YY

Tipuri pentru siruri de caractere

Se impart in trei grupuri:siruri normale:
1. CHAR (fixed length character) si
2. VARCHAR (variable length character),
3. siruri TEXT si
4. BLOB pentru siruri lungi/date binare si sirurile
5. SET si
6. ENUM (valori predefinte).
Tipuri pentru siruri de caractere regulare
Tip Interval
[NATIONAL] 1 to 255
CHAR(M) [BINARY]
[NATIONAL] 1 to 255
VARCHAR(M)
[BINARY]
Tipuri TEXT si BLOB
Lungime maxima
Tip (Caractere)
TINYBLOB 28-1
(255)
TINYTEXT 28-1
BLOB 216-1
(65.535)
6|Page
TEXT 216-1
MEDIUMBLOB 224-1
(16.777.215)
MEDIUMTEXT 224-1
LONGBLOB 232-1
(4.294.967.295)
LONGTEXT 232-1
Tipuri SET si ENUM
Tip Nr. valori in set Descriere
ENUM(‘valoare1’, 65535 O singura valoare din lista sau NULL
‘valoare2’,...)
SET(‘valoare1’, 64 Un set dintre valorile din lista.
‘valoare2’,...)

Exemplu:
create table _tabela1 (
id int auto_increment primary key,
answer enum (‘da’, ‘nu’) default ‘nu’);
Tipul de camp NULL
Pentru a face o valoare dintr-un camp NULL, nu includeti acel camp in
declaratia INSERT. Campurile au ca valoare implicita NULL daca nu
specifici 'NOT NULL'. Pentru compararea valorilor cu NULL se folosesc 'IS
NULL' sau 'IS NOT NULL'.

Descrierea tablelelor
Permite afisarea detaliilor despre campurile tabelei.

mysql> DESCRIBE angajati_data;

+--------+------------------+------+-----+---------+------+
| Field | Type | Null | Key | Default | Extra|
+--------+------------------+------+-----+---------+------|
| emp_id | int(10) unsigned | | PRI | 0 | |
| | auto_increment| | | | |
| f_name | varchar(20) | YES | | NULL | |
| l_name | varchar(20) | YES | | NULL | |
| title | varchar(30) | YES | | NULL | |
| age | int(11) | YES | | NULL | |
| yos | int(11) | YES | | NULL | |
| salary | int(11) | YES | | NULL | |
| perks | int(11) | YES | | NULL | |
| email | varchar(60) | YES | | NULL | |
+--------+------------------+------+-----+---------+------+
9 rows in set (0.00 sec)

5. INSERAREA INREGISTRARILOR IN TABELE

7|Page
 Comanda SQL, INSERT inseareaza informatii in tabele.
INSERT into nume_tabela (camp1, camp2....)
values (val1, val2...);

Exemplu:
mysql> INSERT INTO angajati_data
-> (f_name, l_name, title, age, yos, salary, perks, email)
-> values
-> ("Manish", "Sharma", "CEO", 28, 4, 200000,
-> 50000, "manish@bignet.com");
Query OK, 1 row affected (0.00 sec)

Daca vreti sa inserati unul dintre urmatoarele caractere intr-un camp de

tip text, trebui sa-i adaugati inainte un caracter backslash(\):
‘ (apostrof) :\'
“ (ghilimele):\"
\ (backslash) :\\
% (procent) :\%
_ (liniuta de subliniere) :\_

6. ACTUALIZAREA DATELOR DIN TABELE

Se face cu comanda SQL, UPDATE.

UPDATE nume_tabela SET
nume_camp1 = val1,
nume_camp2 = val2,
nume_camp3 = val3 ...
[WHERE conditii];

UPDATE angajati_data SET

salary = salary + 20000,
perks = perks + 5000
WHERE title='CEO';

Query OK, 1 row affected (0.01 sec)

Rows matched: 1 Changed: 1 Warnings: 0

7. EXTRAGEREA INFORMATIILOR DORITE DIN TABELA

Informatiile dorite sunt extrase din tabela (preocesul de interogare) cu

comanda SELECT
SELECT nume_campuri from nume_tabela [WHERE ...conditii];
De exemplu, pentru a extrage nume si prenumele tuturor angajatilor
(presupunand ca ati mai adaugat pe parcurs mai multe inregistrari cu
INSERT sau LOAD DATA INFILE):
mysql> SELECT f_name, l_name from angajati_data;
8|Page
+---------+------------+
| f_name | l_name |
+---------+------------+
| Manish | Sharma |
| John | Hagan |
| Ganesh | Pillai |
| Anamika | Pandit |
| Mary | Anchor |
| Fred | Kruger |
| John | MacFarland |
| Edward | Sakamuro |
| Alok | Nanda |
| Hassan | Rajabi |
| Paul | Simon |
| Arthur | Hoopla |
| Kim | Hunter |
| Roger | Lewis |
| Danny | Gibson |
| Mike | Harper |
| Monica | Sehgal |
| Hal | Simlai |
| Joseph | Irvine |
| Shahida | Ali |
| Peter | Champion |
+---------+------------+
21 rows in set (0.00 sec)
Pentru a afisa intreaga tabela, in loc sa specificam toate campurile vom
folosi simbolul '*':
SELECT * from angajati_data;
Selectia conditionala Puterea SGBD-ului sta in permiterea de a extrage
informatii dupa anumite conditii specificate
SELECT f_name, l_name from angajati_data where f_name = 'John';

+--------+------------+
| f_name | l_name |
+--------+------------+
| John | Hagan |
| John | MacFarland |
+--------+------------+
2 rows in set (0.00 sec)
Comparatiile MySQL sunt case insensitive ceea ca inseamna ca "john",
"John" sau "JoHn" ar merge in exemplul de mai sus.
Operatori de comparatie
Operator Nume Exemplu
= eqalitate customerid = 3
> mai mare amount>60.00

< mai mic amount<60.00

>= mai mic sau egal amount>=60.00
<= mai mic sau egal amount<=60.00
9|Page
!= sau<> diferit quantity != 0

IS NOT NULL valoare nenula

IS NULL valoare nula
BETWEEN interval de valori amount between 0 and 60.00
IN inclus intr-un set
predefinit city in (“Carlton”, “Moe”)
NOT IN neinclus intr-un
set predefinit city not in (“Carlton”,“Moe”)

LIKE cautare pattern name like (“Fred %”)

NOT LIKE cautare pattern
REGEXP expresie regular name regexp

Daca am vrea sa afisam angajatii al caror nume incepe cu 'J'?

select f_name, l_name from angajati_data where f_name LIKE "J
%";

+--------+------------+
| f_name | l_name |
+--------+------------+
| John | Hagan |
| John | MacFarland |
| Joseph | Irvine |
+--------+------------+
3 rows in set (0.00 sec)

Conditiile SQL pot contine si operatorii logici: AND, OR si NOT. Sa afisam

numele angajatilor care au numele incepand cu 'S' sau 'A':
SELECT l_name from angajati_data where
l_name like 'S%' OR l_name like 'A%';

+----------+
| l_name |
+----------+
| Sharma |
| Anchor |
| Sakamuro |
| Simon |
| Sehgal |
| Simlai |
| Ali |
+----------+
7 rows in set (0.00 sec)

Alte exemple:
SELECT f_name, l_name, title from
-> angajati_data where title
-> IN ('Web Designer', 'System Administrator');
10 | P a g e
+---------+--------+----------------------+
| f_name | l_name | title |
+---------+--------+----------------------+
| Anamika | Pandit | Web Designer |
| Mary | Anchor | Web Designer |
| Roger | Lewis | System Administrator |
| Danny | Gibson | System Administrator |
+---------+--------+----------------------+
4 rows in set (0.00 sec)

select f_name, l_name, age from

-> angajati_data where age BETWEEN
-> 32 AND 40;

+---------+------------+------+
| f_name | l_name | age |
+---------+------------+------+
| John | Hagan | 32 |
| Ganesh | Pillai | 32 |
| John | MacFarland | 34 |
| Alok | Nanda | 32 |
| Hassan | Rajabi | 33 |
| Arthur | Hoopla | 32 |
| Kim | Hunter | 32 |
| Roger | Lewis | 35 |
| Danny | Gibson | 34 |
| Mike | Harper | 36 |
| Shahida | Ali | 32 |
| Peter | Champion | 36 |
+---------+------------+------+
12 rows in set (0.00 sec)

select f_name, l_name, salary

-> from angajati_data where salary
-> NOT BETWEEN
-> 90000 AND 150000;

+---------+------------+--------+
| f_name | l_name | salary |
+---------+------------+--------+
| Manish | Sharma | 200000 |
| Mary | Anchor | 85000 |
| Fred | Kruger | 75000 |
| John | MacFarland | 80000 |
| Edward | Sakamuro | 75000 |
11 | P a g e
| Alok | Nanda | 70000 |
| Paul | Simon | 85000 |
| Arthur | Hoopla | 75000 |
| Hal | Simlai | 70000 |
| Joseph | Irvine | 72000 |
| Shahida | Ali | 70000 |
+---------+------------+--------+
11 rows in set (0.00 sec)
Sortarea datelor
Inregistrarile extrase anterior au fost afisate in rodinea in care erau
stocate in tabela. Pentru a le sorta folosim clauza ORDER BY a comenzii
SELECT.
SELECT l_name, f_name from
angajati_data ORDER BY l_name;

+------------+---------+
| l_name | f_name |
+------------+---------+
| Ali | Shahida |
| Anchor | Mary |
| Champion | Peter |
| Gibson | Danny |
| Hagan | John |
| Harper | Mike |
| Hoopla | Arthur |
| Hunter | Kim |
| Irvine | Joseph |
| Kruger | Fred |
| Lewis | Roger |
| MacFarland | John |
| Nanda | Alok |
| Pandit | Anamika |
| Pillai | Ganesh |
| Rajabi | Hassan |
| Sakamuro | Edward |
| Sehgal | Monica |
| Sharma | Manish |
| Simlai | Hal |
| Simon | Paul |
+------------+---------+
21 rows in set (0.00 sec)
sau (ordine descrerscatoare):
SELECT f_name from angajati_data
ORDER by f_name DESC;
Limitarea numarului de inregistrari extrase
12 | P a g e
SELECT f_name, l_name from
angajati_data LIMIT 5;

+---------+--------+
| f_name | l_name |
+---------+--------+
| Manish | Sharma |
| John | Hagan |
| Ganesh | Pillai |
| Anamika | Pandit |
| Mary | Anchor |
+---------+--------+
5 rows in set (0.01 sec)
Similar, putem lista cei mai tineri doi angajati:
SELECT f_name, l_name, age from
angajati_data ORDER BY age
LIMIT 2;

+--------+----------+------+
| f_name | l_name | age |
+--------+----------+------+
| Edward | Sakamuro | 25 |
| Mary | Anchor | 26 |
+--------+----------+------+
2 rows in set (0.01 sec)

Forma generala a clauzei LIMIT este:

SELECT (...) from tabela LIMIT nr_rand_incepere,
nr_inreg_extrase;

SELECT f_name, l_name from

angajati_data LIMIT 6,3;

+--------+------------+
| f_name | l_name |
+--------+------------+
| John | MacFarland |
| Edward | Sakamuro |
| Alok | Nanda |
+--------+------------+
3 rows in set (0.00 sec)
Comanda de mai sus extrage 3 angajati incepand de la inregistrarea 6.
Folosirea clauzei DISTINCT permite listarea doar a valorilor distincte din
baza de date pentru fiecare camp in parte.
Functii agregat

13 | P a g e
MIN(): Valoare minima
MAX(): Valoare maxima
SUM(): Suma valorilor
AVG(): Media aritmetica
COUNT(): Numarul inregistrarilor extrase

SELECT MIN(salary) from angajati_data;

+-------------+
| MIN(salary) |
+-------------+
| 70000 |
+-------------+
1 row in set (0.00 sec)

SELECT MAX(salary) from angajati_data;

+-------------+
| MAX(salary) |
+-------------+
| 200000 |
+-------------+
1 row in set (0.00 sec)

SELECT SUM(salary) from angajati_data;

+-------------+
| SUM(salary) |
+-------------+
| 1997000 |
+-------------+
1 row in set (0.00 sec)

SELECT COUNT(*) from angajati_data;

+----------+
| COUNT(*) |
+----------+
| 21 |
+----------+
1 row in set (0.00 sec)
Denumirea campurilor in SELECT MySQL permite sa denumesti
campurile extrase cu termeni mai descriptivi pentru datele extrase.
SELECT avg(salary) AS 'Salariu mediu' from angajati_data;

+----------------+
| Salariu mediu |
+----------------+
| 95095.2381 |
+----------------+
1 row in set (0.00 sec)
14 | P a g e
 Clauza GROUP BY permite gruparea informatiilor similare. Deci, pentru
a lista toate functiile unice din tabela:
select title from angajati_data GROUP BY title;

+----------------------------+
| title |
+----------------------------+
| CEO |
| Customer Service Manager |
| Finance Manager |
| Marketing Executive |
| Multimedia Programmer |
| Programmer |
| Senior Marketing Executive |
| Senior Programmer |
| Senior Web Designer |
| System Administrator |
| Web Designer |
+----------------------------+
11 rows in set (0.01 sec)
Clauza HAVING permite specificare unei conditii pentru gruparea
inregistrarilor
select title, AVG(salary)
from angajati_data
GROUP BY title
HAVING AVG(salary) > 100000;

+----------------------------+-------------+
| title | AVG(salary) |
+----------------------------+-------------+
| CEO | 200000.0000 |
| Finance Manager | 120000.0000 |
| Senior Marketing Executive | 120000.0000 |
| Senior Programmer | 115000.0000 |
| Senior Web Designer | 110000.0000 |
+----------------------------+-------------+
5 rows in set (0.00 sec)

8. JOIN-URI INTRE TABELE

Extragerea inregistrarilor din mai multe tabele (JOIN-uri)

De multe ori, ca sa raspunzi la o intrebare trebuie sa extragi date din mai
multe tabele. De exemplu, pentru a afla ce clienti au facut comenzi luna
15 | P a g e
 asta trebuie sa folosesti tabela clienti si tabela comenzi. Pentru acest
lucru in SQL trebuie realizata o relatie intre tabele (JOIN) pe baza unor
informatii comune (un camp de ID).
In exemplul nostru campul care relationeaza tabela 'angajati_data' este
emp_id, iar pentru 'angajati_per’ este e_id. Sa extragem numele
angajatilor casatoriti din angajati_data si numele sotiei din angajati_per
(vom folosi functia CONCAT pentru a alipi doua siruri de caractere):
select CONCAT(f_name, " ", l_name) AS Name,
s_name as 'Spouse Name' from
angajati_data, angajati_per
where m_status = 'Y' AND
emp_id = e_id;

+-----------------+-----------------+
| Name | Spouse Name |
+-----------------+-----------------+
| Manish Sharma | Anamika Sharma |
| John Hagan | Jane Donner |
| Ganesh Pillai | Sandhya Pillai |
| Anamika Sharma | Manish Sharma |
| John MacFarland | Mary Shelly |
| Alok Nanda | Manika Nanda |
| Paul Simon | Muriel Lovelace |
| Arthur Hoopla | Rina Brighton |
| Kim Hunter | Matt Shikari |
| Danny Gibson | Betty Cudly |
| Mike Harper | Stella Stevens |
| Monica Sehgal | Edgar Alan |
| Peter Champion | Ruby Richer |
+-----------------+-----------------+
13 rows in set (0.00 sec)

Tipuri de join-uri in MySQL

Produs cartezian,
Full Join, Cross join
Toate combinatiile tuturor liniilor din tabela. Se specifica prin virgula
si fara clauza WHERE.
Inner join
Poate fi specificat prin virgula intre numele tabelelor sau prin folosirea
WHERE sau cu cuvintele cheie INNER JOIN.
Equi-join
Foloseste o conditie cu '=' pentru a face corespondente intre
inregistrari.
16 | P a g e
Left join
Incearca sa gasesca corespondente intre tabele si cand nu gaseste,
umple inregistrarile fara pereche cu NULL.

9. STERGEREA INREGISTRARILOR DIN TABELA

DELETE FROM table

[WHERE condition] [LIMIT number]

Exemplu:
delete from customers where customerid=5;

Stergerea tabelelor
DROP TABLE angajati_data;

Stergerea unei baze de date

DROP DATABASE database;

10. CREAREA INDECSILOR

Se poate face cu comanda INDEX sau specificand la crearea unui tabel

un camp ca PRIMARY KEY.
index nume_index (nume_coloana_indexata)
create table my_table ( id_col int unsigned auto_increment
primary key, another_col text );

Indecsi pot cuprinde si mai multe campuri:

create table mytable( id_col int unsigned not null, another_col char(200)
not null, index dual_col_index(id_col, another_col) );

In versiunea MySQL 3.23 puteti indexa si dupa o parte dintr-un camp

index index_name (column_name(column_length))

De exemplu:

create table my_table(

char_column char (255) not null,
text_column text not null,
index index_on_char (char_column(20)),

17 | P a g e
index index_on_text (text_column(200))
);

11. MODIFICAREA TABELELOR DUPA CREARE

ALTER TABLE nume modificare [, modificare ...]

Posibile modificari cu ALTER TABLE

Sintaxa Descriere
ADD [COLUMN] column_description Adauga o coloana
[FIRST | AFTER column ]
ADD [COLUMN] (column_description, Adauga o descriere de coloana
ADD INDEX [index] (column,...) Adauga un index
ADD PRIMARY KEY (column,...) Transforma campul in PK

ADD UNIQUE [index] (column,...) Adauga un index pt. unicate

ALTER [COLUMN] column {SET DEFAULT Adauga/sterge valorile implicite
value | DROP DEFAULT}
CHANGE [COLUMN] column new_column Modificari pentru coloane
_description
MODIFY [COLUMN] column_description
DROP [COLUMN] column Sterge un camp
DROP PRIMARY KEY Sterge PK
DROP INDEX index Sterge indexul
RENAME[AS] new_table_name Redenumeste o tabela

MySQL ofera 3 tipuri de tabele: ISAM, MyISAM (implicit),

BDB /InnoDB/, and Heap alese dupa sintaxa:
create table nume type=tip_tabela( nume_col coloana attribut );
1. Heap-urile sunt tabele hash temporare rezidente in memorie.
2. Tabelele BDB sunt folosite la tranzactii,
3. iar tabelele ISAM nu mai sunt recomandate.
4. Deci alegerea implicita MyISAM este cea mai buna si nu trebuie
sa-ti faci grji ca trebuie sa specifici vreodata un tip de tabela.

Sintaxe ALTER:
(Redenumire tabela:)
ALTER TABLE nume_vechi RENAME nume_nou
(Modificare camp:)
ALTER TABLE my_table add COLUMN my_column text not null
(Stergere camp):

18 | P a g e
 ALTER TABLE nume_tabela DROP column nume_camp
Indecsi:
ALTER TABLE my_table ADD INDEX index_name (column_name1,
column_name2, ...)
ALTER TABLE my_table ADD UNIQUE index_name(column_name)
ALTER TABLE my_table ADD PRIMARY key(my_column)
ALTER TABLE table_name DROP index index_name
ALTER TABLE table_name test10 DROP primary key

LIMBAJUL MYSQL-FUNCTII SI COMENZI

PENTRU A LUCRA CU CATEGORIILE LIMBAJULUI MYSQL INSTALAT

IN LUCRAREA 1
RECOMAND SA GASITI IN FISIERUL MANUAL CARE SE AFLA PE
ADRESA

C:\Program Files\MySQL\MySQL Server 5.1\Docs

NOTIUNILE CE URMEAZA SI SA STABILITI CARE SUNT

DIFERENTELE!!

 Siruri de caractere
 Numere
 NULL
 Numele folosite
 Variabile definite de utilizator
 Comentarii
 Cuvinte rezervate
 Functii pentru compararea de siruri
 Functii matematice
 Functii pentru siruri de caractere
 Functii pentru date si timp
 Functii diverse
 Sintaxa completa a celor mai folosite comenzi

MySQL are o interfata SQL foarte complexa, dar si intuitiva si usor de

invatat. Capitolul acesta se ocupa cu prezentarea detaliata a unor
comenzi diverse (cum se folosesc ele ati aflat in Utilizare MySQL), tipuri
de date si functii de care veti avea nevoie ca sa folosesti MySQL eficient.

19 | P a g e
STRUCTURA LIMBAJULUI FOLOSIT
Siruri de caractere
Un sir de caractere (string) este o secventa de caractere aflata intre
apostrofuri sau ghilimele ('un sir' sau "un sir"). Intr-un sir de caractere,
unele secvente au un inteles special. Aceste secvente incep cu '\'.
MySQL recunoste urmatoarele secvente de escape:
\0
0 (NULL)
\'
Apostrof
\"
Ghilimele.
\b , \\
Backslash
\n
Linie noua
\r
Carriage return
\t
Tab.
\z
Control-Z (sfarsit de fisier)
\%
Procent `%'
\_
Undersore `_'

Daca vreti sa includeti ghilimele si apostrofuri in siruri de caractere:

mysql> SELECT 'hello', '"hello"', '""hello""', 'hel''lo', '\'hello';

+-------+---------+-----------+--------+--------+
| hello | "hello" | ""hello"" | hel'lo | 'hello |
+-------+---------+-----------+--------+--------+

mysql> SELECT "hello", "'hello'", "''hello''", "hel""lo", "\"hello";

+-------+---------+-----------+--------+--------+
| hello | 'hello' | ''hello'' | hel"lo | "hello |
+-------+---------+-----------+--------+--------+
Numere
Numerele intregi sunt reprezentate ca o secventa de cifre, iar float-urile
folosesc '.' ca separator decimal.
Valoarea NULL
Valoarea NULL inseamna 'Nici o informatie' si difera de valoarea 0 pentru
intregi si de sirul gol pentru siruri de caractere.
20 | P a g e
 Numele folosite pentru baze de date, tabele, indecsi, coloane si
alias-uri
Un nume poate contine caractere alfanumerice din setul curent de
cacactere (implicit ISO-8859-1 Latin1). Un nume poate incepe cu orice
caracter valid in nume. Un nume poate incepe si cu un numar, dar nu
poate fi compus numai din numere. Nu puteti folosi '.' in nume deoarece e
folosit pentru a referi coloanele din tabele. sensibilitatea la majuscule sau
minuscule pentru numele alese depinde de sistemul de operare (case
sensitive in Unix si case insensitive in Windows). Oricum, in Windows nu
puteti referi aceeasi baza de date in aceeasi interogare cu un nume in
cazuri diferite. Urmatoare interogare nu merge:
mysql> SELECT * FROM my_table WHERE MY_TABLE.col=1;
Numele de coloane sunt case insensitive. Alias-urile sunt case sensitive.

Variabile definite de utilizator

Se pot defini cu @nume_variabila. Ele nu trebuiesc initializate, contin de

la inceput valoare NULL si pot stoca un integ, un numar real, un float sau
un sir de caractere. Puteti seta o variabila la o anumita valoare cu:

SET @variable= { integer expression | real expression | string

expression }[,@variable= ...].

sau cu:
select @t1:=(@t2:=1)+@t3:=4,@t1,@t2,@t3;
+----------------------+------+------+------+
| @t1:=(@t2:=1)+@t3:=4 | @t1 | @t2 | @t3 |
+----------------------+------+------+------+
| 5 | 5 | 1 | 4 |
+----------------------+------+------+------+
Comentarii
MySQL suporta cometariile #pana la sfarsit de linie, --pana la sfarsit de
linie si /*linii multiple*/.
mysql> select 1+1; # Comentariu pana la sfarsitul linie
mysql> select 1+1; -- Comentariu pana la sfarsitul liniei
mysql> select 1 /* comentariu in-line */ + 1;
mysql> select 1+
/*
comentariu
multi-linii
*/
1;
21 | P a g e
 Cuvinte rezervate

action add aggregate all

alter after and as
avg_row_leng
asc avg auto_increment
th
between bigint bit binary
blob bool both by
cascade case char character
change check checksum column
columns comment constraint create
current_timesta
cross current_date current_time
mp
data database databases date
datetime day day_hour day_minute
day_second dayofmonth dayofweek dayofyear
dec decimal default delayed
delay_key_write delete desc describe
distinct distinctrow double drop
end else escape escaped
enclosed enum explain exists
fields file first float
float4 float8 flush foreign
from for full function
global grant grants group
high_priorit
having heap hour
y
hour_minute hour_second hosts identified
ignore in index infile
inner insert insert_id int
integer interval int1 int2
int3 int4 int8 into
if is isam join
key keys kill last_insert_id
leading left length like
lines limit load local
lock logs long longblob
longtext low_priority max max_rows
match mediumblob mediumtext mediumint
middleint min_rows minute minute_second
modify month monthname myisam
natural numeric no not
null on optimize option
optionally or order outer
outfile pack_keys partial password
precision primary procedure process
processlist privileges read real
references reload regexp rename
replace restrict returns revoke

22 | P a g e
 rlike row rows second
select set show shutdown
sql_big_tabl
smallint soname sql_big_selects
es
sql_low_priority_upda sql_log_upda sql_select_limi
sql_log_off
tes te t
sql_big_resu
sql_small_result sql_warnings straight_join
lt
starting status string table
tables temporary terminated text
then time timestamp tinyblob
tinytext tinyint trailing to
type use using unique
unlock unsigned update usage
values varchar variables varying
varbinary with write when
where year year_month zerofill

Urmatoarele cuvinte pot fi folosite si pentru nume de tabele, coloane etc.:

ACTION BIT DATE ENUM NO TEXT TIME TIMESTAMP

FUNCTII

Functii pentru compararea de siruri

LIKE
Cauta un 'pattern' intr-o expresie folosind caracterele wildcard:%(orice
numar de caractere) si _ (un singur caracter).

expr LIKE pat [ESCAPE ‘escape-char’]

mysql> select ‘jay greenspan’ like ‘jay%’;
‘jay greenspan’ like ‘jay%’ 1

REGEXP
Face o cautare folosind o expresie string si o expresie regulara. Returneaza
1 (a gasit) sau 0(n-a gasit).

expr REGEXP pat

mysql> select name from guestbook where name regexp ‘^j.*g’;

STRCMP
STRCMP(expr1,expr2)
Returneaza 0 daca sirurile sunt egale, -1 daca primul sir e mai mic si 1
daca sirul 2 e mai mic ca sirul 1.

Functii pentru controlul programului

IFNULL
23 | P a g e
 IFNULL(expr1,expr2)
Daca expr1 nu e NULL, returneaza expr1, altfel ret. expr2.
mysql> select ifnull(1/0, ‘exp 1 is null’);
+--------------------------------+
| ifnull(1/0, ‘exp 1 is null’) |
+--------------------------------+
| exp 1 is null |
+--------------------------------+
1 row in set (0.00 sec)

IF

IF(expr1,expr2,expr3)
mysql> select if(name like ‘jay%’, ‘Yes’, ‘No’) as ‘Jay Names’ -> from
guestbook;
Functii matematice

ABS (modulul unui numar)

SIGN (semnul:-1 negativ, 1 pozitiv, 0 egal cu 0)
MOD (rstul impartirii)
FLOOR (cea mai mare valoare intreaga mai mica ca un numar)
CEILING (cea mai mica valoare intreaga mai mare ca un numar)
ROUND (un numar rotunjit la o valoare intreaga)
TRUNCATE (trunceaza un numar la un anumit numar de zecimale)
mysql> select truncate(8.53,0), truncate(8.43,0),
truncate(8.534,2);

|truncate(8.53,0)|truncate(8.43,0)|truncate(8.534,2)|
| 8 | 8 | 8.53 |

1 row in set (0.05 sec)

EXP (exponentiala unui numar)

LOG (logaritm)
LOG10 (logaritm zecimal)
POW(X,Y) (X la puterea Y)
SQRT (radacina patrata)
PI (aproximarea lui PI)
COS (cosinus)
SIN (sinus)
TAN (tangenta)
ACOS (arccosinus)
ASIN (arcsinus)
ATAN (arctangenta)
COT (cotangenta)
RAND (valoare la intamplare intre 0 si 1.0)
24 | P a g e
LEAST (cel mai mic argument)
mysql> select least(2,7,9,1);

|least(2,7,9,1)|
| 1 |

1 row in set (0.00 sec)

GREATEST (cea mai mare valoare dintre argumente)

DEGREES (converteste din radiani in grade)
RADIANS (converteste din grade in radiani)

Functii pentru siruri de caractere

ASCII(str) (codul ASCII)

mysql> select ascii(‘\n’);

| ascii(‘\n’)|
| 10 |
1 row in set (0.00 sec)

ORD(str)
CONV(N,from_base,to_base)
BIN(N) (converteste N in baza 2)
OCT(N) (converteste N in baza 8)
HEX(N) (converteste N in baza 16)
CHAR(N1,N2,...) (sirul de caractere format din reprezentarile ASCII ale
argumentelor intregi)
CONCAT(str1,str2,...) (concateneaza doua siruri de cacactere)
LENGTH (lungimea unui sir)
LOCATE(substr,str [,pos]) (cauta pozitia unui subsir intr-un sir)

mysql> select locate(‘s’, ‘mysql functions’) as example1,

-> locate(‘s’, ‘mysql functions’,4) as example2;

|example1|example2|
| 3 | 15 |

1 row in set (0.00 sec)

INSTR(str,substr) (pozitia subsirului in sir)

LPAD(str,len,padstr) (sirul padstr e adaugat la stanga lui srt)
RPAD
LEFT(str,len) (primele 'len' caractere din str)
RIGHT(str,len)
25 | P a g e
SUBSTRING(str,pos[,len]) sau
MID(str,pos,len)

mysql> select mid(‘mysqlfunctions’,6,8);

| mid(‘mysqlfunctions’,6,8)|
| function |

1 row in set (0.00 sec)

SUBSTRING_INDEX(str,delim,count)

mysql> select substring_index(‘mysqlfunctionsmysql’, ‘fu’, 1);

| substring_index(‘mysqlfunctions’, ‘fu’, 1) |
| mysql |

1 row in set (0.00 sec)

mysql> select substring_index(‘mysqlfunctionsmysql’, ‘fu’, -

1);

| substring_index(‘mysqlfunctionsmysql’, ‘fu’, -1) |

| nctionsmysql |

1 row in set (0.00 sec)

LTRIM
RTRIM
TRIM
TRIM([[BOTH | LEADING | TRAILING] [remstr] FROM] str)
REPLACE(str,from_str,to_str)
SOUNDEX(str) (sirul in format SOUNDEX)
SPACE(N) (un spatiu de N pozitii)
REPEAT(str,count) (repeta str de 'count' ori)
REVERSE (inverseaza un sir)
INSERT(str,pos,len,newstr)

mysql> select insert(‘mysqlfunctions’, 6,2,’FU’);

+ +
|insert(‘mysqlfunctions’, 6,2,’FU’)|
+ +
|mysqlFUnctions |
+ +
26 | P a g e
1 row in set (0.44 sec)
FIELD(str,str1,str2,str3,...) (pozitia str in cadrul argumentelor)
LCASE (lowercase)
UCASE (uppercase)
LOAD_FILE (continutul unui fiser ca sir

Functii pentru data calendaristica si timp

DAYOFWEEK
mysql> select dayofweek(‘2001-01-01’);

+ +
| dayofweek(‘2001-01-01’)|
| 2 |
1 row in set (0.33 sec)

WEEKDAY
DAYOFMONTH
DAYOFYEAR
MONTHNAME
QUARTER (semestrul din care face parte data)
WEEK(date [, first]) (first=0-saptamana incepe duminica, first=1-
saptamana incepe luni)
YEAR
YEARWEEK (anul si saptamana in format YYYYWW)
HOUR
MINUTE
SECOND
PERIOD_ADD(P,N) (adauga N luni la perioda P)
PERIOD_DIFF(P1,P2)
DATE_ADD
DATE_SUB(date,INTERVAL expr type)
TO_DAYS
FROM_DAYS
DATE_FORMAT

Specificatori pentru DATE_FORMAT

%M Luna (January÷December)
%W Ziua (Sunday÷ Saturday)
%D Numarul zilei(1st, 2nd, 3rd, etc.)
%Y Anul AAAA
%y Anul AA
%a Numele abreviat al zilei(Sun..Sat)
%d Numarul zilei lunii(00..31)

27 | P a g e
%e Numarul zilei lunii(0..31)
%m Numarul lunii(01..12)
%c Numarul lunii(1..12)
%b Numele lunii(Jan..Dec)
%j Numarul zilei in an(001..366)
%H Ora (00..23)
%k Ora (0..23)
%h Ora (01..12)
%I Ora (01..12)
%l Ora (1..12)
%i Minutele(00..59)
%r Timpul, 12-ore (hh:mm:ss [AP]M)
%T Timpul, 24-ore (hh:mm:ss)
%S Secundele(00..59)
%s Secundele (00..59)
%p AM sau PM
%w Ziua saptamanii (0=Sunday..6=Saturday)
%U Saptamana (0..53)
%u Saptamana (0..53)
%V Saptamana (1..53)
%v Saptamana (1..53)
%X Anul pentru saptamana
%x Anul pentru saptamana
%% Caracterul %

Exemplu:

mysql> select date_format(‘2001-01-01’, ‘%W %M %d, %Y’);

| date_format(‘2001-01-01’, ‘%W %M %d, %Y’) |

| Monday January 01, 2001 |
1 row in set (0.00 sec)

TIME_FORMAT
CURDATE
CURTIME
NOW (data si ora curenta YYYY-MM-DD HH:MM:SS)

Alte functii diverse

Database (numele bazei de date curente)

User (numele utilizatorului curent)
VERSION (versiunea MySQL)
LAST_INSERT_ID (ultima valoare inserata intr-un camp
'auto_increment')
28 | P a g e
SINTAXA COMPLETA A CELOR MAI FOLOSITE COMENZI MYSQL
SELECT
SELECT [STRAIGHT_JOIN] [SQL_SMALL_RESULT] [SQL_BIG_RESULT] [SQL_BUFFER_RESULT]
[HIGH_PRIORITY]
[DISTINCT | DISTINCTROW | ALL]
select_expression,...
[INTO {OUTFILE | DUMPFILE} 'file_name' export_options]
[FROM table_references
[WHERE where_definition]
[GROUP BY {unsigned_integer | col_name | formula} [ASC | DESC], ...]
[HAVING where_definition]
[ORDER BY {unsigned_integer | col_name | formula} [ASC | DESC] ,...]
[LIMIT [offset,] rows]
[PROCEDURE procedure_name]
[FOR UPDATE | LOCK IN SHARE MODE]]

INSERT
INSERT [LOW_PRIORITY | DELAYED] [IGNORE]
[INTO] tbl_name [(col_name,...)]
VALUES (expression,...),(...),...
sau INSERT [LOW_PRIORITY | DELAYED] [IGNORE]
[INTO] tbl_name [(col_name,...)]
SELECT ...
sau INSERT [LOW_PRIORITY | DELAYED] [IGNORE]
[INTO] tbl_name
SET col_name=expression, col_name=expression, ...

ALTER TABLE
ALTER [IGNORE] TABLE tbl_name alter_spec [, alter_spec ...]

alter_specification:
ADD [COLUMN] create_definition [FIRST | AFTER column_name ]
sau ADD [COLUMN] (create_definition, create_definition,...)
sau ADD INDEX [index_name] (index_col_name,...)
sau ADD PRIMARY KEY (index_col_name,...)
sau ADD UNIQUE [index_name] (index_col_name,...)
sau ADD FULLTEXT [index_name] (index_col_name,...)
sau ADD [CONSTRAINT symbol] FOREIGN KEY index_name (index_col_name,...)
[reference_definition]
sau ALTER [COLUMN] col_name {SET DEFAULT literal | DROP DEFAULT}
sau CHANGE [COLUMN] old_col_name create_definition
sau MODIFY [COLUMN] create_definition
sau DROP [COLUMN] col_name
sau DROP PRIMARY KEY
sau DROP INDEX index_name
sau DISABLE KEYS
sau ENABLE KEYS
sau RENAME [TO] new_tbl_name
sau ORDER BY col
sau table_options

UPDATE
UPDATE [LOW_PRIORITY] [IGNORE] tbl_name
SET col_name1=expr1, [col_name2=expr2, ...]
[WHERE where_definition]
[LIMIT #]

LOAD DATA INFILE

29 | P a g e
LOAD DATA [LOW_PRIORITY | CONCURRENT] [LOCAL] INFILE 'file_name.txt'
[REPLACE | IGNORE]
INTO TABLE tbl_name
[FIELDS
[TERMINATED BY '\t']
[[OPTIONALLY] ENCLOSED BY '']
[ESCAPED BY '\\' ]
]
[LINES TERMINATED BY '\n']
[IGNORE number LINES]
[(col_name,...)]

DELETE
DELETE [LOW_PRIORITY | QUICK] FROM table_name
[WHERE where_definition]
[ORDER BY ...]
[LIMIT rows]
sau
DELETE [LOW_PRIORITY | QUICK] table_name[.*] [table_name[.*] ...] FROM
table-references [WHERE where_definition]

CREATE INDEX
CREATE [UNIQUE|FULLTEXT] INDEX index_name ON tbl_name (col_name[(length)],... )

CREATE TABLE
CREATE [TEMPORARY] TABLE [IF NOT EXISTS] tbl_name [(create_definition,...)]
[table_options] [select_statement]

create_definition:
col_name type [NOT NULL | NULL] [DEFAULT default_value] [AUTO_INCREMENT]
[PRIMARY KEY] [reference_definition]
sau PRIMARY KEY (index_col_name,...)
sau KEY [index_name] (index_col_name,...)
sau INDEX [index_name] (index_col_name,...)
sau UNIQUE [INDEX] [index_name] (index_col_name,...)
sau FULLTEXT [INDEX] [index_name] (index_col_name,...)
sau [CONSTRAINT symbol] FOREIGN KEY index_name (index_col_name,...)
[reference_definition]
sau CHECK (expr)

type:
TINYINT[(length)] [UNSIGNED] [ZEROFILL]
sau SMALLINT[(length)] [UNSIGNED] [ZEROFILL]
sau MEDIUMINT[(length)] [UNSIGNED] [ZEROFILL]
sau INT[(length)] [UNSIGNED] [ZEROFILL]
sau INTEGER[(length)] [UNSIGNED] [ZEROFILL]
sau BIGINT[(length)] [UNSIGNED] [ZEROFILL]
sau REAL[(length,decimals)] [UNSIGNED] [ZEROFILL]
sau DOUBLE[(length,decimals)] [UNSIGNED] [ZEROFILL]
sau FLOAT[(length,decimals)] [UNSIGNED] [ZEROFILL]
sau DECIMAL(length,decimals) [UNSIGNED] [ZEROFILL]
sau NUMERIC(length,decimals) [UNSIGNED] [ZEROFILL]
sau CHAR(length) [BINARY]
sau VARCHAR(length) [BINARY]
sau DATE
sau TIME
sau TIMESTAMP
sau DATETIME
sau TINYBLOB
sau BLOB
sau MEDIUMBLOB
sau LONGBLOB
sau TINYTEXT
sau TEXT
30 | P a g e
 sau MEDIUMTEXT
sau LONGTEXT
sau ENUM(value1,value2,value3,...)
sau SET(value1,value2,value3,...)

index_col_name:
col_name [(length)]

reference_definition:
REFERENCES tbl_name [(index_col_name,...)]
[MATCH FULL | MATCH PARTIAL]
[ON DELETE reference_option]
[ON UPDATE reference_option]

reference_option:
RESTRICT | CASCADE | SET NULL | NO ACTION | SET DEFAULT

table_options:
TYPE = {BDB | HEAP | ISAM | InnoDB | MERGE | MYISAM }
sau AUTO_INCREMENT = #
sau AVG_ROW_LENGTH = #
sau CHECKSUM = {0 | 1}
sau COMMENT = "string"
sau MAX_ROWS = #
sau MIN_ROWS = #
sau PACK_KEYS = {0 | 1}
sau PASSWORD = "string"
sau DELAY_KEY_WRITE = {0 | 1}
sau ROW_FORMAT= { default | dynamic | fixed | compressed }
sau RAID_TYPE= {1 | STRIPED | RAID0 } RAID_CHUNKS=# RAID_CHUNKSIZE=#
sau UNION = (table_name,[table_name...])
sau DATA DIRECTORY="directsauy"
sau INDEX DIRECTORY="directsauy"

select_statement:
[IGNORE | REPLACE] SELECT ... (Some legal select statement)

CREATE DATABASE
CREATE DATABASE [IF NOT EXISTS] db_name

DROP DATABASE
DROP DATABASE [IF EXISTS] db_name

DROP INDEX
DROP INDEX index_name ON tbl_name

DROP TABLE
DROP TABLE [IF EXISTS] tbl_name [, tbl_name,...] [RESTRICT | CASCADE]

RENAME TABLE
RENAME TABLE tbl_name TO new_table_name[, tbl_name2 TO new_table_name2,...]

JOIN
table_reference, table_reference
table_reference [CROSS] JOIN table_reference
table_reference INNER JOIN table_reference
table_reference STRAIGHT_JOIN table_reference
table_reference LEFT [OUTER] JOIN table_reference ON conditional_expr
table_reference LEFT [OUTER] JOIN table_reference USING (column_list)
table_reference NATURAL LEFT [OUTER] JOIN table_reference
{ oj table_reference LEFT OUTER JOIN table_reference ON conditional_expr

31 | P a g e