Instructiuni SQL
Structured Query Language (SQL) este limbajul standard utilizat pentru accesarea bazelor de date relationale. Limbajul SQL este un limbaj declarativ, neprocedural, prin intermediul caruia utilizatorii descriu structurile si manipuleaza datele. Prin intermediul limbajelor declarative utilizatorii stabilesc ce date doresc sa obtina, fara a specifica modalitatile de obtinere a acestor date.
Avand in vedere faptul ca exista o standardizare a acestui limbaj, majoritatea sistemelor de gestiune a bazelor de date relationale utilizeaza instructiuni ale limbajului SQL (implementeaza standardul SQL): Oracle, Microsoft SQL Server, MySQL, PostgreSQL, SQLite, Sybase, Ingres.
Instructiunile limbajului Structured Query Language pot fi clasificate in 5 categorii, asa cum se poate observa si mai jos.
DDL (Data Definition Language): instructiuni de definire a datelor (permit descrierea structurii tabelelor).
Instructiune | Semnificatie |
---|---|
CREATE | permite crearea tabelelor |
ALTER | permite modificarea tabelelor |
TRUNCATE | permite stergerea continutului unui tabel |
DROP | permite stergerea tabelelor |
RENAME | permite modificarea denumirii unui tabel |
DML (Data Manipulation Language): instructiuni de manipulare a datelor (permit modificarea continutului tabelelor).
Instructiune | Semnificatie |
---|---|
INSERT | permite adaugarea de noi inregistrari intr-un tabel |
UPDATE | permite actualizarea valorilor pentru inregistrarile dintr-un tabel |
DELETE | permite stergerea inregistrarilor dintr-un tabel |
DQL (Data Query Language): instructiuni de interogare a datelor.
Instructiune | Semnificatie |
---|---|
SELECT | permite regasirea liniilor memorate in tabele |
TCL (Transaction Control Language): instructiuni de procesare a tranzactiilor.
Instructiune | Semnificatie |
---|---|
SAVEPOINT | permite definirea unui punct de salvare, la care se poate reveni pentru a renunta la modificarile facute dupa acest punct asupra bazei de date |
COMMIT | permite ca modificarile facute asupra bazei de date sa devina permanente |
ROLLBACK | permite renuntarea la anumite modificari facute asupra bazei de date |
DCL (Data Control Language): instructiuni pentru controlul datelor (permit definirea, modificarea si retragerea privilegiilor).
Instructiune | Semnificatie |
---|---|
GRANT | permite acordarea de privilegii |
REVOKE | permite retragerea privilegiilor |
O instructiune SQL poate include urmatoarele componente:
• identificatori: specifica nume de obiecte SQL (baze de date, tabele, indecsi, vizualizari, proceduri stocate);
• cuvinte rezervate: termeni predefiniti care asigura o anumita functionalitate;
• variabile: locatii de memorie desemnate printr-un nume;
• constante: numerice (intregi 3251, reale 32.15); alfanumerice/sir de caractere (‘sir caractere’, “sir caractere”); NULL (constanta speciala cu semnificatia nici o valoare);
• operatori: simboluri utilizate in implementarea anumitor operatii;
• expresii: formate din variabile, constante, operatori si apeluri de functii.
Orice obiect SQL (baza de date, tabel, index, alias, vizualizare, procedura stocata) detine un nume (identificator). Pot fi utilizate nume de obiecte care includ unul sau mai multi identificatori. Componentele unui nume cu mai multi identificatori sunt separate prin intermediul caracterului “.”. De exemplu, referirea unei coloane, dintr-un tabel al unei baze de date, se poate face in trei moduri.
Mod referire | Semnificatie |
---|---|
col | coloana col din tabelul utilizat in instructiune |
tab.col | coloana col din tabelul tab din baza de date implicita (activa) |
db.tab.col | coloana col din tabelul tab din baza de date db |
Comentariile sunt utilizate pentru a explica zone dintr-un script sau pentru a preciza informatii suplimentare cu privire la script (autor, versiune, data ultimei modificari).
Limbajul SQL furnizeaza trei modalitati de adaugare a comentariilor in scripturi, cu influente din limbajele de programare, dar si din scripturile de tip shell:
• comentariu multilinie (stilul C): presupune utilizarea perechilor de caractere /*, */ la inceputul si la sfarsitul unui text explicativ;
• comentariu pe o linie: comentariul este precedat de caracterele — sau #.
mysql> # db: sakila, table: actor mysql> SELECT * FROM sakila.actor LIMIT 5; -- WHERE first_name LIKE 'c%'; +----------+------------+--------------+---------------------+ | actor_id | first_name | last_name | last_update | +----------+------------+--------------+---------------------+ | 1 | PENELOPE | GUINESS | 2006-02-15 04:34:33 | | 2 | NICK | WAHLBERG | 2006-02-15 04:34:33 | | 3 | ED | CHASE | 2006-02-15 04:34:33 | | 4 | JENNIFER | DAVIS | 2006-02-15 04:34:33 | | 5 | JOHNNY | LOLLOBRIGIDA | 2006-02-15 04:34:33 | +----------+------------+--------------+---------------------+
Expresii si operatori
Operatorii reprezinta simboluri utilizate in implementarea operatiilor. Limbajul SQL ofera suport pentru urmatoarele categorii de operatori: aritmetici, de comparare, pe biti si logici.
La nivelul sistemelor MySQL/MariaDB sunt implementati urmatorii operatori:
• aritmetici: +, -, *, /, %, MOD, DIV;
• de comparare: =, !=, <>, >, <, >=, <=, <=>, BETWEEN, IN, IS, LIKE;
• pe biti: &, |, ^, ~, <<, >>;
• logici: AND, &&, OR, &&, NOT, !, XOR;
• pentru expresii regulate: REGEXP, RLIKE;
• de asignare: = (in instructiuni SET sau clauze SET in instructiuni UPDATE), :=.
In limbajul SQL, operatorii logici se evaluaza la valorile TRUE, FALSE sau NULL (UNKNOWN). In MySQL, aceste valori sunt implementate prin 1 pentru adevarat (TRUE), 0 pentru fals (FALSE) si NULL. Trebuie avut in vedere faptul ca, in MySQL, orice valoare diferita de 0 sau NULL este evaluata cu 1.
mysql> SELECT NOT 0, NOT NULL, ! 1, 1 AND 0, 1 && NULL, 1 OR 1, 0 || NULL; +-------+----------+-----+---------+-----------+--------+-----------+ | NOT 0 | NOT NULL | ! 1 | 1 AND 0 | 1 && NULL | 1 OR 1 | 0 || NULL | +-------+----------+-----+---------+-----------+--------+-----------+ | 1 | NULL | 0 | 0 | NULL | 1 | NULL | +-------+----------+-----+---------+-----------+--------+-----------+
Operatorii de comparare returneaza 1 pentru adevarat, 0 pentru fals si NULL daca nu se poate efectua comparatia. Operatorii de comparare pot fi utilizati atat cu siruri de caractere, cat si cu valori numerice.
Operatorul de echivalanta (<=>) returneaza acelasi rezultat ca si operatorul de egalitate, cu doua exceptii: daca ambii operanzi sunt NULL, returneaza 1, iar daca doar unul din operanzi este NULL, returneaza 0.
mysql> SELECT 1 <=> 1, 1 = 1, NULL <=> NULL, NULL = NULL, 1 <=> NULL, 1 = NULL; +---------+-------+---------------+-------------+------------+----------+ | 1 <=> 1 | 1 = 1 | NULL <=> NULL | NULL = NULL | 1 <=> NULL | 1 = NULL | +---------+-------+---------------+-------------+------------+----------+ | 1 | 1 | 1 | NULL | 0 | NULL | +---------+-------+---------------+-------------+------------+----------+
Operatorul IS NULL testeaza daca operandul are valoarea NULL, in timp ce operatorul IS NOT NULL testeaza daca operandul este diferit de valoarea NULL. Operatorii IS si IS NOT compara o valoare cu o valoare de tip boolean (TRUE, FALSE si UNKNOWN).
Operatorul BETWEEN (expresie BETWEEN min AND max) testeaza daca valoarea expresiei este in intervalul [min, max].
mysql> SELECT 2 BETWEEN 1 AND 3, 'e' BETWEEN 'a' AND 'c', 2 BETWEEN 2 AND '3'; +-------------------+-------------------------+---------------------+ | 2 BETWEEN 1 AND 3 | 'e' BETWEEN 'a' AND 'c' | 2 BETWEEN 2 AND '3' | +-------------------+-------------------------+---------------------+ | 1 | 0 | 1 | +-------------------+-------------------------+---------------------+
Operatorul IN (exprresie IN (valoare, …)) testeaza daca valoarea expresiei este in lista de valori specificata.
mysql> SELECT 2 IN (1, 2, 3, 5), 'a' IN ('a', 'c', 'd'); +-------------------+------------------------+ | 2 IN (1, 2, 3, 5) | 'a' IN ('a', 'c', 'd') | +-------------------+------------------------+ | 1 | 1 | +-------------------+------------------------+
Operatorul LIKE (expr LIKE model) verifica daca expresia corespunde modelului specificat de caractere; modelul poate utiliza doua simboluri speciale (wild-card), cu urmatoarele semnificatii: % – orice secventa de zero sau mai multe caractere, _ – un singur caracter.
mysql> SELECT 'Marian' LIKE 'Maria_', 'ZAYA' LIKE 'Za%'; +------------------------+-------------------+ | 'Marian' LIKE 'Maria_' | 'ZAYA' LIKE 'Za%' | +------------------------+-------------------+ | 1 | 1 | +------------------------+-------------------+
Operatorul REGEXP (expr REGEXP|RLIKE model) returneaza 1, daca expresia corespunde modelului specificat, si 0, in caz contrar; operatorul REGEXP nu este case sensitive, decat in cazul in care utilizeaza siruri de caractere in format binar; operatorul RLIKE este sinonim cu operatorul REGEXP.
mysql> SELECT * FROM sakila.actor WHERE first_name REGEXP '^[pz]'; +----------+------------+-----------+---------------------+ | actor_id | first_name | last_name | last_update | +----------+------------+-----------+---------------------+ | 1 | PENELOPE | GUINESS | 2006-02-15 04:34:33 | | 11 | ZERO | CAGE | 2006-02-15 04:34:33 | | 46 | PARKER | GOLDBERG | 2006-02-15 04:34:33 | | 54 | PENELOPE | PINKETT | 2006-02-15 04:34:33 | | 104 | PENELOPE | CRONYN | 2006-02-15 04:34:33 | | 120 | PENELOPE | MONROE | 2006-02-15 04:34:33 | +----------+------------+-----------+---------------------+
Tipuri de date
Limbajul SQL ofera suport pentru tipuri de date. Acestea pot fi clasificate astfel: tipuri de date numerice, data calendaristica si timp, siruri de caractere, date binare. Fiecare sistem de gestiune a bazelor de date prezinta propria implementarea a acestor categorii de tipuri de date.
Descrierea tipurilor de date, in MySQL, are la baza urmatoarea conventie tip_data [(M,D)] [optiuni], unde tipul de date referit este afisat pe M pozitii, eventual cu D pozitii in partea zecimala. Lista optiunilor posibile include: UNSIGNED (permite memorarea doar a valorilor pozitive), ZEROFILL (la afisare, valorile numerice vor fi precedate de ‘0’ pana la lungimea de afisare), BINARY (specifica faptul ca interpretarea caracterelor se va face in cod ASCII; la compararea a doua siruri se va face distinctie intre litere mari/mici).
Tipuri de date numerice
BIT: valoare binara;
TINYINT: numar intreg; interval valori posibile: SIGNED -128,127, UNSIGNED 0, 255;
TINYINT [(M)] [UNSIGNED] [ZEROFILL]
BOOL: BOOL sau BOOLEAN sunt sinonime pentru TINYINT(1); valoare 0 este evaluata la FALSE, in timp ce valorile diferite de zero se evalueaza la TRUE;
SMALLINT: numar intreg; interval valori posibile: SIGNED -32768, 32767, UNSIGNED 0, 65535;
SMALLINT[(M)] [UNSIGNED] [ZEROFILL]
MEDIUMINT: numar intreg; interval valori posibile: SIGNED -8388608, 8388607, UNSIGNED 0, 1677721;
MEDIUMINT[(M)] [UNSIGNED] [ZEROFILL]
INT: numar intreg; interval valori posibile: SIGNED -2147483648, 2147483647, UNSIGNED 0, 4294967295;
INT[(M)] [UNSIGNED] [ZEROFILL]
BIGINT: numar intreg; interval valori posibile: SIGNED -9223372036854775808, 9223372036854775807, UNSIGNED 0, 18446744073709551615;
BIGINT[(M)] [UNSIGNED] [ZEROFILL]
INTEGER: sinonim cu INT;
INTEGER[(M)] [UNSIGNED] [ZEROFILL]
FLOAT: numar real; numar in virgula flotanta simpla precizie (32 biti);
FLOAT [(M,D)] [UNSIGNED] [ZEROFILL]
DOUBLE: numar real; numar in virgula flotanta dubla precizie (64 biti);
DOUBLE [(M,D)] [UNSIGNED] [ZEROFILL]
REAL: sinonim cu DOUBLE;
REAL [(M,D)] [UNSIGNED] [ZEROFILL]
DECIMAL: numar in virgula flotanta neimpachetat; daca D lipseste numarul va fi intreg;
DECIMAL [(M,[D])] [UNSIGNED] [ZEROFILL]
NUMERIC: sinonim cu DECIMAL.
NUMERIC [(M,[D])] [UNSIGNED] [ZEROFILL]
Data calendaristica si timp
DATETIME: data calendaristica si timp; interval de valori posibile: ‘1000-01-01 00:00:00’ .. ‘9999-12-31 23:59:59’; format standard: YYYY-MM-DD HH:MM:SS;
DATE: data calendaristica; interval de valori posibile: ‘1000-01-01’ .. ‘9999-12-31’; format standard: YYYY-MM-DD;
TIME: timp; interval valori posibile: ‘-838:59:59’ .. ‘838:59:59’; format standard: HH:MM:SS;
TIMESTAMP: moment de timp; data efectuarii ultimei operatii (INSERT, UPDATE); interval de valori posibile: ‘1970-01-01 00:00:01’ .. ‘2038-01-19 03:14:07’; format standard: 14 – YYYYMMDDHHMMSS, 12 – YYMMDDHHMMSS, 8 – YYYYMMDD, 6 – YYMMDD;
TIMESTAMP [M]
YEAR: an calendaristic; interval valori posibile: ‘1901’ .. ‘2155’; format standard: 4 – YYYY, 2 – YY.
YEAR [2|4]
Tipuri de date pentru siruri de caractere
In MySQL, tipurile de date pentru sirurile de caractere pot fi clasificate astfel: tipuri pentru siruri normale (CHAR, VARCHAR), tipuri pentru siruri lungi/date binare (TEXT, BLOB) si tipuri speciale (SET, ENUM).
CHAR: sir de caractere de lungime fixa. Daca se memoreaza un sir de caractere mai mic decat lungimea declarata, el va fi completat cu spatii la dreapta. Lungimea maxima pentru o valoare de tip CHAR este 255. Daca nu se specifica optiunea BINARY, compararea valorilor se face fara a tine cont de tipul caracterelor.
CHAR (M) [BINARY]
VARCHAR: sir de caractere de lungime variabila. La memorare, spatiile de la finalul sirului de caractere sunt indepartate; lungimea maxima pentru o valoare de tip VARCHAR este 255. Daca nu se specifica optiunea BINARY, compararea valorilor se face fara a tine cont de tipul caracterelor.
VARCHAR (M) [BINARY]
TEXT: permite siruri de dimensiuni mai mari de 255 de caractere. MySQL implementează 4 subtipuri in aceasta categorie: TINYTEXT, TEXT, MEDIUMTEXT, LONGTEXT. La compararea valorilor de tip TEXT nu se va tine cont de tipul caracterelor.
BLOB: permite stocarea de obiecte binare de mari dimensiuni (imagini, audio, video). MySQL implementează 4 subtipuri în aceasta categorie: TINYBLOB, BLOB, MEDIUMBLOB, LONGBLOB, care diferă doar prin dimensiune. Valorile de tip BLOB sunt tratate ca siruri de caractere in format binar.
SET: multime de elemente de tip sir de caractere. Un obiect de tip SET poate include mai multe valori distincte, din cele specificate, despartite prin virgula, sau poate să fie gol. Pentru un astfel de obiect pot fi definite maximum 64 de valori diferite.
SET(‘valoare1’, ‘valoare2’, …)
ENUM: enumerare de elemente de tip sir de caractere. Un obiect de tip ENUM poate contine o singura valoare din cele enumerate sau valoarea NULL. Pentru un astfel de obiect pot fi definite maximum 65535 de valori distincte. Fiecare valoare din enumerare detine un index numeric (NULL pentru valoarea NULL, 0 pentru sirul vid).
ENUM (‘valoare1’, ‘valoare2’, …)