0% au considerat acest document util (0 voturi)

5 vizualizări58 pagini

Tutorial MySql

MySQL este un sistem de gestiune a bazelor de date relaționale, rapid și gratuit, care funcționează pe diverse platforme. Tutorialul oferă informații despre proiectarea bazelor de date pentru aplicații web, extragerea informațiilor necesare și administrarea serverului MySQL. De asemenea, se discută despre instalarea MySQL, PHP și Apache pe Windows și Linux, precum și despre structura bazelor de date relaționale, inclusiv tabele, coloane și relații între date.

Încărcat de

Stefania Cristiana

Drepturi de autor

Respectăm cu strictețe drepturile privind conținutul. Dacă suspectați că acesta este conținutul dumneavoastră, reclamați-l aici.

Formate disponibile

Descărcați ca DOC, PDF, TXT sau citiți online pe Scribd

0% au considerat acest document util (0 voturi)

5 vizualizări58 pagini

Tutorial MySql

Încărcat de

Stefania Cristiana

Drepturi de autor

Respectăm cu strictețe drepturile privind conținutul. Dacă suspectați că acesta este conținutul dumneavoastră, reclamați-l aici.

Formate disponibile

Descărcați ca DOC, PDF, TXT sau citiți online pe Scribd

MySQL :

 Este un Sistem de Gestiune al Bazelor de Date Relationale.

 Cel mai popular si mai rapid server pt baze de date.
 In general, poate fi copiat si folosit gratuit de catre oricine.

 Functioneaza pe diferite platforme (Windows, Linux,..).

Ce veti invata din acest tutorial :
 Sa proiectati baze de date pentru
lucrul pe Web.
 Sa extrageti dintr-o baza de date
doar informatiile de care aveti
nevoie.
 Sa administrati si sa configurati
serverul MySQL pentru acces sigur
si controlat.

 Sa creati pagini Web dinamice cu

anumite inregistrari dintr-o baza de
date.

Introducere in aplicatii Web si baze de date relationale

 Functionarea aplicatiilor Web

 Ce este MySQL
 Baze de date relationale

Aplicatiile Web sunt prezentul si viitorul. Orice limbaj de programare ai fi facut in trecut,
sau daca stii numai HTML, CV-ul tau va fi vazut altfel cu experienta in dezvoltarea
aplicatiilor Web.
La nivel cel mai de jos World Wide Web-ul se bazeaza pe o arhitecura client/server. Asta
insemna ca si severul central dar si aplicatia-client sunt responsabile de o parte din
procesarea datelor.
Clientul
Aplicatiile care se pot dezvolta folosind MySQL si PHP folosesc un singur client:
browser-ul Web. Unele aplicatii mai sofisticate pot folosi si un applet Java (spre exemplu
un client de chat in timp real). Singurul client de care trebuie sa fii preocupat este
browser-ul care va interpreta aplicatiile tale.
Server-ul
Aproape tot ce fac aplicatiile Web are loc pe un server. O aplicatie specifica, numita
server Web, va fi responsabila pentru comunicarea cu browser-ul. In cele din urma, mai
este nevoie de un limbaj care sa intermedieze cereri intre server-ul web si un server de
baze de date, in cazul nostru si sa realizeze sarcini prin program asupra informatiilor ce
vin si se duc spre sever-ul Web. Toate aceste trei elemente (server-ul Web, limbajul de
programare si serverul de baze de date) trebuie sa fie compatibile si cu sistemul de
operare din calculatorul pe care sunt folosite. Cele mai folosite sisteme de operare pe
serverele Web sunt Windows NT/2000 si UNIX (peste 90% din numarul total de servere
de pe Web).
Ce ar trebui sa folosesti pentru aplicatii Web ?
Ei bine, foarte pe scurt PHP si MySQL sunt produse gratuite, spre deosebire de celelate
optiuni gratuitatea nu inseamna ca nu au aceleasi performante ca sistemele de mii de
dolari. Windows NT sau Windows 2000 este o buna alegere, dar poti folosi MySQL si
PHP si pe Windows 95/98/Me. Cu toate acestea, in lumea de afara aproape toate
aplicatiile PHP/MySQL ruleaza pe o versiune de UNIX: Linux, Irix, Solaris, HP-UX..

Server-ul Web

Cele mai folosite servere Web sunt Apache si Microsoft's IIS. Apache este si el gratuit si
in sistem Open Source ca si PHP, MySQL si Linux. El functioneaza bine pe un sistem
UNIX dar si pe un sistem Windows (dar nu pe un server foarte incarcat). Cea mai buna
alegere este realizarea si testarea aplicatiei pe Windows cu Apache, PHP si MySQL si
apoi transferul aplicatiei pe un server Linux fara schimbari in script-uri.

Middleware

PHP face parte din clasa limbajelor middleware (ASP, Perl, ColdFusion etc.). Aceste
limbaje lucreaza cu serverul Web pentru a interpreta cererile facute din dinspre World
Wide Web, proceseaz aceste cereri, interactioneaza cu alte programe pe server pentru a
indeplini cererile si va indica, apoi, server-ului exact ceea ce trebuie servit browser-ului
clientului. Limbajul middleware va fi folosit pentru marea majoritate din munca ta.

O tranzactie normala cu baza de date Web se constituie din urmatorii pasi (numerotati
in figura):

1. Browser-ul unui utilizator face o cerere HTTP pentru o anumita pagina (spre
exemplu se cauta o anumita carte un site prin intermediul fisierului [Link]).
2. Server-ul Web primeste cererea pentru [Link], cauta fisierul si il paseaza
motorului PHP pentru a fi procesat.
3. Motorul PHP incepe procesarea si gaseste o comanda de conectare la o baza de
date si o interogare dupa un anumit criteriu. PHP deschide o conexiune cu server-
ul MySQL si ii trimite interogarea.
4. Server-ul MySQL primeste interogarea si o proceseaza si trimite rezultatul (o lista
de carti, in cazul nostru) PHP-ului.
5. PHP-ul termina de rulat script-ul (de obicei are loc o formatare a rezultatelor
interogarii in HTML) si returneaza fisierul HTML rezultat server-ului Web
6. Server-ul Web trimite HTML-ul inapoi catre browser de unde utilizatorul poate
vedea lista cartilor pe care le-a cerut.

De ce sa folosesti PHP si MySQL ?

 Daca ai un calculator, Linux, Apache si PHP sunt absolut gratuite. La fel si
MySQL cu unele limitari.
 PHP si MySQL pot fi folosite pe majoritatea platformelor.
 Desi MySQL nu dispune de toate caracteristicile suportate de concurenta, este la
fel de rapid si de puternic.
 Conectivitatea, viteza si securitatea face server-ul MySQL extrem de potrivit
pentru accesarea bazelor de date pe Internet.
 PHP a reusit sa ajunga la mix-ul perfect de putere, rapiditate, structura si usurinta
in folosire.
 Si PHP si MySQL sunt imbunatatite in mod constant

Ce este MySQL ?
MySQL este un server SQL pentru baze de date foarte robust, rapid, multi-utilizator,
multi-thread.

MySQL este un sistem de gestiune a bazelor de date.

O baza de date este o colectie strucurata de date. Ca sa adaugi, sa accersezi si sa
procesezi informatiile din baza de date ai nevoie de un sistem de gestiune a bazelor de
date ca, de exemplu MySQL.
MySQL este un sistem de gestiune a bazelor de date relationale.
O baza de date relationala memoreaza date in tabele separate in loc de a stoca toate
informatiile intr-o singura structura adaugand astfel viteza si flexibilitate. Tabelele sunt
legate prin relatii permitandu-se afisarea datelor combinate la cerere.
Sistemele de gestiune a bazelor de date relationale (SGBDR) ofera o cale excelenta
pentru a stoca si a accesa informatii complexe. Cele mai populare SGBDR-uri sunt
Oracle, Infomix, Microsoft's SQL Server, IBM's db2 si SGBD-uri "open-souce":
MySQL, Postgres si Interbase.

Baze de date relationale

Tabele
Tabela are un nume, un numar de coloane corespunzatoare tipurilor de informatii si linii
corespunzatoare inregistrarilor din tabele. De exemplu:
CLIENTI
ID Nume Adresa Oras
1 Julie Smith 25 Oak Street London
2 Alan Wong 47 Haines Avenue New York
3 Michelle Arthur 357 North Road Chicago

Coloanele au un nume unic si contin informatii diferite. Fiecare are un tip de date asociat
(de exemplu, integer pentru 'ID' si string pentru 'Nume', 'Adresa' si 'Oras'). Coloanele mai
sunt numite campuri sau atribute.
Liniile reprezinta cate un client diferit in tabela noastra. Mai sunt numite inregistrari sau
tupluri.
Valorile specificate la intersectia coloanelor cu liniile trebuie sa aiba tipul de date
corespunzator.
Cheile reprezinta o cale de a identifica fiecare inregistrare in parte. Baze de date care au
mai multe tabele folosesc o cheie primara sau o cheie externa(Primary Key sau Foreign
Key ) ca referinta de la o tabela la alta.

Daca adaugam o noua tabela cu comezile facute de clienti, putem face legatura intre cele
doua tabele pe baza campului comun 'ID' care este PK in tabela 'clienti' si FK in
'comenzi':

COMENZI
ComID ID Cantitate
1 3 30.66
2 1 23.00
3 2 5.00
4 4 40.87

Relatii
Exista 3 tipuri de relatii intr-o BD relationala:

 Relatie una-la-una - Exista cate una/unul din fiecare in relatie (dcaca am fi pus
adresele intr-o tabela separata intre CLIENTI si ADRESE ar fi existat un
corespondent pentru fiecare inregistrare).
 Relatie una-la-mai-multe - O linie dintr-o tabela e legata la mai multe linii din alta
tabela (un client ar putea face mai multe comenzi).
 Relatie mai-multe-la-mai-multe - Mai multe linii din tabela 1 sunt legate la mai
multe din tabela 2 (de exemplu, in cazul a doua tabele, CARTI si AUTORI, o
carte ar putea fi scrisa de doi coautori, fiecare dintre ei mai avand si alte carit
scrise).

Sfaturi de proiectare pentru baze de date

1. Gandeste-te la obiectele reale pe care le modelezi.

2. Evita sa stochezi informatiile care sunt redundante.
3. Foloseste valori "atomice" in coloanele tabelei (adica nu memora valori multiple
in cadrul aceluiasi camp al tabelei).
4. Alege chei foarte sensibile, care pot identifica unic o inregistrare.
5. Gandeste-te la ce vrei sa ceri prin interogari din baza de date si include informatii
aditionale.
6. Evita sa folosesti prea multe atribute nule (coloane din inregistrari fara continut).

Instalare MySQL, PHP si Apache

 Instalare MySQL sub Windows
 Instalare Apache sub Windows
 Instalare PHP sub Windows
 Instalare MySQL sub Linux
 Instalare PHP/Apache sub Linux
MySQL este disponibil pentru Windows, Linux si alte variante de Unix. Se poate copia
de la site-ul MySQL: [Link]. Versiunea Windows are un nume asemanator cu
mysql-shareware-x_xx_xx-[Link] (unde 'x' este versiunea. Download-ul RPM este cel
recomandat pentru versiunea Linux.

Pachetul MySQL este compus din:

 Serverul MySQL : Este inima MySQL-ului (programul care se ocupa cu bazele

tale de date).
 Programe-client MySQL: Cel mai folosit este [Link] care ofera o interfata
prin care se pot inteorga bazele da date pentru a afla informatiile dorite din baza
de dateMySQL comes with many client programs. The one with which we'll be
dealing a lot is called mysql (note: smallcaps). This provides an interface through
which you can issue SQL statements and have the results displayed.
 Libraria-client MySQL: Ajuta la scrierea programelor client in C.

Diferenta dintre MySQL si mysql

MySQL se refera la toata pachetul de distributie MySQL, in timp ce mysql este doar un
program-client.

Instalare pe Windows

Trebuie sa ai instalat protocolul TCP/IP (e pe CD-ul cu Windows) si libraria

Winsock 2 (Windows 95 nu-l are!!) ca sa mearga MySQL.

Pentru a instala pachetul copiat, dezarhiveaza-l intr-un director temporar si ruleaza

[Link]. Implicit MySQL-Windows se va instala in `C:\mysql'. Daca vrei sa-l instalezi
in alt director, instaleaza-l mai intai in `C:\mysql' si apoi muta-l unde vrei, trebuind apoi
sa specifici programului cand il startezi noua cale cu comanda:
C:\> D:\programs\mysql\bin\mysqld --basedir D:\programs\mysql

Copiaza fisierul ‘C:\mysql\[Link]’ in ‘C:\[Link]’ si modifica optiunile implicite

ale serverului dupa preferinte (vezi sectiunea de "Administrare MySQL").

Instalarea e acum completa. Pentru a testa daca MySQL merge incepe o sesiune MS-DOS
(in casuta Start menu-Run tasteaza command) in directorul c:\mysql\bin si scrie
urmatoarea comanda:
mysqld-shareware --standalone
Se va porni serverul MySQL. Tasteaza mysql si promptul se va schimba in mysql.
Tasteaza show databases si ar trebui sa obtii urmatorul rezultat:

Acum vei adauga o parola pentru utilizatorul root in locul utilizatorului anonim care
poate fi folosit de oricine:

C:\> C:\mysql\bin\mysql mysql<

mysql> DELETE FROM user WHERE Host='localhost' AND User='';
mysql> QUIT
C:\> C:\mysql\bin\mysqladmin reload
C:\> C:\mysql\bin\mysqladmin -u root password your_password

Acum, pentru a opri serverul vei folosi comanda:

C:\> mysqladmin --user=root --password=your_password shutdown
Tasteaza quit la promptul mysql.

Windows 95/98
Versiunea de MySQL pentru Windows 95/98 are doua versiuni de servere: mysqld si
mysqld-opt, optimizat pentru procesoare Pentium. Poti starta serverul cu comanda:
C:\mysql\bin\mysqld-opt
si-l poti opri cu comanda:
C:\mysql\bin\mysqladmin -u root shutdown

Windows NT/Win2000
Serviciul e instalat cu numele MySQL si trebuie pornit din Services Control Manager
(SCM) Utility din Control Panel. Poti configura serverul MySQL sa relueze ca serviciu
prin:
C:\mysql\bin\mysqld-nt -install
Acum poti porni/opri serviciu cu:
NET START mysql M
NET STOP mysql
Daca nu vrei sa rulezi MySQL ca serviciu, il poti porni cu comanda:
C:\> C:\mysql\bin\mysqld-nt --standalone

In continuare, vei instala serverul APACHE.

Este recomandat sa download-ezi versiunea de Apache pentru Windows cu extensia '.exe'

de la [Link] daca esti incepator si nu vrei sa compilezi codul sursa. In continuare, tot
ce trebuie sa faci e sa dai click pe fisierul executabil si Apache se va instala pe disc.

Poti rula Apache de la o fereastra-consola sau ca un serviciu Windows. Pentru a rula

Apache de la consola alege optiunea 'Start Apache as console App' din grupul Apache din
meniul Start. Se va deschide o fereastra de consola care va ramane activa pana vei opri
serverul Apache alegand 'Shutdown Apache as Console App' sau apasand CTRL+C in
ferestra de consola sau deschizand alta fereasta MS-DOS si tiparind:
C:\Program Files\Apache Group\Apache> apache -k shutdown

Apache va "asculta" protul 80 dupa ce va fi pornit. Pentru a te conecta la server, deschide

browser-ul de Internet si scrie una din adresele:
[Link]
[Link]
Se va deschide o pagina HTML de bun-venit si informatii despre Apache. Daca nu se
intampla nimic si apare o eroare deschide fisierul [Link] din direcotrul logs al Apache
si vei alfa ce a mers rau. Daca ai schimbat portul (altul decat 80) adauga :numar_port
dupa adresa de URL

La drum cu PHP...
Copiaza distributia PHP de la [Link] si dezarhiveaza pachetul in directorul 'C:\php4\'.
Din acest director copiaza fisierele [Link] and [Link] in 'c:\windows\
system'. Apoi, redenumeste [Link]-dist in [Link] and muta-l in directorul in care e
instalat Windows-ul ('c:\windows\'). Deschide acest fisier cu Notepad si caua sirul de
caractere "extensio_dir". Schimba valoarea implicita cu 'C:\php4'. Daca ai nevoie de
extensii speciale (de exemplu, pentru grafice) sterge comentariile (caracterul ;) din fatza
randului din [Link] de genul:
;extensions=php_**.dll

Acum ve trebui sa faci legatura intre PHP, Apache si MySQL. Du-te in directorul in care
ai instalat Apache, cauta fisierul '[Link]' din directorul '\conf' si adauga aceste linii:

ScriptAlias /php4/ "c:/php4/"

AddType application/x-httpd-php4 .php
AddType application/x-httpd-php4 .php3
AddType application/x-httpd-php4 .php4
AddType application/x-httpd-php4 .phtml
Action application/x-httpd-php4 "/php4/[Link]"

Si gata. Porneste server-ul Apache. Creaza un fisier in Notepad cu continutul:

<?php
phpinfo()
?>
Salveaza-l ca [Link] in "\htdocs" din directorul Apache (locul in care va trebui sa pui
toate scripturile PHP ca sa mearga). Apoi deschide-l in browser:
[Link]
Se va obtine un fisier HTML cu informatii despre configirarea PHP.
PHP poate fi folosit si fara server-ul Apache prin rularea din linia de comanda (Command
Prompt) cu parametru un fisier *.php:
C:\php4\php [Link]

Pentru a folosi PHP cu Apache, se vor copia toate fisierele *.php in directorul htdocs
din folder-ul /Apache Group/Apache.

Instalare pe Linux

Linux Varianta 1 - Distributia RPM MySQL

Este metoda recomandata de a instala MySQL pe Linux. Fisierele RPM care te
intereseaza sunt:

[Link] - Server-ul MySQL.

[Link] - Programele-client MySQL.
[Link] - Codul sursa al tutoror RPM-urilor.

Intra ca superuser (Tasteaza "su" la prompt si da parola de root). Intra in directorul cu

RPM-urile copiate si tasteaza:
shell> rpm -ivh "mysql_file_name.rpm"
Acum vom stabili o parola pentru utilizatorul root:
shell> mysqladmin -u root password parola_ta
Pentru a starta clinetul mysql:
shell> mysql -u root -p
Vei fi intrebat parola. Tasteaz-o (e cea pe care ai pus-o in loc de 'parola_ta' in comanda
de mai sus). Daca nu esti intrebat de parola intra in '/etc/rc.d/init.d/' si tasteaza ./mysql
start si acum porneste serverul mysql ca mai sus.
Odata ce clientul mysql a pornit vei primi promptul mysql>. Tasteaza:
shell> show databases;
Rezulatul va fi unul similar cu:

Linux Varianta 2 - distributia sursa (Doar pentru avansati !!!)

Copiaza fisierul .[Link] de la [Link] Dezarhiveaza-l cu:
gunzip [Link] tar xf [Link]
Se va crea un director cu numele distributiei. Intra in acest director cu 'cd'. Comenzile pe
care le vei folosi pentru a instala distributia sursa sunt:
shell> groupadd mysql
shell> useradd -g mysql mysql
shell> gunzip < [Link] | tar -xvf -
shell> cd mysql-VERSION
shell> ./configure --prefix=/usr/local/mysql
shell> make
shell> make install
shell> scripts/mysql_install_db
shell> chown -R root /usr/local/mysql
shell> chown -R mysql /usr/local/mysql/var
shell> chgrp -R mysql /usr/local/mysql
shell> cp support-files/[Link] /etc/[Link]
shell> /usr/local/mysql/bin/safe_mysqld --user=mysql &
Primul pas acum e sa rulezi confiruarea serverului cu comanda:
./configure --prefix=/path/to/installation
Apoi:
make
make install

Configurare post-instalare

Se vor instala tabelele de grant (cu drepturile de utilizatori) si se porneste server-ul cu

comenzile:
- pt. distributia sursa:
shell> ./scripts/mysql_install_db
shell> cd mysql_installation_directory
shell> ./bin/safe_mysqld --user=mysql &
- pt. distrubita binara(nu cea cu pachete RPM sau pkg:
shell> cd mysql_installation_directory
shell> ./bin/mysql_install_db
shell> ./bin/safe_mysqld --user=mysql &
Testeaza acum daca serverul e pornit si functioneaza:
shell> BINDIR/mysqladmin version
shell> BINDIR/mysqladmin variables

PHP si Apache pe Linux

Pe UNIX PHP e instalat ca o extensie a Apache. Deci instalarea lor se va face simultan.
Incepe prin dezarhivarea pachetelor PHP si Apache.
gunzip apache [Link] tar xf [Link]

gunzip [Link] tar xf php-4.02

Foloseste 'cd' pentru a ajunge in directorul in care ai dezarhivat Apache si ruleaza
'configure' pentru a specifica calea in care se va instala Apache:
./configure --prefix=/path/to/apache
Acum, revino la PHP si dupa ce-ai rulat 'configure' da-i comenzile:
make
make install
In directorul Apache ruleaza din nou 'configure':
./configure --prefix=/path/to/apache
--activate-module=src/modules/php4/libphp4.a
Apoi:
make
make install
Apache e instalat acum in directorul specificat. Ultimii pasi: in directorul PHP copiaza
fisierul [Link] in /usr/local/lib/[Link] si deschide fisierul '[Link]' din '/conf' al
Apache si sterge comentariul (semnul ;) din fata liniei:
AddType application/x-httpd-php .php
Starteaza Apache din directorul '/bin':
./apachectl start

Utilizarea server-ului MySQL

 Conectarea la server
 Privilegiile utilizatorilor
 Crearea bazelor de date si a tabelelor
 Tipuri de campuri
 Inserarea de inregistrari
 Actualizarea inregistrarilor
 Extragerea inregistrarilor cu SELECT
 Join-uri intre tabele
 Stergerea inregistrarilor si a tabelelor
 Crearea indecsilor
 Modificarea tabelelor

Conectarea si deconectarea de la server

Primul lucru pe care trebuie sa-l observi este ca fiecare comanda data server-ului se
termina cu ';'. Fara aceste terminator nu se va intampla nimic. Asta inseamna ca poti avea
linii noi in mijlocul unei comenzi sau poti 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 vrei sa nu mai executi o comanda pe care ai scris-o partial, o poti 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 '.
"> Astepta continuarea unui sir de caractere care incepe cu ".

Este important de stiut ce inseamna prompt-urile '> and "> , deoarece daca din
greseala introduci un sir neterminat, orice altceva ce vei tasta (chiar si quit) nu va fi luat
in seama.

Pentru a te conecta la server, de obicei esti nevoit sa dai numele de utilizator si parola:

shell> mysql -h host -u user -p

Enter password: ********

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

conecteaza la server. -h specifica numele gazdei (host) la care te vei conecta (doar daca
te conectezi pe alta statie de lucru). -u specifica numele tau de utilizator ('root' daca ai
MySQL pe propria statie, sau alt nume dat de administrator..). -p spune server-ului ca te
vei conecta folosind o parola.
shell> mysql -h host -u user -p
Enter password: ********
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 459 to server version: 3.22.20a-log

Type 'help' for help.

mysql>

In functie de cum ai instalat si configurat MySQL, ai putea fi lasat sa te conectezi la

server fara nume de utilizator sau parola:
shell> mysql

Dupa ce te-ai conectat cu succes la server te poti deconecta cu comanda QUIT sau
apasand CTRL+D
mysql> QUIT

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 sofisticat.
Cand vei crea un utilizator, ii vei 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;
Crearea tabelelor

Vom crea o baza de date angajati pe care o vom folosi si in alte ocazii:
Pe Windws:
create database angajati;
Sa vedem cate baze de date sunt in sistem:
show databases;

Sub Linux:
Trebuie sa devii superuser si sa tastezi parola de root:
create database angajati;
GRANT ALL ON angajati.* TO marius@localhost IDENTIFIED BY "eagle"
Ultima conanda acorda toate drepturile asupra tabelei angajati utilizatorului Marius.
Iesi cu QUIT si intra din nou cu nume de utilizator de aceasta data:
mysql -u user_name -p
Ar trebui sa apara ca in continuare:
[marius@localhost marius]$ mysql -u marius -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is X to server version: [Link]

Deschiderea unei baze de date se poate face cu una din metodele:

 Specificand nume bazei de date la inceputul sesiunii:

 mysql angajati (sub Windows)
 mysql angajati -u user1 -p (sub Linux)
 Cu comanda USE: mysql>USE angajati;
 Specificand direct numele bazei de date la prompt:

mysql>\u 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 ai selectat baza de date angajati dai urmatoarea comanda:

mysql> CREATE TABLE angajati_data

-> (
-> emp_id int unsigned 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 poia 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 camp ID). 'primary key' speciofica ca acel
camp va fi indexat (fiecare valoare va fi unicat).

Tipuri de campuri

Cele trei tipuri de baza pentru campuri sunt: numeric, data si timp si sir de
caractere(string). Cand alegi un anumit tip sau subtip, poti specifica si lungimea maxima
admisa (M, maxim 255).

Tipurile de date numerice

Pentru numerele in virgula flotanta (float), poti specifica cu D numarul de cifre dupa
puctul zecimal. Pentru numerele intregi poti 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
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: CHAR (fixed length character) si VARCHAR
(variable length character), siruri TEXT si BLOB pentru siruri lungi/date binare si sirurile
SET si 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)
TEXT 216-1
MEDIUMBLOB 224-1
(16.777.215)
MEDIUMTEXT 224-1
LONGBLOB 232-1
([Link])
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 include 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)
Inserarea inregistrarilor in tabele

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@[Link]");
Query OK, 1 row affected (0.00 sec)

Daca vrei sa inserezi unul dintre urmatoarele caractere intr-un camp de tip text, trebui sa-i
adaugi inainte un caracter backslash(\):

‘ (apostrof) :\'
“ (ghilimele):\"
\ (backslash) :\\
% (procent) :\%
_ (liniuta de subliniere) :\_

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

Extragerea informatiilor dorite din tabela

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';

< mai mic amount<60.00

>= mai mic sau egal amount>=60.00
<= mai mic sau egal amount<=60.00
!= sau diferit quantity != 0
<>
IS NOT valoare nenula
NULL
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%";

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%';

Alte exemple:
SELECT f_name, l_name, title from
-> angajati_data where title
-> IN ('Web Designer', 'System Administrator');

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;

Sortarea datelor
Inregistrarile extraswe 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;

Limitarea numarului de inregistrari extrase

SELECT f_name, l_name from

angajati_data LIMIT 5;

+--------+----------+------+
| 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;

Folosirea clauzei DISTINCT permite listarea doar a valorilor distincte din baza de date
pentru fiecare camp in parte.

Functii agregat

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)

Clauza GROUP BY permite gruparea informatiilor similare. Deci, pentru a lista toate
functiile unice din tabela:

select title from angajati_data GROUP BY title;

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)

Extragerea inregistrarilor din mai multe tabele (JOIN-uri)

De multe ori, ca sa raspunzi la o intrebare trebui sa extragi date din mai multe tabele. De
exemplu, pentru a afla ce clienti au facut comenzi luna 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 '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;

Stergerea inregistrarilor din tabela

DELETE FROM table
[WHERE condition] [LIMIT number]

delete from customers where customerid=5;

Stergerea tabelelor
DROP TABLE angajati_data;

Stergerea unei baze de date

DROP DATABASE database;

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 poti 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)),
index index_on_text (text_column(200))
);
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, and Heap alese dupa
sintaxa:

create table nume type=tip_tabela( nume_col coloana attribut );

Heap-urile sunt tabele hash temporare rezidente in memorie. Tabelele BDB sunt folosite
la tranzactii, iar tabelele ISAM nu mai sunt recomandate. Deci alegerea implicita
MyISAM este cea mai buna si nu trebuie sa-ti faci grji ca trebui 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):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_name test10 drop primary key

Limbajul MySQL-functii si comenzi

 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 ai
aflat in Utilizare MySQL), tipuri de date si functii de care vei avea nevoie ca sa folosesti
MySQL eficient.

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 vrei sa incluzi 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.

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 poti 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 poti 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.
Poti 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;

Cuvinte rezervate

action add aggregate all

alter after and as
avg_row_le auto_increme
asc avg
ngth nt
between bigint bit binary
blob bool both by
cascade case char character
change check checksum column
columns comment constraint create
current_da current_ti current_time
cross
te me stamp
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
distinctro
distinct double drop
w
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_prior
having heap hour
ity
hour_secon
hour_minute hosts identified
d
ignore in index infile
inner insert insert_id int
integer interval int1 int2
int3 int4 int8 into
if is isam join
last_insert_
key keys kill
id
leading left length like
lines limit load local
lock logs long longblob
low_priori
longtext max max_rows
ty
match mediumblob mediumtext mediumint
minute_secon
middleint min_rows minute
d
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
rlike row rows second
select set show shutdown
sql_big_ta sql_big_sele
smallint soname
bles cts
sql_low_priority_ sql_log_of sql_log_up sql_select_l
updates f date imit
sql_big_re sql_warnin straight_joi
sql_small_result
sult gs n
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
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)
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)
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 |
+ +
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)
%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')

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

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
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
}

Administrarea MySQL
 Administrarea utilizatorilor
 Controlul accesului
 Comezile GRANT si REVOKE
 Backup-ul bazelor de date
 Securitatea datelor
 Optimizarea MySQL

Administrarea oricarui sistem de gestiune a bazelor de date relationale (SGBDR) necesita

putina munca. Fiecare sistem are propriile metode pentru administrare si propriile
dificultati cand vine vorba de adaugarea si stergerea de conturi ale utilizatorilor, backup
si asigurarea securitatii. Administarea server-ului MySQL nu este dificila per ansamblu,
dar poate speria la inceput.

Administrarea utilizatorilor

Tabelele de grant
Drepturile utilizatorilor MySQL sunt stocate in cateva tabele care sunt create automat la
instalarea MySQL. Aceste tabele apartin bazei de date mysql:

mysql> use mysql

Fiecare dintre aceste tabele corespunde controlului unui nivel de acces. Poti crea un
oricati utilizatori care pot accesa MySQL de pe diferite gazde. Pentru fiecare combinatie
utilizator/gazda, acorzi acces la o intreaga baza de data, la anumite tabele, sau la anumite
coloane dintr-o tabele. Aditional, aceste tabele acorda privilegii de administrare.
Utilizatorilor le poate fi dat dreptul de a adauga/sterge baze de date sau de a acorda altor
utilizatori drepturi de administare.

In practica, nu ar trebui sa acorzi mai multe drepturi decat e necesar pentru a proteja
datele de curiosi sau de incompetenti. Pentru asta trebuie sa stii ca drepturile sunt
acordate intr-un mod ierarhic. Cele acordate pe tabela user sunt universale: daca un
utilizator are privilegiu de stergere(drop) in tabela user, acesta poate sterge orice tabela
din rocie baza de date din MySQL. Tabela db acorda privilegii asupra unei intregi baze
de date. Pentru o tabela/set de tabele foloseste tables_priv. Tabela columns_priv
acorda drepturi asupra unor anumite colobne dintr-o tabela.

Tabela user
Orice utilizator care vrea sa lucreze in MySQL trebuie sa fie inscris in acesta tabela.
Drepturile pot fi acordate in alta parte, dar fara o inscriere aici, utilizatorului nu i se va
permite conectarea la server.

mysql> show columns from user;

MySQL identifica un utilizator dupa combinatia user-host. Prin urmare, un utilizator

poate avea cate un set de drepturi diferite pentru fiecare gazda (host) pe care o foloseste
pentru a se conecta la MySQL. Drepturile setate pe Y (yes) sunt acodate pentru toate
tabele din orice baza de date. Alte drepturi:
- File_priv acorda dreptul de a scrie si citi fisiere de pe disc.
- process_priv acorda dreptul de a vedea si de a termina toate comenzile si threrad-rile
in curs de executie(poti vedea ce fac si ce tasteaza ceilalti utilizatori !!).
- Grant_priv da dreptul de a putea acorda mai departe privilegiile proprii altor
utilizatori.
- Reload_priv e folosit, in special pentru a face comenzi flush
- Shutdown_priv da dreptul de a opri server-ul folosind mysqladmin shutdown.

Tabela db

mysql> show columns from db;

Drepturile specificate aici merg doar pentru baza de date specificate in coloana
db_column.

Tabelele tables_priv si columns_priv

Ofera drepturi asupra unei tabele sau asupra unor coloane dintr-o tabela.

mysql> show columns from tables_priv;

Controlul accesului

MySQL foloseste tabelele de privilegii pentru a determina ce are si ce nu are un utilizator

dreptul sa faca in doi pasi:
1. Verificarea conexiunii: MySQL verifica daca ai voie sa te conectezi la server
bazandu-se pe numele de utilizator (blank insemna orice utilizator), numele de
gazda si pe parola. Pentru numele gazdei poti folosi caracterul wildcard '%' ca
semnificand orice gazda.
2. Verificarea cererii: MySQL verifica in toate tabele de drepturi daca ai drepturile
necesare pentru a obtine informatiile dorite.

Comenzile GRANT si REVOKE

Tabele descrise mai sus sunt tabele normale MySQl si pot fi modificate cu comenzile
invatate. De exemplu, pentru a crea un nou utilizator:
INSERT INTO user (Host, User, Password, Select_priv, Insert_priv,
Update_priv, Delete_priv, Create_priv, Drop_priv, Reload_priv,
Shutdown_priv, Process_priv, File_priv, Grant_priv, References_priv,
Index_priv, Alter_priv) VALUES (‘localhost’, ‘juan’, ‘password’, ‘N’,
‘N’, ‘N’, ‘N’, ‘N’, ‘N’, ‘N’, ‘N’, ‘N’, ‘N’, ‘N’, ‘N’, ‘N’, ‘N’)
Nu este insa ce si-ar dori sa fac administratorul de fiecare data. Din fericire, MySQL
ofera cateva comenzi care fac lucrul cu utilizatorii mult mai usor:

GRANT
GRANT privilegii [coloane]
ON obiect
TO utilizator [IDENTIFIED BY ‘parola’]
[WITH GRANT OPTION]
Niveluri de drepturi
grant all on *.* Acorda drepturi universale
Acorda drepturi asupra tuturor tabelelor din baza
grant all on database.*
de date
grant all on database.table_name Drepturi pentru o singura tabela
grant all(col1, col2) on
Drepturi pentru anumite coloane dintr-o tabela
database.table_name

mysql> grant all on guestbook.* to ion@localhost identified by

“parola1”;
Prima parte a comenzii poate fi all sau alta optiune din tabela user. Partea a doua a
comenzii (on guestbook) arata unde se vor aplica drepturile (vezi tabelul de mai sus).
Partea a treia arata cui i se acorda drepturile (utilizator@gazda), iar ultima parte arata
parola cu care este identificat utilizatorul.
grant select, update, insert on [Link] to adi@localhost
identified by “parola2”;
Acesta comanda permite lui adi sa vada, sa modifice, sa actualizeze si sa insereze
inregistrari in tabela 'guestbook' din baza de date 'guestbook2k'.
grant select, update (nume, email) on [Link] to
monica@localhost identified by “Mel12068”;
Monica poate vedea si actualiza doar campurile 'nume' si 'email'.
grant all on *.* to marius@localhost identified by “xxx456”;
Marius are drepturi depline (poate chiar acorda privilegii altor utilizatori).
REVOKE

Daca vrei sa anulezi drepturile acordate unui utilizator poti folosi comanda REVOKE:
REVOKE privilegii [(coloane)]
ON item
FROM utilizator

Comanda revoke Shutdown on . from cosmin@localhost; revoca dreptul de

shutdown al lui Cosmin. Daca vrei sa stergi un utilizator de tot trebuie sa-l stergi din
tabela 'user':
delete from user where user=’user’ and host=’host’

Afisarea drepturilor
Din versiunea 3.23.4 MySQL a introdus comanda show grants care permite vizualizarea
drepturilor acordate la un moment dat:

mysql> show grants for jayg@localhost;

+------------------------------------------------------------- +
| Grants for ion@localhost |
+------------------------------------------------------------- +
| GRANT ALL PRIVILEGES ON testul1.* TO ‘ion’@’localhost’ |
+------------------------------------------------------------- +
1 row in set (0.00 sec)

Reincarcarea drepturilor
MySQL citeste automat tabelele de privilegii cand e pornit si cand sunt date comenzi
GRANT sau REVOKE. Modificarile facute manual tabelelor de drepturi nu iau efect
decat daca se restarteaza MySQL. Ca sa functioneze aceste modificari reincarca tabelele:
flush privileges
sau
mysqladmin flush-privileges
sau
mysqladmin reload

Backup-ul bazelor de date

Pentru a face un backup complet al bazelor de date:

mysql> mysqldump --tab=/cale/director --opt --full
sau
mysql> mysqlhotcopy database /path/director
Poti, de asemenea copia toate fisierele tabelelor (`*.frm', `*.MYD', and `*.MYI' files) cat
timp serverul nu actualizeaza nimic. Poti face si backup-uri selective cu SELECT * INTO
OUTFILE 'nume_fisier' FROM nume_tabela si sa restaurezi datele cu LOAD DATA
INFILE 'nume_fisier' REPLACE ... Pentru a evita inregistrarile duplicat (inregistrarile
noi le inlociesc pe cele mai vechi daca sunt identice in cazul comenzii REPLACE) ai
nevoie de o cheie primara sau de o cheie unica.
Securitatea in MySQL

Securitatea e foarte importanta, in special cand vei conecta baza ta de date MySQL la
site-ul Web. Cand rulezi MySQL ia in considerare urmatoarele sfaturi:
 Nu da nimanui acces la tabela user !
 Invata sistemul de privilegii al MySQL ! Tasteaza mysql -u root. Daca te poti
conecta fara sa ti se ceara o parola, oricine poate face acelasi lucru. Vezi, in
pagina de instalare cum se poate pune parola de root pe sever.
 Nu folosi parole din dictionar deoarece exista programe care le pot sparge!
Foloseste initialele cuvintelor dintr-o propozitie (de exemplu aaum 'Ana are un
miel') sau combinatii de pe tastatura (in loc de stefan-dyrgsm, adica o litera spre
dreapta de pe tastatura).
 Investeste intr-un firewall.
 Foloseste parole pentru toti utilizatorii MySQL si ai grija in ce fisiere script le
memorezi. Poti cripta parolele cu functiile PASSWORD() sau MD5().
 La conectarea pe Web, ar trebui sa creezi un utilizator special numai pentru Web
(de exemplu, sa aiba doar drepturi de SELECT pe tabela cu produse si de
INSERT pe tabela cu comenzile facute).
 Daca utilizatorii care folosesc formularele de pe Web tasteaza date confidentiale,
trebuie sa folosesti SSL (Secure Socket Layer) pentru ca altfel datele vor fi
transmise spre server in fomatul text.

Optimizarea MySQL

 Optimizeaza tabele care pot deveni fragmentate dupa multe actualizari si

modificari cu OPTIMIZE TABLE nume_tabela
 Alege cel mai potrivit si cel mai scurt tip de date pentru campurile din tabele.
 Foloseste indecsi cand sunt necesari pentru a face interogarile mai rapide.
 Foloseste valori implicite in comanda INSERT
 Invata sa folosesti comanda EXPLAIN SELECT.. care arata ce se va intampla in
cazul unei interogari.
 Nu uita ca privilegiile sunt citite la fiecare interogare. Deci, simplifica cat mai
mult privilegiile acordate.
 Nu uita ca exista mai multe tipuri de tabele care pot fi create cu CREATE TABLE
nume TYPE=tip (MyISAM-implicit, HEAP-temporar, BDB-sigure pentru
tranzactii).

Configurarea MySQL
 Schimbarea setului de caractere
 Mesaje de eroare in romana
 Utilitarele MySQL
 mysql
 mysqladmin
 mysqldump
 mysqlimport

Schimbarea setului de caractere

Implicit, MySQL foloseste setul de caractere ISO-8859-1 Latin1 cu sortarea in orinea
limbii suedeze. Pentru a schimba acest set implicit de caractere, foloseste comanda:
mysql> ./configure --with-charset=CHARSET
unde CHARSET poate fi big5, cp1251, cp1257, czech, danish, dec8, dos, euc_kr,
gb2312, gbk, german1, hebrew, hp8, hungarian, koi8_ru, koi8_ukr, latin1, latin2, sjis,
swe7, tis620, ujis, usa7, or win1251ukr.

Pentru a adauga un nou set de caractere decide daca setul e unul simplu sau complex (are
nevoie de sau nu de suport multi-byte) si:
[Link] simplu:

1. Adauga SETUL la sfarasitul fisierului `sql/share/charsets/Index' si atribuie-i un

numar.
2. Creaza un fisier `sql/share/charsets/[Link]'. (Foloseste ca model
`sql/share/charsets/[Link]').
3. Adauga numele 'SETUL' la listele CHARSETS_AVAILABLE and
COMPILED_CHARSETS din '[Link]'.

[Link] complex:
1. Creaza fisierul `strings/ctype-SETUL.c'.
2. Adauga SETUL la sfarasitul fisierului `sql/share/charsets/Index' si atribuie-i un
numar.
3. Plaseaza un comentariu in partea de sus a fisierului creat la 1. :
4. /*
5. * This comment is parsed by configure to create ctype.c
6. * .configure. number_MYSET=MYNUMBER
7. * .configure. strxfrm_multiply_MYSET=N
8. * .configure. mbmaxlen_MYSET=N<
*/
9. Creaza urmatoarele functii: my_strncoll_MYSET(), my_strcoll_MYSET(),
my_strxfrm_MYSET(), my_like_range_MYSET().
10. Adauga numele 'SETUL' la listele CHARSETS_AVAILABLE and
COMPILED_CHARSETS din '[Link]'.

Mesaje de eroare in alte limbi

mysqld poatge da mesaje de eroare in urmatoarele limbi: ceha, daneza, engleza (implicit),
estoniana, franceza, germana, greaca, italiana, japoneza, koreana, maghiara, norvegiana,
norvegiana-ny, olandeza, poloneza, portugheza, romana, rusa, slovaca, spaniola si
suedeza.

Pentru a porni mysql in limba romana:

shell> mysqld --language=romanian
sau
shell> mysqld --language=/usr/local/share/romanian
Pentru a actualiza fisierul cu mesaje de eroare, modifica `[Link]' si executa:
shell> comp_err [Link] [Link]

Utilitarele MySQL

Sunt niste programe-client care se folosesc pentru a construi, configura si intretine bazele
de date.
myisamchk
Descrie, verifica si optimizeaza tabele.
make_binary_release
Face un pachet binar cu dstrubutia MySQL.
msql2mysql
Converteste programe mSQL in MySQL.
mysql
mysqlaccess
Verifica privilegii de acces pentru o combinatie de gazda-utilizator-baza de date.
mysqladmin
mysqlbug
Genereaza un raport cu defectge (bugs) gasite in MySQL.
mysqld
Daemon-ul SQL.
mysqldump
mysqlimport
mysqlshow
Afiseaza informatii despre baze de date, tabele, coloane, indecsi.
mysql_install_db
Creaza tabelele de privilegii.
replace
Program utilitar care inlocuieste un sir de caractere cu al sir dintr-un anumit fisier.

shell> replace a b b a -- fisier1 fisier2 ...

safe_mysqld
Porneste daemon-ul mysqld cu unele optiuni de siguranta.

[Link]

Este interfata in linie de comanda a MySQL-ului si-ti permite sa rulezi comenzi SQL sau
comenzi specifice MySQL. Sintaxa este:
mysql [options] [database name] [<inputfile] [>outputfile]
Tasteaza help pentru a vedea unele facilitati ale mysql:
help (\h) Afiseaza acest text
? (\h) Sinonim pentru ‘help’
clear (\c) "Curata" ecranul
connect (\r) Reconectare la server
edit (\e) Comanda edit cu $EDITOR
exit (\q) Iesire din mysql
go (\g) Trimite comanda la server
ego (\G) Trimite comanda si afiseaza rezultatul vertical
print (\p) Tipareste comanda curenta
quit (\q) Iesire din mysql
rehash (\#) Reconstruieste hash-ul
status (\s) Status info
use (\u) Foloseste o baza de date

** nou in versiunea 3.23:

source (\.) Executa un fisier script .sql

Alte optiuni pentru programul-client mysql:

-? --help Help
-B --batch Afiseaza rezultatele cu TAB ca separator.
-D, --database=.. Baza de date folosita
e --execute=... Executa comanda si iese
-E --vertical Afisare veritcala a rezultatelor
-f --force Continua chiar daca apar erori
-h --host=... Conectare la gazda specificata
-H --html Produce iesiri in format HTML.
-L --skip-line-
numbers Nu afiseaza numere de linii in cazul erorilor
-n --unbuffered Goleste buffer-ul dupa fiecare interogare
-p[password]
--password[=...] Parola care va fi folosita
-P --port=... Portul TCP/IP folosit
-q --quick Tipareste rezultatul linie cu linie
-r --raw Scrie numele de campuri cu tot cu caracterele de
escape
-t --table Iesiri in formatul tabeleiOutput in table format.
This is default in
non-batch mode.
-u --user=# Utilizatorul care intra nu e cel curentUser for
login if not current user.
-w --wait Asteapta si reincearca conectarea

mysqladmin

Este utilitarul pentru sarcini administrative. Sintaxa:

mysqladmin [OPTIONS] command command...
unde comenzile pot fi:
create databasename
drop databasename
extended-status Mesaj extins despre status-ul server-ului
flush-hosts
flush-logs
flush-tables
flush-privileges Reincarca tabelele de privilegii
kill id,id,... Termina thread-urile mysql
password newpassword Schimba parola
ping Verifica daca mysgld e pornit
processlist Lista proceselor active
reload Reincarca tabelele de privilegii
refresh
shutdown
status
variables Afiseaza variabilele disponibile
version Versiunea MySQL
slave-start Starteaza thread-ul slave
(nou in v3.23)
slave-stop Opreste thread-ul slave.
(nou in v3.23)
-? --help
-# --debug=...
-f --force Continua chiara daca apar erori
-h --host=#
-p[...] --password[=...]
-P --port=...
-I --sleep=sec Executa comenzile in continuu cu o
pauza intre
-r --relative Arata diferentele obtinute
-s --silent Iesire daca nu e permisa conecatarea
-t --timeout=... Timeout pentru conectare
-w --wait[=retries]
-W --pipe
-E --vertical

mysqldump

Este un utilitar pentru mutarea/stergerea informatiilor din tabele. Sintaxa:

mysqldump [OPTIONS] database [tables]
Folosire (pentru backup):
mysqldump --opt mydatabase > [Link]
Poti citi inapoi in MySQL informatiile cu:
mysql mydatabase < [Link]
Optiuni:
-? --help
-a --all
--add-locks Adauga LOCK TABLES inainte si
UNLOCK
TABLE dupa fiecare dump
--add-drop-table
--allow-keywords
-c --complete-insert
--delayed
-F --flush-logs
-f --force
-h --host=..
-l --lock-tables
-t --no-create-info
-d --no-data
--opt
-p[...] --password[=...]
-P --port=port_num
-q --quick
-T path-to- --tab=path-to- Creaza un fisier .sql si un
fisier .txt cu continutul
some-directory, some-directory tabelei
--fields-terminated-by=...
--fields-enclosed-by=...
--fields-optionally-enclosed-by=...
--fields-escaped-by=...
--lines-terminated-by=...
-u user_name, --user=
user_name
-w --where=
’where-
condition’

mysqlimport

Este o interfata in linie de comanda pentru comanda SQL LOAD DATA INFILE. Sintaxa:
mysqlimport [options] database textfile1 [textfile2....]
Folosire (cu mysqldump):
mysqldump -T . tracking tabela1
mysql tracking <[Link]
mysqlimport tracking [Link]
Optiuni:
-? --help
-d --delete Goleste tabela inainte de
import
--fields-terminated-by=...
--fields-enclosed-by=...
--fields-optionally-
enclosed-by=...
--fields-escaped-by=...
--lines-terminated-by=...
-f --force
-h host_name --host=host_name
-l --lock-tables
-L --local Fisierele sunt pe gazda
clientului
-p[...] --password[=...]
-P port_num --port=port_num
-I --ignore Pentru inregistrari duplicat
(nu sunt luate in seama)
-r --replace Inregistrarile duplicat sunt
inlocuite cu noua
versiune
-s --silent
-u user_name --user=user_name
-c --columns=... Campurile care vor fi
actualizate

Trebuie specificat neaparat una din optiunile --ignore sau --replace, altfel, cand se
vor gasi inregistrari duplicat in tabela si-n fiserul text se va genera o eroare.

Interogarea MySQL cu ajutorul script-urilor PHP

 Crearea tabelelor cu PHP

 Conectarea la baza de date
 Deschiderea bazei de date
 Executia comenzilor
 Adaugarea de inregistrari
 Formulare HTML
 Afisarea inregistrarilor
 Actualizarea inregistrarilor
 Functiile PHP pentru lucrul cu MySQL

Crearea unei tabele cu PHP

CREATE TABLE nume_tabela {

nume_camp tip(marime) alte_informatii,
...
}

Presupunem ca exemplu, o agenda cu datele vizitatorilor unui site memorata in tabela

agenda cu structura:

Nume Tip Lungime Descriere

id INT 6 Un identificator unic
first VARCHAR 15 Prenume
last VARCHAR 15 Nume
phone VARCHAR 20 Numarul de telefon
mobile VARCHAR 20 Numarul de mobil
fax VARCHAR 20 Numarul de fax
email VARCHAR 30 Adresa de email
web VARCHAR 30 Adresa de web
Pentru a crea aceasta tabela in PHP (explicatiile urmeaza):
<?
$user="nume";
$password="parola";
$database="baza_de_date";
mysql_connect(localhost,$user,$password);
@mysql_select_db($database) or die( "Nu se poate deschide baza de
date");
$query="CREATE TABLE agenda (id int(6) NOT NULL auto_increment,
first varchar(15) NOT NULL,
last varchar(15) NOT NULL,
phone varchar(20) NOT NULL,
mobile varchar(20) NOT NULL,
fax varchar(20) NOT NULL,
email varchar(30) NOT NULL,
web varchar(30) NOT NULL,
PRIMARY KEY (id),UNIQUE id (id),
KEY id_2 (id))";
mysql_query($query);
mysql_close();
?>

Acum sa pargurgem pasii necesari pentru a putea folosi acesta tabela.

Conectarea la baza de date:

$username="nume_utilizator";
$password="parola";
$database="baza_de_date";

mysql_connect(localhost,$username,$password);

Deschiderea bazei de date:

@mysql_select_db($database) or die( "Mesaj in caz de eroare");

Executia unei comenzi se poate face direct sau atribuind comanda unei variabile (daca
se asteapta un rezultat):
mysql_query($query);

Adaugarea de inregistrari
Informatiile urmatoare vor fi adaugate in agenda cu comanda: First: Ion
Last: Gheorghe
Phone: 01234 567890
Mobile: 00112 334455
Fax: 01234 567891
E-mail: iongh@[Link]
Web: [Link]

$query = "INSERT INTO agenda VALUES ('','Ion','Gheorghe','01234

567890','00112 334455','01234
567891','iongh@[Link]','[Link]

Formularele HTML
Iata cum ar putea sa arate un fomrular cu ajutorul caruia se vor culege informatii despre
vizitatori:

Prenume:

Nume:

Telefon:

Celular:

Fax:

E-mail:

Site Web:

Codul este:
<form action="[Link]" method="post">
Prenume: <input type="text" name="first"><br>
Last Nume: <input type="text" name="last"><br>
Telefon: <input type="text" name="phone"><br>
Mobile: <input type="text" name="mobile"><br>
Fax: <input type="text" name="fax"><br>
E-mail: <input type="text" name="email"><br>
Site Web:<input type="text" name="web"><br>
<input type="Submit">
</form>

Creaza acum un fisier '[Link]' cu urmatorul continut:

<?
$username="utilizator";
$password="parola";
$database="baza_de_date";

mysql_connect(localhost,$username,$password);
@mysql_select_db($database) or die( "Nu se poate deschide BD");

$query = "INSERT INTO agenda VALUES ('','$first','$last',

'$phone','$mobile','$fax','$email','$web')";
mysql_query($query);

mysql_close();
?>

Afisarea inregistrarilor
$query="SELECT * FROM agenda";
$result=mysql_query($query);
Rezultatele sunt acum intr-un tablou ('result'). Pentru a-i afisa elementele, trebuie folosit
un ciclu:
$num=mysql_numrows($result);

$i=0;
while ($i < $num) {
COD PT AFISaRE
++$i;
}

In continuare, vom memora datele in variabile:

$first=mysql_result($result,$i,"first");
$last=mysql_result($result,$i,"last");
$phone=mysql_result($result,$i,"phone");
$mobile=mysql_result($result,$i,"mobile");
$fax=mysql_result($result,$i,"fax");
$email=mysql_result($result,$i,"email");
$web=mysql_result($result,$i,"web");

Script-ul final pentru afisarea rezultatului interogarii:

<?
$username="utilizator";
$password="parola";
$database="baza_de_date";

mysql_connect(localhost,$username,$password);
@mysql_select_db($database) or die( "Nu se poate deschide baza de
date");
$query="SELECT * FROM agenda";
$result=mysql_query($query);

$num=mysql_numrows($result);

mysql_close();

echo "<b><center>Rezultatul interogarii</center></b><br><br>";

$i=0;
while ($i < $num) {

echo "<b>$first $last</b><

br>Telefon: $phone<
br>Mobil: $mobile<
br>Fax: $fax<
br>E-mail: $email<
br>Site Web: $web<
br><hr><br>";
++$i;
}

Fomatarea afisajului rezulatelor se poate face folosind combinatii HTMl/PHP:

<font face="Arial, Helvetica, sans-serif"><? echo "$first

$last";?></font*gt;

Interogarile se fac dupa urmatorul exemplu:

$query="SELECT * FROM agenda WHERE last='$searchlast'";

$result=mysql_query($query);

Actualizarea inregistrarilor

$id=$_GET['id'];
$username="utilizator";
$password="parola";
$database="baza_de_date";
mysql_connect(localhost,$username,$password);

$query=" SELECT * FROM agenda WHERE id='$id'";

$result=mysql_query($query);
$num=mysql_numrows($result);
mysql_close();

$i=0;
while ($i < $num) {
$first=mysql_result($result,$i,"first");
$last=mysql_result($result,$i,"last");
$phone=mysql_result($result,$i,"phone");
$mobile=mysql_result($result,$i,"mobile");
$fax=mysql_result($result,$i,"fax");
$email=mysql_result($result,$i,"email");
$web=mysql_result($result,$i,"web");
Spatiu pentru cod
++$i;
}

Formularul HTML:
<form action="[Link]" method="post">
<input type="hidden" name="ud_id" value="<? echo "$id"; ?>">
Prenumele: <input type="text" value="ud_first" value="<? echo "$first"?
>"><br>
Numele: <input type="text" value="ud_last" value="<? echo "$last"?
>"><br>
Ner. telefon: <input type="text" value="ud_phone" value="<? echo
"$phone"?>"><br>
Nr. celular: <input type="text" value="ud_mobile" value="<? echo
"$mobile"?>"><br>
Nr. fax: <input type="text" value="ud_fax" value="<? echo "$fax"?>"><br>
Adresa e-mail: <input type="text" value="ud_email" value="<? echo
"$email"?>"><br>
Adresa Web: <input type="text" value="ud_web" value="<? echo "$web"?
>"><br>
<input type="Submit" value="Actualizeaza">
</form>

Urmatorul pas este actualizarea propriu-zisa a bazei de date cu valorile introduse in

formular:

$ud_id=$_POST['ud_id'];
$ud_first=$_POST['ud_first'];
$ud_last=$_POST['ud_last'];
$ud_phone=$_POST['ud_phone'];
$ud_mobile=$_POST['ud_mobile'];
$ud_fax=$_POST['ud_fax'];
$ud_email=$_POST['ud_email'];
$ud_web=$_POST['ud_web'];

$username="utilizator";
$password="parola";
$database="baza_de_date";
mysql_connect(localhost,$username,$password);

$query="UPDATE agenda WHERE id='$ud_id'

SET first='$ud_first' last='$ud_last' phone='$ud_phone'
mobile='$ud_mobile'
fax='$ud_fax' email='$ud_email'
web='$ud_web'";
mysql_query($query);
echo "Inregistrare actualizata";
mysql_close();

Functiile PHP pentru lucrul cu MySQL

Functie Returneaza Actiune

mysql_connect([string int Deschide o conexiune la server

hostname[:port][:/path/to/
socket]] [, string
username] [, string
password])

mysql_pconnect([string int Deschide o conexiune persistenta

hostname[:port][:/path/ la serverul MySQL
to/socket]] [, string
username] [, string
password])

mysql_close([int link_ int Inchide o conexiune

identifier])
mysql_select_db(string int Selecteaza o baza de date MySQL
database_name [, int
link_identifier])

mysql_create_db(string int Creaza o baza de date

database_name [, int
link_identifier])

mysql_drop_db(string int Sterge o baza de date

database_name [, int
link_identifier])

mysql_query(string query int Trimite o interogare SQL

[, int link_identifier])

mysql_db_query(string int Trimite o interogare SQL

database_name, string
query [, int link_
identifier])

mysql_list_dbs([int int Lista bazelor de date de pe

server
link_identifier])

mysql_list_tables(string int Lista tabelelor dintr-o baza de

date
database_name [, int
link_identifier])

mysql_list_fields(string int Afiseaza campurile rezultat

database_name, string
table_name [, int link_
identifier])

mysql_error([int link_ string Afiseaza mesajul de eroare

precedent
identifier])

mysql_errno([int link_ int Afiseaza numarul mesajului de

eroare
identifier]) de la operatia precedenta

mysql_affected_rows([int int Preia numarul de inregistrari

link_identifier]) afectate de operatia precedenta

mysql_insert_id([int link_ int Preia auto_incrementul

precedentei
identifier]) comenzi INSERT

mysql_result(int result, int Preia rezultatele interogarii

int row [, mixed field])

mysql_num_rows(int result) int Preia numarul inregistrarilor

din rezultat

mysql_num_fields(int result)int Preia numarul campurilor din

rezultat
mysql_fetch_row(int result) tablou Preia cate un rand din tabloul
rezultat

mysql_fetch_object(int obiect Preia un rand ca obiect

result [, int result_type])

mysql_fetch_array(int tablou Preia un rand ca tablou

result [, int result_type])

mysql_data_seek(int result, int Muta pointerul intern al

rezultatului
int row_number)

mysql_fetch_lengths(int tablou Preia marimea maxima a datelor

result) din fiecare camp din rezultat

mysql_fetch_field(int obiect Preia informatii despre campuri

result [, int field_offset])

mysql_field_seek(int result, int Muta pointerul rezultatului la

un offset
int field_offset)

mysql_field_name(int string Preia numele campului specificat

result, int field_index)

mysql_field_table(int string Preia numele tabelei din care e

campul
result, int field_offset)

mysql_field_len(int int Preia marimea acelui camp

result, int field_offet)

mysql_field_type(int string Preia tipul acelui camp

result, int field_offset)

mysql_field_flags(int string Preia flag-ul acelui camp

result, int field_offset)

mysql_free_result(int int Elibereaza memoria de rezultat

result)

S-ar putea să vă placă și

Curs 2
Încă nu există evaluări
Curs 2
24 pagini
1 - Utilizarea PHP Cu Mysql Pas Cu Pas
100% (1)
1 - Utilizarea PHP Cu Mysql Pas Cu Pas
14 pagini
1 - UTILIZAREA PHP CU MYSQL Pas Cu Pas
Încă nu există evaluări
1 - UTILIZAREA PHP CU MYSQL Pas Cu Pas
23 pagini
PHP Mysql
Încă nu există evaluări
PHP Mysql
27 pagini
Baze de Date MySQL
Încă nu există evaluări
Baze de Date MySQL
12 pagini
Mysql Si PHP
Încă nu există evaluări
Mysql Si PHP
24 pagini
Curs PHP
Încă nu există evaluări
Curs PHP
22 pagini
CURLS SQL - Lectia1
Încă nu există evaluări
CURLS SQL - Lectia1
20 pagini
Lab 3 BD Mysql Phpmyadmin Partea 1 Last
Încă nu există evaluări
Lab 3 BD Mysql Phpmyadmin Partea 1 Last
34 pagini
TOP 10 Sisteme de Gestiune A Bazelor de Date
Încă nu există evaluări
TOP 10 Sisteme de Gestiune A Bazelor de Date
3 pagini
Indrumar Laborator Baze de Date
Încă nu există evaluări
Indrumar Laborator Baze de Date
123 pagini
Lucrul Cu Bazele de Date
Încă nu există evaluări
Lucrul Cu Bazele de Date
10 pagini
Tutorial MySQL
Încă nu există evaluări
Tutorial MySQL
22 pagini
David Vico
Încă nu există evaluări
David Vico
60 pagini
My SQLBooklet
Încă nu există evaluări
My SQLBooklet
64 pagini
Curs PHP
Încă nu există evaluări
Curs PHP
20 pagini
Microsoft SQL Server
Încă nu există evaluări
Microsoft SQL Server
17 pagini
Baza de Date Săptămâna 1
Încă nu există evaluări
Baza de Date Săptămâna 1
10 pagini
Monea Iustinian - Proiect Baze de Date
Încă nu există evaluări
Monea Iustinian - Proiect Baze de Date
39 pagini
Manual Licenta - Calculatoate Si Tehnologia Informatiei 2012
Încă nu există evaluări
Manual Licenta - Calculatoate Si Tehnologia Informatiei 2012
200 pagini
Folosirea MySQL Si PHP in Gestionarea Unei Baze de Date Pe Web
0% (1)
Folosirea MySQL Si PHP in Gestionarea Unei Baze de Date Pe Web
30 pagini
Introducere in T-SQL - Partea I
Încă nu există evaluări
Introducere in T-SQL - Partea I
18 pagini
Utilizarea Bazelor de Date in Unitatea de Invatamant Final
100% (1)
Utilizarea Bazelor de Date in Unitatea de Invatamant Final
42 pagini
Llab NR 2 Partea III NR 1 BD Mysql Phpmyadmin
Încă nu există evaluări
Llab NR 2 Partea III NR 1 BD Mysql Phpmyadmin
4 pagini
Microsoft SQL Server
Încă nu există evaluări
Microsoft SQL Server
17 pagini
IP Clasa-XI Capitolul-10 & 11 NOTE
Încă nu există evaluări
IP Clasa-XI Capitolul-10 & 11 NOTE
20 pagini
Sistem de Management Al Vizitatorilor
Încă nu există evaluări
Sistem de Management Al Vizitatorilor
40 pagini
MySQL - Partea I (Introducere. Realizarea Bazei de Date. Realizarea Și Popularea Tabelelor.)
Încă nu există evaluări
MySQL - Partea I (Introducere. Realizarea Bazei de Date. Realizarea Și Popularea Tabelelor.)
10 pagini
Analiza Sistemului Informatic de Evidenta A Elevilor Particularizat Pe o Scoala
Încă nu există evaluări
Analiza Sistemului Informatic de Evidenta A Elevilor Particularizat Pe o Scoala
33 pagini
Note Complete UNITATE 1 DBMS
Încă nu există evaluări
Note Complete UNITATE 1 DBMS
28 pagini
Programare Web MYSQL
100% (1)
Programare Web MYSQL
11 pagini
Proiect Info
Încă nu există evaluări
Proiect Info
29 pagini
Paul Dubois - Mysql
Încă nu există evaluări
Paul Dubois - Mysql
372 pagini
Tutorial
Încă nu există evaluări
Tutorial
230 pagini
Lucrare de Laborator Nr. 1 SGBD
Încă nu există evaluări
Lucrare de Laborator Nr. 1 SGBD
44 pagini
Raport Proiect Sistem de Management Al Clinicii
Încă nu există evaluări
Raport Proiect Sistem de Management Al Clinicii
20 pagini
Analiza Sistemului Informatic de Evidenta A Elevilor Particularizat Pe o Scoala
Încă nu există evaluări
Analiza Sistemului Informatic de Evidenta A Elevilor Particularizat Pe o Scoala
33 pagini
LLAB - NR - 2 - PARTEA - III - NR 2 - BD - MYSQL - PHPMYADMIN
Încă nu există evaluări
LLAB - NR - 2 - PARTEA - III - NR 2 - BD - MYSQL - PHPMYADMIN
23 pagini
1 BD Introducere
Încă nu există evaluări
1 BD Introducere
20 pagini
Carte SQL2008 Capitolele 1-4 PDF
Încă nu există evaluări
Carte SQL2008 Capitolele 1-4 PDF
126 pagini
MySQL Server
Încă nu există evaluări
MySQL Server
90 pagini
Conț Inuturi: Tabele, Cu Declarații Clare Ale Cerințelor Utilizatorului Și Sistemului
Încă nu există evaluări
Conț Inuturi: Tabele, Cu Declarații Clare Ale Cerințelor Utilizatorului Și Sistemului
30 pagini
Notiuni Introductive.
Încă nu există evaluări
Notiuni Introductive.
48 pagini
Cap1 Concepte BD
Încă nu există evaluări
Cap1 Concepte BD
36 pagini
Cap1 Concepte Baze Date 2023
Încă nu există evaluări
Cap1 Concepte Baze Date 2023
39 pagini
Access
Încă nu există evaluări
Access
29 pagini
Mysql
Încă nu există evaluări
Mysql
13 pagini
Referat - MySQL - ZAHARESCU LIVIU
Încă nu există evaluări
Referat - MySQL - ZAHARESCU LIVIU
5 pagini
Training SQL Querying Pentru Business
Încă nu există evaluări
Training SQL Querying Pentru Business
86 pagini
Referat MySQL Fara Diacritice
Încă nu există evaluări
Referat MySQL Fara Diacritice
4 pagini
Lectia 1 - SQL
Încă nu există evaluări
Lectia 1 - SQL
37 pagini
SQL Vs NoSQL
Încă nu există evaluări
SQL Vs NoSQL
20 pagini
Unitatea 5 Crearea Și Manipularea Bazelor de Date
Încă nu există evaluări
Unitatea 5 Crearea Și Manipularea Bazelor de Date
43 pagini
Initiere in PHP & MySQL (Romana)
93% (15)
Initiere in PHP & MySQL (Romana)
156 pagini
Bde 1
Încă nu există evaluări
Bde 1
6 pagini
Istoria Bazelor de Date
Încă nu există evaluări
Istoria Bazelor de Date
9 pagini
Laborator 1
Încă nu există evaluări
Laborator 1
13 pagini
Brevă Recenzie A Bazei de Date
Încă nu există evaluări
Brevă Recenzie A Bazei de Date
6 pagini
Initiere in PHP Si MySQL - Valentin Ivascu 2005
Încă nu există evaluări
Initiere in PHP Si MySQL - Valentin Ivascu 2005
2 pagini