mysql ___. istallare mysql dal link è fare il download di diverse versioni di mysql: dal link è...

MySQLMySQL______

Istallare MySQLIstallare MySQL

Dal link Dal link http://dev.mysql.com/ è fare è fare il download di diverse versioni di il download di diverse versioni di MySQL:MySQL: Es. MySQL 5.0 per diverse piattaforme Es. MySQL 5.0 per diverse piattaforme

tra cui Linux e Windows;tra cui Linux e Windows; Altri tool e driver utili:Altri tool e driver utili:

MySQL Administrator;MySQL Administrator; MySQL Query Browser;MySQL Query Browser; MySQL Workbench;MySQL Workbench; MySQL Connector/J (JDBC).MySQL Connector/J (JDBC).

SommarioSommario

Introduzione a MySQLIntroduzione a MySQL Connessione/Disconnessione da un Connessione/Disconnessione da un

database MySQLdatabase MySQL Programmi client.Programmi client. Esempi di query: database Esempi di query: database Menagerie Menagerie ((

http://dev.mysql.com/doc/)) SQL in MySQL DDL e DML.SQL in MySQL DDL e DML. EXPLAIN.EXPLAIN. Funzioni.Funzioni.

MySQL ABMySQL AB Società fondata dagli sviluppatori di Società fondata dagli sviluppatori di

MySQL;MySQL;

MySQL diventa popolare quando MySQL diventa popolare quando viene presentata la versione 3.23;viene presentata la versione 3.23;

L’insieme di feature che offre L’insieme di feature che offre coincide con ciò che la maggior parte coincide con ciò che la maggior parte degli utenti richiede ad un DBMS.degli utenti richiede ad un DBMS.

MySQL 4.0-4.1-5.0MySQL 4.0-4.1-5.0

Feature principali:Feature principali: InnoDB;InnoDB; Query Cache;Query Cache; Comando UNION;Comando UNION; Variabili Dinamiche;Variabili Dinamiche; FullText Search;FullText Search; Sub-Queriy e tabelle derivate;Sub-Queriy e tabelle derivate; Prepared Statements;Prepared Statements; Protocollo di trasmissione client/server binario;Protocollo di trasmissione client/server binario; OpenGIS (dati geografici)OpenGIS (dati geografici) Internazionalizzazione, UTF-8.Internazionalizzazione, UTF-8.

Stored ProcedureStored Procedure ViewView TriggerTrigger Pluggable Storage EnginePluggable Storage Engine

RDBMSRDBMSRDBMSRDBMS

Tabelle utenteTabelle utente dizionario dizionario datidati

ServerServer

Connessione/Connessione/disconnessionedisconnessione

Per connettersi al server è necessario Per connettersi al server è necessario fornire login e passwordfornire login e password

shell> mysql -h host -u user -p Enter password: ********

hosthost and and useruser rappresentano: rappresentano:

l’hostname dove risiede MySQL; l’hostname dove risiede MySQL; lo username di un utente che possiede un lo username di un utente che possiede un

account sul server;account sul server; -p -p specifica al server la richiesta della password specifica al server la richiesta della password

all’utente.all’utente.

C:\>mysql -u alfredo -pEnter password: *******

Welcome to the MySQL monitor. Commands end with ; or \g.Your MySQL connection id is 19 to server version: 4.0.18-nt

Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

mysql>

Per avere l’help:Per avere l’help:

C:\>mysql –help

Per uscire:Per uscire:

mysql> QUIT

Login tramite Query Login tramite Query browserbrowser

Nome connessioneNome connessione

Schermata principale di Schermata principale di Query BrowserQuery Browser

Comandi SQLComandi SQLComandi SQLComandi SQLEstrazione DatiEstrazione Dati

Data manipulation language (DML)Data manipulation language (DML)

Data definition language (DDL)Data definition language (DDL)

controllo Transazionicontrollo Transazioni

Data control language (DCL)Data control language (DCL)

INSERT UPDATE DELETE

CREATE CREATE ALTER DROP ALTER DROP RENAME RENAME TRUNCATE TRUNCATE

COMMIT COMMIT ROLLBACK ROLLBACK SAVEPOINT SAVEPOINT

GRANT GRANT REVOKEREVOKE

SELECT

Creazione di un accountCreazione di un account

Tipicamente viene eseguita Tipicamente viene eseguita dall’utente dall’utente root, root, mediante l’uso del mediante l’uso del comando GRANT.comando GRANT.

C:\>mysql -u root -pEnter password: *******

mysql> GRANT ALL ON nomeDB.* to -> ‘user’@’localhost’ IDENTIFIED BY -> ‘nome_password’;

Connessione da un clientConnessione da un client Per consentire la connessione da un server Per consentire la connessione da un server

specifico.specifico.

mysql> GRANT ALL ON nomeDB.* to

-> ‘user’@’nome_server’ IDENTIFIED BY

-> ‘nome_password’;

EsempiEsempimysql> SELECT VERSION(), CURRENT_DATE;

+-----------+--------------+| VERSION() | CURRENT_DATE |+-----------+--------------+| 4.0.18-nt | 2004-11-02 |+-----------+--------------+1 row in set (0.06 sec)

mysql> SELECT SIN(PI()/4), (4+1)*5; +-------------+---------+ | SIN(PI()/4) | (4+1)*5 | +-------------+---------+ | 0.707107 | 25 | +-------------+---------+

mysql> select user()mysql> select user() -> ,-> , -> current_date;-> current_date;

+-------------------+--------------++-------------------+--------------+| user() | current_date || user() | current_date |+-------------------+--------------++-------------------+--------------+| alfredo@localhost | 2004-11-02 || alfredo@localhost | 2004-11-02 |+-------------------+--------------++-------------------+--------------+1 row in set (0.00 sec)1 row in set (0.00 sec)

mysql>mysql>

Prompt di MySQLPrompt di MySQL PromptPrompt SignificatoSignificato

mysql>mysql> Pronto per ricevere un comando;Pronto per ricevere un comando;

->-> In attesa della successiva linea per un In attesa della successiva linea per un comando multiple-line.comando multiple-line.

'>'> In attesa della successiva linea per un In attesa della successiva linea per un comando multiple-line, apice di comando multiple-line, apice di apertura nella riga precedente (`'').apertura nella riga precedente (`'').

">"> In attesa della successiva linea per un In attesa della successiva linea per un comando multiple-line, doppio apice di comando multiple-line, doppio apice di apertura nella riga precedente (`"'). apertura nella riga precedente (`"').

`>`> In attesa della successiva linea per un In attesa della successiva linea per un comando multiple-line , che fa comando multiple-line , che fa riferimento ad un identificatore che riferimento ad un identificatore che inizia con backtick (``').inizia con backtick (``').

Selezione di un databaseSelezione di un database Comandi Comandi show - useshow - use

mysql> show databases;+----------+| Database |+----------+| alfredo || mysql || test |+----------+3 rows in set (0.00 sec)

mysql> use alfredo;Database changed

SHOWSHOW SHOW ha diverse opzioni e da informazioni riguardo ai database alle tabella,

collone, indici, ecc. Da anche informazioni riguardo il server.

SHOW [FULL] COLUMNS FROM tbl_name [FROM db_name] [LIKE 'pattern'] SHOW CREATE DATABASE db_name SHOW CREATE TABLE tbl_name SHOW DATABASES [LIKE 'pattern'] SHOW [STORAGE] ENGINES SHOW ERRORS [LIMIT [offset,] row_count] SHOW GRANTS FOR user SHOW INDEX FROM tbl_name [FROM db_name] SHOW INNODB STATUS SHOW [BDB] LOGS SHOW PRIVILEGES SHOW [FULL] PROCESSLIST SHOW STATUS [LIKE 'pattern'] SHOW TABLE STATUS [FROM db_name] [LIKE 'pattern'] SHOW [OPEN] TABLES [FROM db_name] [LIKE 'pattern'] SHOW [GLOBAL | SESSION] VARIABLES [LIKE 'pattern'] SHOW WARNINGS [LIMIT [offset,] row_count]

Creazione di un databaseCreazione di un database

L’amministratore crea il database;L’amministratore crea il database;mysql> CREATE DATABASE menagerie;

Successivamente l’utente crea le tabelle che Successivamente l’utente crea le tabelle che desidera:desidera:CREATE TABLE pet ( name VARCHAR(20),

owner VARCHAR(20),

species VARCHAR(20),

sex CHAR(1),

birth DATE,

death DATE );

DescribeDescribemysql> describe pet;+---------+-------------+------+-----+---------+-------+| Field | Type | Null | Key | Default | Extra |+---------+-------------+------+-----+---------+-------+| name | varchar(20) | YES | | NULL | || owner | varchar(20) | YES | | NULL | || species | varchar(20) | YES | | NULL | || sex | char(1) | YES | | NULL | || birth | date | YES | | NULL | || death | date | YES | | NULL | |+---------+-------------+------+-----+---------+-------+6 rows in set (0.02 sec)

Query: esempiQuery: esempimysql> SELECT * FROM pet;

+----------+--------+---------+------+------------+------------+| name | owner | species | sex | birth | death |+----------+--------+---------+------+------------+------------+| Fluffy | Harold | cat | f | 1993-02-04 | NULL | | Claws | Gwen | cat | m | 1994-03-17 | NULL || Buffy | Harold | dog | f | 1989-05-13 | NULL || Fang | Benny | dog | m | 1990-08-27 | NULL || Bowser | Diane | dog | m | 1979-08-31 | 1995-07-29 || Chirpy | Gwen | bird | f | 1998-09-11 | NULL || Whistler | Gwen | bird | NULL | 1997-12-09 | NULL || Slim | Benny | snake | m | 1996-04-29 | NULL | | Puffball | Diane | hamster | f | 1999-03-30 | NULL |+----------+--------+---------+------+------------+------------+

Query: esempiQuery: esempimysql> SELECT * FROM pet WHERE name = 'Bowser';

+--------+-------+---------+------+------------+------------+ | name | owner | species | sex | birth | death | +--------+-------+---------+------+------------+------------+ | Bowser | Diane | dog | m | 1989-08-31 | 1995-07-29 | +--------+-------+---------+------+------------+------------+

mysql> SELECT * FROM pet WHERE (species = 'cat' AND sex = 'm') -> OR (species = 'dog' AND sex = 'f');

+-------+--------+---------+------+------------+-------+ | name | owner | species | sex | birth | death | +-------+--------+---------+------+------------+-------+ | Claws | Gwen | cat | m | 1994-03-17 | NULL | | Buffy | Harold | dog | f | 1989-05-13 | NULL | +-------+--------+---------+------+------------+-------+

Query: esempiQuery: esempimysql> SELECT name, species, birth FROM pet -> WHERE species = 'dog' OR species = 'cat';

+--------+---------+------------+ | name | species | birth | +--------+---------+------------+ | Fluffy | cat | 1993-02-04 | | Claws | cat | 1994-03-17 | | Buffy | dog | 1989-05-13 | | Fang | dog | 1990-08-27 | | Bowser | dog | 1989-08-31 | +--------+---------+------------+

Query: esempiQuery: esempimysql> SELECT name, birth FROM pet ORDER BY birth DESC; +----------+------------+ | name | birth | +----------+------------+ | Puffball | 1999-03-30 | | Chirpy | 1998-09-11 | | Whistler | 1997-12-09 | | Slim | 1996-04-29 | | Claws | 1994-03-17 | | Fluffy | 1993-02-04 | | Fang | 1990-08-27 | | Bowser | 1989-08-31 | | Buffy | 1989-05-13 | +----------+------------+

Query: esempiQuery: esempimysql> SELECT name, species, birth FROM pet -> ORDER BY species, birth DESC;

+----------+---------+------------+ | name | species | birth | +----------+---------+------------+ | Chirpy | bird | 1998-09-11 | | Whistler | bird | 1997-12-09 | | Claws | cat | 1994-03-17 | | Fluffy | cat | 1993-02-04 | | Fang | dog | 1990-08-27 | | Bowser | dog | 1989-08-31 | | Buffy | dog | 1989-05-13 | | Puffball | hamster | 1999-03-30 | | Slim | snake | 1996-04-29 |+----------+---------+------------+

Query: esempiQuery: esempimysql> SELECT name, birth, CURDATE(), -> (YEAR(CURDATE())-YEAR(birth)) -> - (RIGHT(CURDATE(),5)<RIGHT(birth,5)) -> AS age -> FROM pet; +----------+------------+------------+------+ | name | birth | CURDATE() | age | +----------+------------+------------+------+ | Fluffy | 1993-02-04 | 2003-08-19 | 10 | | Claws | 1994-03-17 | 2003-08-19 | 9 | | Buffy | 1989-05-13 | 2003-08-19 | 14 | | Fang | 1990-08-27 | 2003-08-19 | 12 | | Bowser | 1989-08-31 | 2003-08-19 | 13 || Chirpy | 1998-09-11 | 2003-08-19 | 4 || Whistler | 1997-12-09 | 2003-08-19 | 5 | | Slim | 1996-04-29 | 2003-08-19 | 7 | | Puffball | 1999-03-30 | 2003-08-19 | 4 | +----------+------------+------------+------+

Query: esempiQuery: esempimysql> SELECT name, birth, death,

-> (YEAR(death)-YEAR(birth))-(RIGHT(death,5)<RIGHT(birth,5))

-> AS age -> FROM pet WHERE death IS NOT NULL ORDER BY age; +--------+------------+------------+------+ | name | birth | death | age | +--------+------------+------------+------+ | Bowser | 1989-08-31 | 1995-07-29 | 5 | +--------+------------+------------+------+

mysql> SELECT name, birth FROM pet WHERE MONTH(birth) = 5;

+-------+------------+ | name | birth | +-------+------------+ | Buffy | 1989-05-13 | +-------+------------+

Il valore NULL per un campo assume il Il valore NULL per un campo assume il seguente significato: seguente significato: mancantemancante, , sconosciutosconosciuto ed è trattato diversamente dagli altri valori.ed è trattato diversamente dagli altri valori.

Per testare il valore NULL non possono Per testare il valore NULL non possono essere usati gli operatori di confronto quali essere usati gli operatori di confronto quali =, <, o <>. =, <, o <>.

Esempio:Esempio:

mysql> SELECT 1 = NULL, 1 <> NULL, 1 < NULL, 1 > NULL; +----------+-----------+----------+----------+ | 1 = NULL | 1 <> NULL | 1 < NULL | 1 > NULL | +----------+-----------+----------+----------+ | NULL | NULL | NULL | NULL | +----------+-----------+----------+----------+

Con l’uso di IS NULL e IS NOT NULL Con l’uso di IS NULL e IS NOT NULL si ottiene:si ottiene:

mysql> SELECT 1 IS NULL, 1 IS NOT NULL; +-----------+---------------+ | 1 IS NULL | 1 IS NOT NULL | +-----------+---------------+ | 0 | 1 | +-----------+---------------+

Quando si usa ORDER BY, i valori Quando si usa ORDER BY, i valori NULL sono inseriti all’inizio con ASC NULL sono inseriti all’inizio con ASC ed alla fine con ORDER BY ... DESC. ed alla fine con ORDER BY ... DESC.

mysql> SELECT * FROM pet WHERE name LIKE 'b%'; +--------+--------+---------+------+------------+------------+ | name | owner | species | sex | birth | death | +--------+--------+---------+------+------------+------------+ | Buffy | Harold | dog | f | 1989-05-13 | NULL | | Bowser | Diane | dog | m | 1989-08-31 | 1995-07-29 | +--------+--------+---------+------+------------+------------+

mysql> SELECT * FROM pet WHERE name LIKE '%fy'; +--------+--------+---------+------+------------+-------+ | name | owner | species | sex | birth | death | +--------+--------+---------+------+------------+-------+ | Fluffy | Harold | cat | f | 1993-02-04 | NULL | | Buffy | Harold | dog | f | 1989-05-13 | NULL | +--------+--------+---------+------+------------+-------+

mysql> SELECT * FROM pet WHERE name LIKE '%w%'; +----------+-------+---------+------+------------+------------+ | name | owner | species | sex | birth | death |+----------+-------+---------+------+------------+------------+ | Claws | Gwen | cat | m | 1994-03-17 | NULL | | Bowser | Diane | dog | m | 1989-08-31 | 1995-07-29 | | Whistler | Gwen | bird | NULL | 1997-12-09 | NULL |+----------+-------+---------+------+------------+------------+

mysql> SELECT * FROM pet WHERE name LIKE '_____';

+-------+--------+---------+------+------------+-------+ | name | owner | species | sex | birth | death | +-------+--------+---------+------+------------+-------+ | Claws | Gwen | cat | m | 1994-03-17 | NULL | | Buffy | Harold | dog | f | 1989-05-13 | NULL | +-------+--------+---------+------+------------+-------+

mysql> SELECT * FROM pet WHERE name REGEXP '^b'; +--------+--------+---------+------+------------+------------+ | name | owner | species | sex | birth | death | +--------+--------+---------+------+------------+------------+ | Buffy | Harold | dog | f | 1989-05-13 | NULL | | Bowser | Diane | dog | m | 1989-08-31 | 1995-07-29 | +--------+--------+---------+------+------------+------------+

mysql> SELECT * FROM pet WHERE name REGEXP '^[bB]';

mysql> SELECT * FROM pet WHERE name REGEXP 'fy$'; +--------+--------+---------+------+------------+-------+ | name | owner | species | sex | birth | death | +--------+--------+---------+------+------------+-------+ | Fluffy | Harold | cat | f | 1993-02-04 | NULL | | Buffy | Harold | dog | f | 1989-05-13 | NULL | +--------+--------+---------+------+------------+-------+

mysql> SELECT * FROM pet WHERE name REGEXP 'w'; +----------+-------+---------+------+------------+------------+ | name | owner | species | sex | birth | death | +----------+-------+---------+------+------------+------------+ | Claws | Gwen | cat | m | 1994-03-17 | NULL | | Bowser | Diane | dog | m | 1989-08-31 | 1995-07-29 | | Whistler | Gwen | bird | NULL | 1997-12-09 | NULL |+----------+-------+---------+------+------------+------------+

mysql> SELECT * FROM pet WHERE name REGEXP '^.....$'; +-------+--------+---------+------+------------+-------+ | name | owner | species | sex | birth | death | +-------+--------+---------+------+------------+-------+ | Claws | Gwen | cat | m | 1994-03-17 | NULL | | Buffy | Harold | dog | f | 1989-05-13 | NULL | +-------+--------+---------+------+------------+-------+

mysql> SELECT * FROM pet WHERE name REGEXP '^.{5}$'; +-------+--------+---------+------+------------+-------+ | name | owner | species | sex | birth | death |+-------+--------+---------+------+------------+-------+ | Claws | Gwen | cat | m | 1994-03-17 | NULL | | Buffy | Harold | dog | f | 1989-05-13 | NULL | +-------+--------+---------+------+------------+-------+

mysql> SELECT COUNT(*) FROM pet; +----------+ | COUNT(*) | +----------+ | 9 | +----------+

mysql> SELECT owner, COUNT(*) FROM pet GROUP BY owner; +--------+----------+ | owner | COUNT(*) | +--------+----------+ | Benny | 2 | | Diane | 2 | | Gwen | 3 | | Harold | 2 | +--------+----------+

mysql> SELECT species, sex, COUNT(*) FROM pet GROUP BY species, sex; +---------+------+----------+ | species | sex | COUNT(*) | +---------+------+----------+ | bird | NULL | 1 | | bird | f | 1 | | cat | f | 1 | | cat | m | 1 | | dog | f | 1 | | dog | m | 2 | | hamster | f | 1 | | snake | m | 1 | +---------+------+----------+

mysql> SELECT species, sex, COUNT(*) FROM pet WHERE species = 'dog' OR species = 'cat' -> GROUP BY species, sex; +---------+------+----------+ | species | sex | COUNT(*) | +---------+------+----------+ | cat | f | 1 | | cat | m | 1 | | dog | f | 1 | | dog | m | 2 | +---------+------+----------+

mysql> CREATE TABLE event (name VARCHAR(20),

-> date DATE,

-> type VARCHAR(15),

-> remark VARCHAR(255));

mysql> SELECT p1.name, p1.sex, p2.name, p2.sex, p1.species -> FROM pet AS p1, pet AS p2 -> WHERE p1.species = p2.species AND p1.sex = 'f' AND p2.sex = 'm'; +--------+------+--------+------+---------+ | name | sex | name | sex | species |+--------+------+--------+------+---------+ | Fluffy | f | Claws | m | cat | | Buffy | f | Fang | m | dog | | Buffy | f | Bowser | m | dog | +--------+------+--------+------+---------+

Tipi di dati: Numerici Tipi di dati: Numerici (1/2)(1/2)

TipoTipo ByteByte Minimum ValueMinimum Value Maximum ValueMaximum Value

(Signed/Unsigned)(Signed/Unsigned) (Signed/Unsigned)(Signed/Unsigned)

TINYINT[(M)]TINYINT[(M)] 11 -128-128 127127

00 255255

SMALLINT [(M)] 2 -32768 32767

0 65535

MEDIUMINT [(M)]MEDIUMINT [(M)] 33 -8388608-8388608 83886078388607

0 0 1677721516777215

INT [(M)] 4 -2147483648 2147483647

0 4294967295

BIGINT [(M)]BIGINT [(M)] 88 -9223372036854775808-9223372036854775808 92233720368547758079223372036854775807

00 1844674407370955161184467440737095516155

FLOAT[(M,D)] 4 +/-1.175494351E-38 +/- 3.402823466E+38

DOUBLE [(M,D)]DOUBLE [(M,D)] 88 +/-+/-2.2250738585072014E-2.2250738585072014E-

308 308

+/-+/-1.7976931348623157E1.7976931348623157E

+308 +308

Tipi di dati: Numerici Tipi di dati: Numerici (2/2)(2/2)

INTEGERINTEGER DOUBLE PRECISION DOUBLE PRECISION REALREAL DECIMALDECIMAL NUMERICNUMERIC

Per il tipo DECIMAL il range Per il tipo DECIMAL il range dipende da M e D, occupa M+2 byte.dipende da M e D, occupa M+2 byte.

Tipi di dati: testoTipi di dati: testoTipoTipo Max sizeMax size ByteByte

CHARCHAR[(M)][(M)] MM MM

VARCHAR(M) M L+1

TINYBLOB/ TINYTEXTTINYBLOB/ TINYTEXT 2288-1-1 L+1L+1

BLOB/TEXT 216-1 L+2

MEDIUMBLOB/MEDIUMBLOB/MEDIUMTEXTMEDIUMTEXT

222424-1-1 L+3L+3

LONGBLOB/LONGTEXT 232-1 L+4

ENUM(‘value1’,’value2’,…)ENUM(‘value1’,’value2’,…) 65535 65535 elementielementi

1 o 2 byte1 o 2 byte

SET (‘value1’,’value2’,…) 64 elementi 1,2,3,4 o 8 byte

• L rappresenta la lunghezza effettiva del testo

Tipi di dati: date e timeTipi di dati: date e time

TipoTipo RangeRange ByteByte

DATEDATE ‘‘1000-01-01’ ‘9999-12-31’1000-01-01’ ‘9999-12-31’ 33

DATETIME ‘1000-01-01 00:00:00’ ‘9999-12-31 23:59:59’

8

TIMESTAMP[(TIMESTAMP[(M)]M)]

Da 19700101000000 ad Da 19700101000000 ad una data nel 2037una data nel 2037

44

TIME ‘-838:59:59’ - ‘838:59:59’ 3

YEAR [(M)]YEAR [(M)] 1901 al 2144 per YEAR(4)1901 al 2144 per YEAR(4) 11

CREATE DATABASE CREATE DATABASE CREATE {DATABASE | SCHEMA} [IF NOT EXISTS] db_name

[create_specification [, create_specification] ...]

create_specification: [DEFAULT] CHARACTER SET charset_name | [DEFAULT] COLLATE collation_name

CREATE DATABASE crea un CREATE DATABASE crea un database con il nome dato;database con il nome dato;

Per poter eseguire il comando Per poter eseguire il comando bisogna avere il privilegio CREATE bisogna avere il privilegio CREATE per creazione database.per creazione database.

DROP DATABASEDROP DATABASE

DROP {DATABASE | SCHEMA} [IF EXISTS] db_name

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

CREATE [TEMPORARY] TABLE [IF NOT EXISTS] tbl_name [(] LIKE old_tbl_name [)];

CREATE TABLE crea una tabella nel CREATE TABLE crea una tabella nel db;db;

Per poter eseguire il comando Per poter eseguire il comando bisogna avere il privilegio CREATE bisogna avere il privilegio CREATE per le tabelle.per le tabelle.

CREATE TABLE (cont.)CREATE TABLE (cont.)create_definition:

column_definition | [CONSTRAINT [symbol]] PRIMARY KEY [index_type] (index_col_name,...) | KEY [index_name] [index_type] (index_col_name,...) | INDEX [index_name] [index_type] (index_col_name,...) | [CONSTRAINT [symbol]] UNIQUE [INDEX] [index_name] [index_type]

(index_col_name,...) | [FULLTEXT|SPATIAL] [INDEX] [index_name] (index_col_name,...) | [CONSTRAINT [symbol]] FOREIGN KEY [index_name] (index_col_name,...)

[reference_definition] | CHECK (expr)

column_definition: col_name type [NOT NULL | NULL] [DEFAULT default_value] [AUTO_INCREMENT] [[PRIMARY] KEY] [COMMENT 'string'] [reference_definition]

index_col_name: col_name [(length)] [ASC | DESC]

reference_definition: REFERENCES tbl_name [(index_col_name,...)]

[MATCH FULL | MATCH PARTIAL | MATCH SIMPLE] [ON DELETE reference_option] [ON UPDATE reference_option]

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

table_options: table_option [table_option] ...

table_option: {ENGINE|TYPE} = {BDB|HEAP|ISAM|InnoDB|MERGE|MRG_MYISAM|MYISAM} | AUTO_INCREMENT = value | AVG_ROW_LENGTH = value | CHECKSUM = {0 | 1} | COMMENT = 'string' | MAX_ROWS = value | MIN_ROWS = value | PACK_KEYS = {0 | 1 | DEFAULT} | PASSWORD = 'string' | DELAY_KEY_WRITE = {0 | 1} | ROW_FORMAT = { DEFAULT | DYNAMIC | FIXED | COMPRESSED } | RAID_TYPE = { 1 | STRIPED | RAID0 } RAID_CHUNKS = value RAID_CHUNKSIZE = value | UNION = (tbl_name[,tbl_name]...) | INSERT_METHOD = { NO | FIRST | LAST } | DATA DIRECTORY = 'absolute path to directory' | INDEX DIRECTORY = 'absolute path to directory' | [DEFAULT] CHARACTER SET charset_name [COLLATE collation_name]

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

Nella CREATE TABLE può essere usata la Nella CREATE TABLE può essere usata la clausola TEMPORARY. Una tabella TEMPORARY clausola TEMPORARY. Una tabella TEMPORARY è visibile solo nella connessione corrente è visibile solo nella connessione corrente all’uscita la tabella è rimossa. all’uscita la tabella è rimossa.

Bisogna avere il privilegio CREATE TEMPORARY Bisogna avere il privilegio CREATE TEMPORARY TABLES. TABLES.

Può essere specificata la parola chiave IF NOT Può essere specificata la parola chiave IF NOT EXISTS per evitare errori se la tabella già esiste. EXISTS per evitare errori se la tabella già esiste. Nota: non viene verificato che la tabella che si sta Nota: non viene verificato che la tabella che si sta

creando ha la stessa struttura di quella esistente.creando ha la stessa struttura di quella esistente.

MySQL memorizza il formato di ogni tabella MySQL memorizza il formato di ogni tabella come un file come un file ’.frm'’.frm' nella directory del db. nella directory del db. Possono essere creati anche altri file.Possono essere creati anche altri file.

Nel caso di tabelle di tipo MyISAM il sistema Nel caso di tabelle di tipo MyISAM il sistema crea tre file per una tabella crea tre file per una tabella tbl_nametbl_name: : tbl_name.frm File di definizione del

formato tbl_name.MYD Data file tbl_name.MYI Index file

Se NULL o NOT NULL non sono stati Se NULL o NOT NULL non sono stati specificati il sistema per default associa il specificati il sistema per default associa il valore NULL. valore NULL.

Una colonna integer può avere l’attributo Una colonna integer può avere l’attributo addizionale AUTO_INCREMENT. Quando addizionale AUTO_INCREMENT. Quando viene inserito un valore NULL (recommended) viene inserito un valore NULL (recommended) o 0 in una colonna AUTO_INCREMENT, alla o 0 in una colonna AUTO_INCREMENT, alla colonna viene automaticamente inserito il colonna viene automaticamente inserito il successivo valore disponibile. Tipicamente il successivo valore disponibile. Tipicamente il valore è valore è valuevalue+1, dove +1, dove valuevalue è il più grande è il più grande valore presente nella tabella per quel campo. valore presente nella tabella per quel campo.

La sequenza AUTO_INCREMENT inizia con 1. La sequenza AUTO_INCREMENT inizia con 1.

KEY è sinonimo di INDEX. Gli attributi PRIMARY KEY KEY è sinonimo di INDEX. Gli attributi PRIMARY KEY possono essere specificati con la parola chiave KEY possono essere specificati con la parola chiave KEY quando vengono definiti. Implementato per compatibilità quando vengono definiti. Implementato per compatibilità con altri sistemi DBMS.con altri sistemi DBMS.

In MySQL, un indice UNIQUE impone che tutti i valori In MySQL, un indice UNIQUE impone che tutti i valori per in esso siano distinti. Fatta eccezione per i valori per in esso siano distinti. Fatta eccezione per i valori NULL se sono ammessi. Questa regola non è valida per NULL se sono ammessi. Questa regola non è valida per le tabelle di tipo BDB. le tabelle di tipo BDB.

Una PRIMARY KEY è una KEY univoca e le colonne sono Una PRIMARY KEY è una KEY univoca e le colonne sono definite NOT NULL. Una tabella può avere solo una definite NOT NULL. Una tabella può avere solo una PRIMARY KEY. Se non viene associata nessuna PRIMARY KEY. Se non viene associata nessuna PRIMARY KEY alla tabella ad una applicazione chiede la PRIMARY KEY alla tabella ad una applicazione chiede la PRIMARY KEY della tabella in esame MySQL ritorna il PRIMARY KEY della tabella in esame MySQL ritorna il primo indice UNIQUE definito che non ha colonne a primo indice UNIQUE definito che non ha colonne a NULL. NULL.

CREATE TABLE student

(

name VARCHAR(20) NOT NULL,

sex ENUM('F','M') NOT NULL,

student_id INT UNSIGNED NOT NULL AUTO_INCREMENT,

PRIMARY KEY (student_id)

);

Alcuni storage consentono di specificare il tipo di indice Alcuni storage consentono di specificare il tipo di indice (struttura dati) durante la creazione della tabella. (struttura dati) durante la creazione della tabella.

Bisogna usare la parola chiave USING Bisogna usare la parola chiave USING type_nametype_name. .

MyISAM MyISAM BTREE BTREE InnoDBInnoDB BTREE BTREE MEMORY/HEAP MEMORY/HEAP HASH, BTREE HASH, BTREE

Esempio: Esempio:

CREATE TABLE lookup (id INT,

INDEX USING BTREE (id)) ENGINE = MEMORY;

MyISAMMyISAM

MyISAM è lo storage engine di default dal MyISAM è lo storage engine di default dal MySQL 3.23. E’ basato sullo storage ISAM.MySQL 3.23. E’ basato sullo storage ISAM.

Ogni tabella MyISAM è memorizzata Ogni tabella MyISAM è memorizzata all’interno del disco con tre file. all’interno del disco con tre file.

Per specificare in maniera esplicita la Per specificare in maniera esplicita la tipoligia di tabella desiderata bisogna tipoligia di tabella desiderata bisogna usare il comando ENGINE o TYPE.usare il comando ENGINE o TYPE.

CREATE TABLE t (i INT) ENGINE = MYISAM;

CREATE TABLE t (i INT) TYPE = MYISAM;

Tipi di tabelleTipi di tabelleStorage EngineStorage Engine DescrizioneDescrizione

BDBBDB Tabelle transaction-safe con page Tabelle transaction-safe con page locking.locking.

HEAPHEAP I dati della seguente tabella sono I dati della seguente tabella sono solamente memorizzati nella solamente memorizzati nella memoria principale.memoria principale.

ISAMISAM Primo storage engine di MySQL Primo storage engine di MySQL

InnoDBInnoDB Tabella transaction-safe con lock Tabella transaction-safe con lock di righe e chiavi esterne.di righe e chiavi esterne.

MEMORYMEMORY Un alias di HEAPUn alias di HEAP

MERGEMERGE Una collezione di tabelle MyISAM Una collezione di tabelle MyISAM usate come una singola tabella.usate come una singola tabella.

MRG_MyISAMMRG_MyISAM Un alias di MERGE. Un alias di MERGE.

MyISAMMyISAM Storage engine binario portabile. Storage engine binario portabile. Evoluzione di ISAM.Evoluzione di ISAM.

CREATE/DROP INDEX CREATE/DROP INDEX

CREATE [UNIQUE|FULLTEXT|SPATIAL] INDEX index_name [index_type]

ON tbl_name (index_col_name,...)

index_col_name:

col_name [(length)] [ASC | DESC]

DROP INDEX index_name ON tbl_name

DROP/RENAME TABLEDROP/RENAME TABLEDROP [TEMPORARY] TABLE [IF EXISTS]

tbl_name [, tbl_name] ... [RESTRICT | CASCADE]

RENAME TABLE tbl_name TO new_tbl_name [, tbl_name2 TO new_tbl_name2] ...

Esempio:

CREATE TABLE new_table (...);

RENAME TABLE old_table TO backup_table, new_table TO old_table;

INSERTINSERTINSERT [LOW_PRIORITY | DELAYED | HIGH_PRIORITY] [IGNORE] [INTO] tbl_name [(col_name,...)] VALUES ({expr | DEFAULT},...),(...),... [ ON DUPLICATE KEY UPDATE col_name=expr, ... ]

INSERT [LOW_PRIORITY | DELAYED | HIGH_PRIORITY] [IGNORE] [INTO] tbl_name

SET col_name={expr | DEFAULT}, ... [ ON DUPLICATE KEY UPDATE col_name=expr, ... ]

INSERT [LOW_PRIORITY | DELAYED | HIGH_PRIORITY] [IGNORE]

[INTO] tbl_name [(col_name,...)] SELECT ...

Se viene specificata la clausola DELAYED, il server inserisce la Se viene specificata la clausola DELAYED, il server inserisce la riga o le righe in un buffer e il client che ha effettuato l’insert può riga o le righe in un buffer e il client che ha effettuato l’insert può proseguire il lavoro. Se la tabella è occupata il sistema mantiene proseguire il lavoro. Se la tabella è occupata il sistema mantiene le righe. Nel momento in cui la tabella è libera il sistema inizia le righe. Nel momento in cui la tabella è libera il sistema inizia con l’inserimento di esse, controllando periodicamente se vi sono con l’inserimento di esse, controllando periodicamente se vi sono richieste verso la tabella. Nel momento in cui il sistema verifica richieste verso la tabella. Nel momento in cui il sistema verifica una richiesta sospende l’inserimento. una richiesta sospende l’inserimento.

Se viene specificata la parola chiave LOW_PRIORITY, Se viene specificata la parola chiave LOW_PRIORITY, l’esecuzione dell’insert viene ritardata fino a quando vi sono dei l’esecuzione dell’insert viene ritardata fino a quando vi sono dei client che effettuano richieste verso la tabella. client che effettuano richieste verso la tabella.

Se viene specificata la parola chiave IGNORE tutte le righe che Se viene specificata la parola chiave IGNORE tutte le righe che provano a duplicare il contenuto di un campo con indice UNIQUE provano a duplicare il contenuto di un campo con indice UNIQUE o PRIMARY KEY vengono ignorate. o PRIMARY KEY vengono ignorate.

Se viene specificata la clausola ON DUPLICATE KEY nel Se viene specificata la clausola ON DUPLICATE KEY nel momento in cui si tenta di inserire una riga duplicata su un indice momento in cui si tenta di inserire una riga duplicata su un indice il sistema effettua l’update specificato per quella riga.il sistema effettua l’update specificato per quella riga.

LOAD DATALOAD DATALOAD 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

[STARTING BY ''] [TERMINATED BY '\n']

] [IGNORE number LINES] [(col_name,...)]

Il comando LOAD DATA INFILE consente il Il comando LOAD DATA INFILE consente il caricamento di una tabella ad alta velocità caricamento di una tabella ad alta velocità leggendo le righe da un file di testo.leggendo le righe da un file di testo.

Caricamento dei dati:Caricamento dei dati:

mysql> LOAD DATA LOCAL INFILE 'pet.txt' INTO TABLE pet;

mysql> LOAD DATA LOCAL INFILE 'event.txt' INTO TABLE event;

mysql> LOAD DATA INFILE '/tmp/test.txt'

-> INTO TABLE test LINES STARTING BY “yyy";

Quindi un file contenente Quindi un file contenente

yyy"Row",1 yyy"Row",1

blablabla yyy"Row",2 blablabla yyy"Row",2 Può essere letto e verrà caricato Può essere letto e verrà caricato

come (“row”,1), (“row”,2)come (“row”,1), (“row”,2)

SELECTSELECTSELECT

[ALL | DISTINCT | DISTINCTROW ] [HIGH_PRIORITY] [STRAIGHT_JOIN] [SQL_SMALL_RESULT] [SQL_BIG_RESULT] [SQL_BUFFER_RESULT]

[SQL_CACHE | SQL_NO_CACHE] [SQL_CALC_FOUND_ROWS] select_expr, ... [INTO OUTFILE 'file_name' export_options | INTO DUMPFILE 'file_name'] [FROM table_references

[WHERE where_definition] [GROUP BY {col_name | expr | position}

[ASC | DESC], ... [WITH ROLLUP]] [HAVING where_definition] [ORDER BY {col_name | expr | position}

[ASC | DESC] , ...] [LIMIT {[offset,] row_count | row_count OFFSET offset}]

[PROCEDURE procedure_name(argument_list)] [FOR UPDATE | LOCK IN SHARE MODE]]

EsempioEsempio

mysql> SELECT CONCAT(last_name,', ',first_name) AS full_name

-> FROM mytable ORDER BY full_name;

La clausola FROM La clausola FROM table_referencestable_references indica le indica le tabelle da dove prelevare le righe. tabelle da dove prelevare le righe.

Per ogni tabella specificata si può specificare un Per ogni tabella specificata si può specificare un alias: alias: tbl_name [[AS] alias]

[[USE INDEX (key_list)] | [IGNORE INDEX (key_list)] | [FORCE INDEX (key_list)]]

L’uso di USE INDEX, IGNORE INDEX, FORCE L’uso di USE INDEX, IGNORE INDEX, FORCE INDEX da all’ottimizzatore delle regole su come INDEX da all’ottimizzatore delle regole su come scegliere gli indici. scegliere gli indici.

JOINJOINtable_reference, table_reference table_reference [INNER | CROSS] JOIN table_reference [join_condition] table_reference STRAIGHT_JOIN table_reference table_reference LEFT [OUTER] JOIN table_reference [join_condition] table_reference NATURAL [LEFT [OUTER]] JOIN table_reference { OJtable_reference LEFT OUTER JOIN table_reference ON conditional_expr } table_reference RIGHT [OUTER] JOIN table_reference [join_condition] table_reference NATURAL [RIGHT [OUTER]] JOIN table_reference

table_reference:

tbl_name [[AS] alias] [[USE INDEX (key_list)] | [IGNORE INDEX (key_list)] | [FORCE INDEX (key_list)]]

join_condition: ON conditional_expr | USING (column_list)

Right Outer JoinLeft Outer Join Join

Le righe che soddisfano la join

Le righe escluse dalla join della tabella a sx

Le righe escluse dalla join della tabella a dx

Full outer join

mysql> SELECT table1.* FROM table1

-> LEFT JOIN table2 ON table1.id=table2.id

-> WHERE table2.id IS NULL;

Questo esempio trova tutte le righe della Questo esempio trova tutte le righe della table1table1 che non che non sono presenti in sono presenti in table2table2 (ovvero tutte le righe di (ovvero tutte le righe di table1table1 che che non hanno un corrispondente in non hanno un corrispondente in table2table2). ).

La clausola USING (column_list) elenca una lista di colonne che La clausola USING (column_list) elenca una lista di colonne che devono essere presenti in entrambe le tabelle. devono essere presenti in entrambe le tabelle.

Le seguenti clausole sono semanticamente identiche: Le seguenti clausole sono semanticamente identiche: a LEFT JOIN b USING (c1,c2,c3) a LEFT JOIN b ON a.c1=b.c1 AND

a.c2=b.c2 AND a.c3=b.c3

NATURAL [LEFT] JOIN di due tabelle è semanticamente NATURAL [LEFT] JOIN di due tabelle è semanticamente equivalente a INNER JOIN o LEFT JOIN con la clausola USING che equivalente a INNER JOIN o LEFT JOIN con la clausola USING che elenca i campi delle due tabelle. elenca i campi delle due tabelle.

RIGHT JOIN opera analogamente a LEFT JOIN. Si consiglia di usare RIGHT JOIN opera analogamente a LEFT JOIN. Si consiglia di usare LEFT JOIN invece di RIGHT JOIN, per compatibilità con altri LEFT JOIN invece di RIGHT JOIN, per compatibilità con altri sistemi.sistemi.

STRAIGHT_JOIN è identica alla JOIN, ad eccezione che le tabella STRAIGHT_JOIN è identica alla JOIN, ad eccezione che le tabella sinistra è sempre letta prima della tabella destra. Questo può sinistra è sempre letta prima della tabella destra. Questo può essere utile nei casi in cui l’ottimizzatore posiziona le tabelle essere utile nei casi in cui l’ottimizzatore posiziona le tabelle nell’ordine sbagliato.nell’ordine sbagliato.

In una query possono essere specificate delle regole (In una query possono essere specificate delle regole (hintshints) ) relativamente agli indici da usare durante l’esecuzione di una relativamente agli indici da usare durante l’esecuzione di una query.query.

Specificando USE INDEX (key_list), si può dire al MySQL di Specificando USE INDEX (key_list), si può dire al MySQL di usare solamente gli indici specificati in key_list per trovare le usare solamente gli indici specificati in key_list per trovare le righe nella tabella. righe nella tabella.

La sintassi alternativa IGNORE INDEX (key_list) può essere La sintassi alternativa IGNORE INDEX (key_list) può essere usata per dire al MySQL di non usare un particolare indice. usata per dire al MySQL di non usare un particolare indice.

Queste regole sono utili se il comando EXPLAIN mostra che Queste regole sono utili se il comando EXPLAIN mostra che MySQL usa in maniera non ottimale gli indici.MySQL usa in maniera non ottimale gli indici.

Si può usare FORCE INDEX. Opera in modo simile a USE Si può usare FORCE INDEX. Opera in modo simile a USE INDEX (key_list) ma in più assume che un full table scan è una INDEX (key_list) ma in più assume che un full table scan è una operazione molto dispendiosa. operazione molto dispendiosa.

USE KEY, IGNORE KEY, e FORCE KEY sono sinonimi di USE USE KEY, IGNORE KEY, e FORCE KEY sono sinonimi di USE INDEX, IGNORE INDEX, and FORCE INDEX. INDEX, IGNORE INDEX, and FORCE INDEX.

SottoquerySottoquerySottoquerySottoquery

“Quali impiegati hanno un salario maggiore del salario di ‘Jones’?”

Query Principale

??

“Quale e’ il salario di ‘Jones’?”

??

Sottoquery

SottoquerySottoquerySottoquerySottoquerySELECT select_exprFROM table_referencesWHERE expr operator

(SELECT select_expr FROM table_references);

L’output di una sottoquery viene dato in L’output di una sottoquery viene dato in input alla query principale.input alla query principale.

2975

mysql> SELECT ename -> FROM emp -> WHERE sal > -> (SELECT sal -> FROM emp -> WHERE empno=7566);

Uso di SottoqueryUso di SottoqueryUso di SottoqueryUso di Sottoquery

Tipi di SottoqueryTipi di SottoqueryTipi di SottoqueryTipi di Sottoquery sottoquery su riga singolasottoquery su riga singola

Query principale

Sottoquery ritornaritorna

Singolo valoreSingolo valore

• subquery su riga Multiplasubquery su riga Multipla

Un elenco di valoriUn elenco di valoririferiti ad un camporiferiti ad un campo

Query principale


•Sottoquery su colonna Multipla

Elenco di valori Elenco di valori

Riferiti a diverisi campiRiferiti a diverisi campi

Query principale


Sottoquery su righe Sottoquery su righe multiplemultiple

Sottoquery su righe Sottoquery su righe multiplemultiple Restituiscono più di una rigaRestituiscono più di una riga

Vanno usate con operatori di riga Vanno usate con operatori di riga multiplamultipla

Operatore

IN

ANY/SOME

ALL

Significato

Uguale ad un elemento della lista

Vero se almeno uno degli elementi

soddisfa la condizione

Confronta il valore con tutti gli elemeti

restituiti dalla sottoquery

Sottoquery correlateSottoquery correlate

Una Una sottoquery correlata sottoquery correlata è una è una sottoquery che contiene un riferimento sottoquery che contiene un riferimento ad una tabella (es. ad un suo campo) ad una tabella (es. ad un suo campo) che è presente nella query più esterna.che è presente nella query più esterna.

Esempio: Esempio: SELECT * FROM t1 WHERE column1 = ANY (SELECT column1

FROM t2

WHERE t2.column2 = t1.column2);

EXSIST/NOT EXSISITSEXSIST/NOT EXSISITS

Se una sottoquery restituisce un Se una sottoquery restituisce un valore qualsiasi allora la sottoquery valore qualsiasi allora la sottoquery EXISTS è TRUE e la sottoquery NOT EXISTS è TRUE e la sottoquery NOT EXISTS è FALSE. EXISTS è FALSE.

Per esempio: Per esempio: mysql> SELECT column1 FROM t1 WHERE

-> EXISTS (SELECT * FROM t2);

City(id,city,country,district,populatioCity(id,city,country,district,population)n)

Cities_Stores(city,store_type,addressCities_Stores(city,store_type,address))

Stores(store_type,description)Stores(store_type,description)

EsempiEsempi Che tipi di negozi sono presenti in una o più città? Che tipi di negozi sono presenti in una o più città?

SELECT DISTINCT store_type FROM Stores WHERE EXISTS (SELECT * FROM Cities_Stores WHERE

Cities_Stores.store_type = Stores.store_type);

Quali tipi di negozi non sono presenti nelle città? Quali tipi di negozi non sono presenti nelle città?

SELECT DISTINCT store_type FROM Stores WHERE NOT EXISTS (SELECT * FROM Cities_Stores WHERE Cities_Stores.store_type = Stores.store_type);

EsempiEsempi Quali Quali tipi di negozitipi di negozi sono presenti in TUTTE le città? sono presenti in TUTTE le città?

SELECT DISTINCT store_type FROM Stores WHERE NOT EXISTS ( SELECT * FROM Cities WHERE NOT EXISTS ( SELECT * FROM Cities_Stores WHERE Cities_Stores.city = Cities.city AND Cities_Stores.store_type = Stores.store_type));

Doppio NOT EXISTS. Ha una clausola NOT EXISTS dentro una Doppio NOT EXISTS. Ha una clausola NOT EXISTS dentro una clausola NOT EXISTS. clausola NOT EXISTS.

Nell’output non esiste una città che non ha un tipo di negozio Nell’output non esiste una città che non ha un tipo di negozio (store) dei tipi elencati.(store) dei tipi elencati.

Sottoquery a Colonne Sottoquery a Colonne multiplemultiple

Sottoquery a Colonne Sottoquery a Colonne multiplemultiple

Visualizzare: id ordine, id prodotto, e quantità nella Visualizzare: id ordine, id prodotto, e quantità nella tabella item dove id prodotto e quantità coincidono tabella item dove id prodotto e quantità coincidono entrambi con id prodotto e quantità di un elemento entrambi con id prodotto e quantità di un elemento nell’ordine 605.nell’ordine 605.

mysql> SELECT ordid, prodid, qty -> FROM item -> WHERE (prodid, qty) IN -> (SELECT prodid, qty -> FROM item -> WHERE ordid = 605) -> AND ordid <> 605;

mysql> SELECT a.ename, a.sal, a.deptno, b.salavg -> FROM emp a, (SELECT deptno, avg(sal) salavg -> FROM emp -> GROUP BY deptno) b -> WHERE a.deptno = b.deptno -> AND a.sal > b.salavg;

Uso di una sottoquery Uso di una sottoquery nella clausola FROMnella clausola FROM

Uso di una sottoquery Uso di una sottoquery nella clausola FROMnella clausola FROM

EXPLAINEXPLAIN

EXPLAIN EXPLAIN tbl_nametbl_name

OppureOppure

EXPLAIN SELECT EXPLAIN SELECT select_optionsselect_options

EXPLAINEXPLAIN

Consente di capire le performance di Consente di capire le performance di una query e mostra quali indici una query e mostra quali indici effettivamente la query sta usando.effettivamente la query sta usando.

Funzioni SQLFunzioni SQLFunzioni SQLFunzioni SQL

FunzioniFunzioniInputInput

arg 1arg 1

arg 2arg 2

arg arg nn

ElaborazioneElaborazione

OutputOutput

Valori dei Valori dei RisultatiRisultati

Due Tipi di Funzioni SQL Due Tipi di Funzioni SQL Due Tipi di Funzioni SQL Due Tipi di Funzioni SQL

FunzioniFunzioni

FunzioniFunzioniSingle-row Single-row

Funzioni Funzioni Multiple-rowMultiple-row

FunzioniFunzioniFunzioniFunzioni

ConversionConversionee

StringheStringhe

NumeriNumeri

DateDate

GeneralGeneraliiFunzioniFunzioni

(Single-Row)(Single-Row)

Operatori di confrontoOperatori di confronto = , <> != , <= < >= , > <=> (NULL-safe), IS NULL, IS NOT NULL = , <> != , <= < >= , > <=> (NULL-safe), IS NULL, IS NOT NULL expr BETWEEN min AND max expr BETWEEN min AND max expr NOT BETWEEN min AND max expr NOT BETWEEN min AND max

Equivalente a NOT (expr BETWEEN min AND max). Equivalente a NOT (expr BETWEEN min AND max). expr IN (value,...) expr IN (value,...) expr NOT IN (value,...) expr NOT IN (value,...)

Equivalente a NOT (expr IN (value,...)). Equivalente a NOT (expr IN (value,...)). ISNULL(expr) ISNULL(expr) COALESCE(list) COALESCE(list)

Ritorna il primo elemento non-NULL nella lista:Ritorna il primo elemento non-NULL nella lista:mysql> SELECT COALESCE(NULL,1); -> 1 mysql> SELECT COALESCE(NULL,NULL,NULL); -> NULL

INTERVAL(N,N1,N2,N3,...) INTERVAL(N,N1,N2,N3,...) Ritorna 0 se N < N1, 1 se N < N2 ecc.o -1 se N è NULL. N1 < N2 < N3 < ... < Nn Ritorna 0 se N < N1, 1 se N < N2 ecc.o -1 se N è NULL. N1 < N2 < N3 < ... < Nn

mysql> SELECT INTERVAL(23, 1, 15, 17, 30, 44, 200); -> 3 mysql> SELECT INTERVAL(10, 1, 10, 100, 1000); -> 2 mysql> SELECT INTERVAL(22, 23, 30, 44, 200); -> 0

Controllo di flussoControllo di flusso CASE value WHEN [compare-value] THEN result [WHEN [compare-value] THEN

result ...] [ELSE result] END CASE WHEN [condition] THEN result [WHEN [condition] THEN result ...] [ELSE result]

END

mysql> SELECT CASE 1 WHEN 1 THEN "one" WHEN 2 THEN "two" ELSE "more" END; -> "one" mysql> SELECT CASE WHEN 1>0 THEN "true" ELSE "false" END; -> "true" mysql> SELECT CASE BINARY "B" WHEN "a" THEN 1 WHEN "b" THEN 2 END; -> NULL

IF(expr1,expr2,expr3)

mysql> SELECT IF(1>2,2,3); -> 3 mysql> SELECT IF(1<2,'yes','no'); -> 'yes' mysql> SELECT IF(STRCMP('test','test1'),'no','yes'); -> 'no'

Altre funzioniAltre funzioni

IFNULL(expr1,expr2) NULLIF(expr1,expr2)

Funzioni su StringheFunzioni su StringheFunzioni su StringheFunzioni su Stringhe

FFununzzionioniisu stringhesu stringhe

LOWERLOWER

UPPERUPPER

INITCAPINITCAP

CONCATCONCAT

SUBSTRSUBSTR

LENGTHLENGTH

INSTRINSTR

LPADLPAD

TRIMTRIM

RIGHTRIGHT

FunzioniFunzioniConversioni Conversioni CaseCase

Funzioni di Funzioni di Manipolazione StringheManipolazione Stringhe

Funzioni di manipolazione Funzioni di manipolazione stringhestringhe

ASCII(str) ASCII(str) BIN(N) BIN(N) BIT_LENGTH(str) BIT_LENGTH(str) CHAR(N,...) CHAR(N,...) CHAR_LENGTH(str) CHAR_LENGTH(str) CHARACTER_LENGTH(str) CHARACTER_LENGTH(str)

CHARACTER_LENGTH() sinonimo di CHARACTER_LENGTH() sinonimo di CHAR_LENGTH(). CHAR_LENGTH().

COMPRESS(string_to_compress) COMPRESS(string_to_compress)

CONCAT(str1,str2,...) CONCAT(str1,str2,...) Ritorna la stringa risultato della concatenazione delle stringhe contenute come argomento. Ritorna la stringa risultato della concatenazione delle stringhe contenute come argomento.

Restituisce NULL se uno qualisasi degli argomenti è NULL.Restituisce NULL se uno qualisasi degli argomenti è NULL.

mysql> SELECT CONCAT(‘apulvirenti', ‘@', ‘dmi.unict.it'); -> ‘[email protected]'

mysql> SELECT CONCAT('My', NULL, 'QL'); -> NULLmysql> SELECT CONCAT(14.3); -> '14.3'

CONCAT_WS(separator, str1, str2,...) CONCAT_WS(separator, str1, str2,...) CONV(N,from_base,to_base) CONV(N,from_base,to_base)

Converte numeri tra due differenti basi. Ritorna NULL se uno dei due argomenti è NULL.Converte numeri tra due differenti basi. Ritorna NULL se uno dei due argomenti è NULL.

mysql> SELECT CONV("a",16,2); -> '1010' mysql> SELECT CONV("6E",18,8); -> '172' mysql> SELECT CONV(-17,10,-18); -> '-H' mysql> SELECT CONV(10+"10"+'10'+0xa,10,10); -> '40'

ELT(N,str1,str2,str3,...) ELT(N,str1,str2,str3,...) Ritorna str1 se N = 1, str2 if N = 2, ecc. Ritorna NULL se N è minore di 1 o maggiore del Ritorna str1 se N = 1, str2 if N = 2, ecc. Ritorna NULL se N è minore di 1 o maggiore del

numero di argomenti.numero di argomenti.

mysql> SELECT ELT(1, 'ej', 'Heja', 'hej', 'foo'); -> 'ej' mysql> SELECT ELT(4, 'ej', 'Heja', 'hej', 'foo'); -> 'foo'

FIELD(str,str1,str2,str3,...) FIELD(str,str1,str2,str3,...) Complementare di ELT(). Ritorna l’indice della stringa str in str1, Complementare di ELT(). Ritorna l’indice della stringa str in str1,

str2,ecc. Ritorna 0 se non viene trovata.str2,ecc. Ritorna 0 se non viene trovata.mysql> SELECT FIELD('ej', 'Hej', 'ej', 'Heja', 'hej', 'foo'); -> 2 mysql> SELECT FIELD('ej', 'Hej', 'ej', 'Heja', 'hej', 'foo'); -> 2 mysql> SELECT FIELD('fo', 'Hej', 'ej', 'Heja', 'hej', 'foo'); -> 0 mysql> SELECT FIELD('fo', 'Hej', 'ej', 'Heja', 'hej', 'foo'); -> 0

FIND_IN_SET(str,strlist) FIND_IN_SET(str,strlist) HEX(N_or_S) HEX(N_or_S)

INSERT(str,pos,len,newstr) INSERT(str,pos,len,newstr) mysql> SELECT INSERT('Quadratic', 3, 4, 'What'); -> 'QuWhattic' mysql> SELECT INSERT('Quadratic', 3, 4, 'What'); -> 'QuWhattic'

INSTR(str,substr) INSTR(str,substr) mysql> SELECT INSTR('foobarbar', 'bar'); -> 4 mysql> SELECT INSTR('foobarbar', 'bar'); -> 4 mysql> SELECT INSTR('xbar', 'foobar'); -> 0 mysql> SELECT INSTR('xbar', 'foobar'); -> 0

LCASE(str) – UCASE(str)LCASE(str) – UCASE(str) Sinonimo di LOWER() – UPPER(). Sinonimo di LOWER() – UPPER().

LEFT(str,len) LEFT(str,len) mysql> SELECT LEFT('foobarbar', 5); -> 'fooba' mysql> SELECT LEFT('foobarbar', 5); -> 'fooba'

LENGTH(str) LENGTH(str) mysql> SELECT LENGTH('text'); -> 4 mysql> SELECT LENGTH('text'); -> 4

LOCATE(substr,str) LOCATE(substr,str) LOCATE(substr,str,pos) LOCATE(substr,str,pos) LPAD(str,len,padstr) LPAD(str,len,padstr)

mysql> SELECT LPAD('hi',4,'??'); -> '??mysql> SELECT LPAD('hi',4,'??'); -> '??hi' hi'

LTRIM(str) LTRIM(str) mysql> SELECT LTRIM(' barbar'); -> mysql> SELECT LTRIM(' barbar'); ->

'barbar' 'barbar'

POSITION(substr IN str) POSITION(substr IN str) Sinonimo di LOCATE(substr,str). Sinonimo di LOCATE(substr,str).

QUOTE(str) QUOTE(str) REPEAT(str,count) REPEAT(str,count)

mysql> SELECT REPEAT('MySQL', 3); -> mysql> SELECT REPEAT('MySQL', 3); -> 'MySQLMySQLMySQL' 'MySQLMySQLMySQL'

REPLACE(str,from_str,to_str) REPLACE(str,from_str,to_str) mysql> SELECT REPLACE('www.mysql.com', mysql> SELECT REPLACE('www.mysql.com',

'w', 'Ww'); -> 'WwWwWw.mysql.com' 'w', 'Ww'); -> 'WwWwWw.mysql.com' REVERSE(str) REVERSE(str)

mysql> SELECT REVERSE('abc'); -> 'cba‘.mysql> SELECT REVERSE('abc'); -> 'cba‘.

RIGHT(str,len) RIGHT(str,len) mysql> SELECT RIGHT('foobarbar', 4); -> 'rbar‘. mysql> SELECT RIGHT('foobarbar', 4); -> 'rbar‘.

RPAD(str,len,padstr) RPAD(str,len,padstr) mysql> SELECT RPAD('hi',5,'?'); -> 'hi???' mysql> SELECT RPAD('hi',5,'?'); -> 'hi???'

RTRIM(str) RTRIM(str) mysql> SELECT RTRIM('barbar '); -> 'barbar'mysql> SELECT RTRIM('barbar '); -> 'barbar'

Funzioni di confronto tra Funzioni di confronto tra stringhestringhe

STRCMP(expr1,expr2) STRCMP(expr1,expr2) STRCMP() ritorna 0 se le due stringhe STRCMP() ritorna 0 se le due stringhe

coincidono, -1 se il primo argomento è minore coincidono, -1 se il primo argomento è minore del secondo, 1 altrimenti.del secondo, 1 altrimenti.

mysql> SELECT STRCMP('text', 'text2'); mysql> SELECT STRCMP('text', 'text2');

-> -1 -> -1 mysql> SELECT STRCMP('text2', 'text'); mysql> SELECT STRCMP('text2', 'text'); -> 1 -> 1 mysql> SELECT STRCMP('text', 'text'); mysql> SELECT STRCMP('text', 'text'); -> 0-> 0

expr LIKE pat [ESCAPE 'escape-char'] Ritorna 1 expr LIKE pat [ESCAPE 'escape-char'] Ritorna 1 (TRUE) o 0 (FALSE). (TRUE) o 0 (FALSE).

mysql> SELECT 'David!' LIKE 'David_'; mysql> SELECT 'David!' LIKE 'David_';

-> 1 -> 1

mysql> SELECT 'David!' LIKE '%D%v%'; mysql> SELECT 'David!' LIKE '%D%v%';

-> 1 -> 1

mysql> SELECT 'David!' LIKE 'David\_'; mysql> SELECT 'David!' LIKE 'David\_';

-> 0 -> 0

mysql> SELECT 'David_' LIKE 'David\_'; mysql> SELECT 'David_' LIKE 'David\_';

-> 1-> 1

Per specificare un carattere di ESCAPE diverso da \:Per specificare un carattere di ESCAPE diverso da \:

mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|'; mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|';

-> 1 -> 1

Funzioni di confronto tra Funzioni di confronto tra stringhestringhe

MATCH (col1,col2,...) AGAINST (expr [IN MATCH (col1,col2,...) AGAINST (expr [IN BOOLEAN MODE | WITH QUERY EXPANSION] )BOOLEAN MODE | WITH QUERY EXPANSION] )

MATCH ... AGAINST() è utilizzata per ricerche MATCH ... AGAINST() è utilizzata per ricerche full text, ritorna la rilevanza tra il testo che si full text, ritorna la rilevanza tra il testo che si trova nelle colonne (col1,col2,...) e la query expr. trova nelle colonne (col1,col2,...) e la query expr. La similarità è un valore positivo in virgola La similarità è un valore positivo in virgola mobile.mobile.

mysql> CREATE TABLE articles ( mysql> CREATE TABLE articles ( -> id INT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY, -> id INT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY, -> title VARCHAR(200), -> title VARCHAR(200), -> body TEXT, -> body TEXT, -> FULLTEXT (title,body) -> FULLTEXT (title,body) -> ); -> ); Query OK, 0 rows affected (0.00 sec) Query OK, 0 rows affected (0.00 sec)

mysql> INSERT INTO articles (title,body) VALUES mysql> INSERT INTO articles (title,body) VALUES -> ('MySQL Tutorial','DBMS stands for DataBase ...'), -> ('MySQL Tutorial','DBMS stands for DataBase ...'), -> ('How To Use MySQL Efficiently','After you went through a ...'), -> ('How To Use MySQL Efficiently','After you went through a ...'), -> ('Optimizing MySQL','In this tutorial we will show ...'), -> ('Optimizing MySQL','In this tutorial we will show ...'), -> ('1001 MySQL Tricks','1. Never run mysqld as root. 2. ...'), -> ('1001 MySQL Tricks','1. Never run mysqld as root. 2. ...'), -> ('MySQL vs. YourSQL','In the following database comparison ...'), -> ('MySQL vs. YourSQL','In the following database comparison ...'), -> ('MySQL Security','When configured properly, MySQL ...'); -> ('MySQL Security','When configured properly, MySQL ...');

Query OK, 6 rows affected (0.00 sec) Records: 6 Duplicates: 0 Warnings: 0 Query OK, 6 rows affected (0.00 sec) Records: 6 Duplicates: 0 Warnings: 0

mysql> SELECT id, MATCH (title,body) AGAINST ('Tutorial') mysql> SELECT id, MATCH (title,body) AGAINST ('Tutorial') -> FROM articles; -> FROM articles;

+----+-----------------------------------------+ +----+-----------------------------------------+ | id | MATCH (title,body) AGAINST ('Tutorial') | | id | MATCH (title,body) AGAINST ('Tutorial') | +----+-----------------------------------------+ +----+-----------------------------------------+ | 1 | 0.64840710366884 | | 1 | 0.64840710366884 | | 2 | 0 | | 2 | 0 | | 3 | 0.66266459031789 | | 3 | 0.66266459031789 | | 4 | 0 | | 4 | 0 | | 5 | 0 | | 5 | 0 | | 6 | 0 | | 6 | 0 | +----+-----------------------------------------+ +----+-----------------------------------------+ 6 rows in set (0.00 sec) 6 rows in set (0.00 sec)

mysql> SELECT id, body, MATCH (title,body) AGAINST mysql> SELECT id, body, MATCH (title,body) AGAINST -> ('Security implications of running MySQL as root') AS score -> ('Security implications of running MySQL as root') AS score -> FROM articles WHERE MATCH (title,body) AGAINST -> FROM articles WHERE MATCH (title,body) AGAINST -> ('Security implications of running MySQL as root'); -> ('Security implications of running MySQL as root');

+----+-------------------------------------+-----------------+ +----+-------------------------------------+-----------------+ | id | body | score | | id | body | score | +----+-------------------------------------+-----------------+ +----+-------------------------------------+-----------------+ | 4 | 1. Never run mysqld as root. 2. ... | 1.5055546709332 | | 4 | 1. Never run mysqld as root. 2. ... | 1.5055546709332 | | 6 | When configured properly, MySQL ... | 1.31140957288 | | 6 | When configured properly, MySQL ... | 1.31140957288 | +----+-------------------------------------+-----------------+ +----+-------------------------------------+-----------------+ 2 rows in set (0.00 sec) 2 rows in set (0.00 sec)

mysql> SELECT * FROM articles WHERE MATCH (title,body) mysql> SELECT * FROM articles WHERE MATCH (title,body) -> AGAINST ('+MySQL -YourSQL' IN BOOLEAN MODE); -> AGAINST ('+MySQL -YourSQL' IN BOOLEAN MODE);

+----+------------------------------+-------------------------------------+ +----+------------------------------+-------------------------------------+ | id | title | body || id | title | body |+----+------------------------------+-------------------------------------+ +----+------------------------------+-------------------------------------+ | 1 | MySQL Tutorial | DBMS stands for DataBase ... || 1 | MySQL Tutorial | DBMS stands for DataBase ... || 2 | How To Use MySQL Efficiently | After you went through a ... || 2 | How To Use MySQL Efficiently | After you went through a ... || 3 | Optimizing MySQL | In this tutorial we will show ... || 3 | Optimizing MySQL | In this tutorial we will show ... || 4 | 1001 MySQL Tricks | 1. Never run mysqld as root. 2. ... || 4 | 1001 MySQL Tricks | 1. Never run mysqld as root. 2. ... || 6 | MySQL Security | When configured properly, MySQL ... | | 6 | MySQL Security | When configured properly, MySQL ... | +----+------------------------------+-------------------------------------+ +----+------------------------------+-------------------------------------+

Questa query restituisce tutte le righe che contengono la Questa query restituisce tutte le righe che contengono la parola “MySQL” e non contengono la parola “YourSQL”.parola “MySQL” e non contengono la parola “YourSQL”.

Funzioni matematicheFunzioni matematiche

ABS(X)ABS(X) FLOOR(X), CEILING(X)FLOOR(X), CEILING(X) SIN(X), COS(X)…SIN(X), COS(X)… LN(X), LOG(X), LOG(B,X)LN(X), LOG(X), LOG(B,X) Ecc.Ecc.

Operatori logiciOperatori logici NOT (! )NOT (! ) AND (&& ) AND (&& ) OR (|| ) OR (|| ) XOR XOR

ViewView

CREATE CREATE [OR REPLACE] [OR REPLACE] [ALGORITHM = {UNDEFINED | MERGE | [ALGORITHM = {UNDEFINED | MERGE | TEMPTABLE}] TEMPTABLE}] [DEFINER = { [DEFINER = { useruser | CURRENT_USER }] [SQL | CURRENT_USER }] [SQL SECURITY { DEFINER | INVOKER }] VIEW SECURITY { DEFINER | INVOKER }] VIEW view_nameview_name [( [(column_listcolumn_list)] )] AS AS select_statementselect_statement [WITH [CASCADED | LOCAL] CHECK OPTION] [WITH [CASCADED | LOCAL] CHECK OPTION]

CREATE CREATE [OR REPLACE] [OR REPLACE] [ALGORITHM = {UNDEFINED | MERGE | [ALGORITHM = {UNDEFINED | MERGE | TEMPTABLE}] TEMPTABLE}] [DEFINER = { [DEFINER = { useruser | CURRENT_USER }] [SQL | CURRENT_USER }] [SQL SECURITY { DEFINER | INVOKER }] VIEW SECURITY { DEFINER | INVOKER }] VIEW view_nameview_name [( [(column_listcolumn_list)] )] AS AS select_statementselect_statement [WITH [CASCADED | LOCAL] CHECK OPTION] [WITH [CASCADED | LOCAL] CHECK OPTION]

Definizione di stored Definizione di stored procedureprocedure

Una stored routine è costituita o da una Una stored routine è costituita o da una procedura o da una funzioneprocedura o da una funzione

Una stored procedure è costituita da un insieme Una stored procedure è costituita da un insieme di istruzioni SQL che vengono memorizzate nel di istruzioni SQL che vengono memorizzate nel server con un nome identificativo, può essere server con un nome identificativo, può essere invocata con CALL e torna indietro valori usando invocata con CALL e torna indietro valori usando le variabili di outputle variabili di output

Una stored function può essere chiamata Una stored function può essere chiamata mediante il solo nome, e può ritornare un valore mediante il solo nome, e può ritornare un valore scalarescalare

Delle stored routines possono chiamare altre Delle stored routines possono chiamare altre stored routinesstored routines

ProprietàProprietà Una stored routine è associata ad un particolare Una stored routine è associata ad un particolare

database, e questo vuol dire che:database, e questo vuol dire che:1.1. Quando viene invocata, implicitamente viene eseguito Quando viene invocata, implicitamente viene eseguito

USE <database>, non sono ammessi USE all’interno USE <database>, non sono ammessi USE all’interno della routinedella routine

2.2. E’ possibile riferirsi ad una routine non presente nel E’ possibile riferirsi ad una routine non presente nel database corrente prefissandola con il nome del suo database corrente prefissandola con il nome del suo databasedatabase

3.3. Il DROP del db provoca il DROP delle routine associateIl DROP del db provoca il DROP delle routine associate Se non indicato diversamente le SR sono Se non indicato diversamente le SR sono

associate al DB di defaultassociate al DB di default

Perché usare una SR?Perché usare una SR?

Girano in qualsiasi ambiente. Dato che sono Girano in qualsiasi ambiente. Dato che sono sul server del DB, non dipendono sul server del DB, non dipendono dall’applicativo che le usa e dal linguaggio dall’applicativo che le usa e dal linguaggio di programmazione. L’aggiornamento di di programmazione. L’aggiornamento di una SR aggiorna la logica di funzionamento una SR aggiorna la logica di funzionamento del DB senza la necessità di modificare i del DB senza la necessità di modificare i clientclient

Possono ridurre il traffico di rete, Possono ridurre il traffico di rete, utilizzando dei result set direttamente sul utilizzando dei result set direttamente sul DB senza muoverli verso il client per DB senza muoverli verso il client per l’elaborazione.l’elaborazione.

SintassiSintassi

CREATECREATE [[DEFINERDEFINER = { user | = { user | CURRENT_USERCURRENT_USER }] }] PROCEDUREPROCEDURE sp_name ([proc_parameter[,...]]) sp_name ([proc_parameter[,...]]) [characteristic ...] routine_body[characteristic ...] routine_body

CREATECREATE [[DEFINERDEFINER = { user | = { user | CURRENT_USERCURRENT_USER }] }] FUNCTIONFUNCTION sp_name ([func_parameter[,...]]) sp_name ([func_parameter[,...]]) RETURNSRETURNS type type [characteristic ...] routine_body[characteristic ...] routine_body

Esempio di proceduraEsempio di proceduraDELIMITERDELIMITER // //

CREATECREATE PROCEDUREPROCEDURE simpleproc ( simpleproc (OUTOUT param1 int) param1 int)BEGINBEGIN

SELECTSELECT COUNTCOUNT(*) (*) INTOINTO param1 param1 FROMFROM imp; imp;ENDEND;;////

DELIMITERDELIMITER ; ;

CALLCALL simpleproc(@a); simpleproc(@a);

SELECTSELECT @a; @a;

OsservazioniOsservazioni DELIMITER cambia il “terminatore” di linea da ; a //, in DELIMITER cambia il “terminatore” di linea da ; a //, in

modo che sia possibile usare ; nella definizione della modo che sia possibile usare ; nella definizione della procedura e non venga interpretato da mysqlprocedura e non venga interpretato da mysql

La procedura torna un risultato tramite l’unico parametro La procedura torna un risultato tramite l’unico parametro definito, che è un parametro di uscita. Il parametro viene definito, che è un parametro di uscita. Il parametro viene riempito dalla istruzione CALL, e letto tramite una riempito dalla istruzione CALL, e letto tramite una semplice SELECTsemplice SELECT

E’ possibile avere procedure molto più complesseE’ possibile avere procedure molto più complesse Per ottenere informazioni a proposito delle procedure:Per ottenere informazioni a proposito delle procedure:

SHOW PROCEDURE STATUSSHOW PROCEDURE STATUS;;SHOW CREATE PROCEDURESHOW CREATE PROCEDURE <nome>; <nome>;

Procedura complessaProcedura complessaDELIMITER //DELIMITER //CREATE PROCEDURE procedura1 (param1 INT, param2 CHAR(3),CREATE PROCEDURE procedura1 (param1 INT, param2 CHAR(3), OUT param3 INT)OUT param3 INT)BEGINBEGIN DECLARE finito INT default 0;DECLARE finito INT default 0; DECLARE a INT;DECLARE a INT; DECLARE b CHAR(50);DECLARE b CHAR(50); DECLARE cur1 CURSOR FOR SELECT id,nomeDECLARE cur1 CURSOR FOR SELECT id,nome FROM clienti WHERE cat = param2;FROM clienti WHERE cat = param2; DECLARE CONTINUE HANDLER FOR SQLSTATE '02000'DECLARE CONTINUE HANDLER FOR SQLSTATE '02000' SET finito = 1;SET finito = 1; OPEN cur1;OPEN cur1; SET param3 = 0;SET param3 = 0; FETCH cur1 INTO a,b;FETCH cur1 INTO a,b; ciclo: WHILE NOT finito DOciclo: WHILE NOT finito DO IF param3 < param1 THENIF param3 < param1 THEN SET param3 = param3 + 1;SET param3 = param3 + 1; FETCH cur1 INTO a,b;FETCH cur1 INTO a,b; ELSEELSE LEAVE ciclo;LEAVE ciclo; END IF;END IF; END WHILE ciclo;END WHILE ciclo;END; //END; //DELIMITER ;DELIMITER ;

AnalisiAnalisiDELIMITERDELIMITER // //

Dice al server che l’istruzione di CREATE non termina con il ; che invece mi Dice al server che l’istruzione di CREATE non termina con il ; che invece mi serve all’interno delle Stored Procedureserve all’interno delle Stored Procedure

CREATE PROCEDURECREATE PROCEDURE procedura1 (param1 INT, param2 CHAR(3), procedura1 (param1 INT, param2 CHAR(3), OUTOUT param3 INT) param3 INT)

La procedura ha come nome La procedura ha come nome procedura1, procedura1, e usa tre parametri, i primi due di e usa tre parametri, i primi due di input e l’ultimo di outputinput e l’ultimo di output

BEGINBEGIN

ENDEND

Il codice da eseguire deve essere delimitato da BEGIN e ENDIl codice da eseguire deve essere delimitato da BEGIN e END

AnalisiAnalisiDECLAREDECLARE finito INT default 0; finito INT default 0;

DECLAREDECLARE a INT; a INT;

DECLAREDECLARE b CHAR(50); b CHAR(50);

Definiamo tre variabili da usare all’interno della routine, una di queste inizializzata con Definiamo tre variabili da usare all’interno della routine, una di queste inizializzata con un defaultun default

DECLAREDECLARE cur1 cur1 CURSOR FOR SELECT CURSOR FOR SELECT id,nomeid,nome

FROMFROM clienti clienti WHEREWHERE cat = param2; cat = param2;

Definiamo un “cursore”Definiamo un “cursore”

DECLARE CONTINUE HANDLER FOR SQLSTATE DECLARE CONTINUE HANDLER FOR SQLSTATE '02000''02000'

SETSET finito = 1; finito = 1;

Definiamo un “handler” che non interrompe l’esecuzione se si verifica la condizione Definiamo un “handler” che non interrompe l’esecuzione se si verifica la condizione indicataindicata

L’ordine delle dichiarazioni è importante, deve essere quello qui illustrato!L’ordine delle dichiarazioni è importante, deve essere quello qui illustrato!

AnalisiAnalisiOPENOPEN cur1; cur1;

SETSET param3 = 0; param3 = 0;

Questa è la prima vera operazione, l’apertura del cursore. In questo modo Questa è la prima vera operazione, l’apertura del cursore. In questo modo viene eseguita la select, che costituisce il corpo del cursore. Inizializziamo viene eseguita la select, che costituisce il corpo del cursore. Inizializziamo il parametro di output e passiamo allail parametro di output e passiamo alla

FETCHFETCH cur1 cur1 INTOINTO a,b; a,b;

Con questa operazione il cursore legge la prima riga tornata dalla select, e Con questa operazione il cursore legge la prima riga tornata dalla select, e scrive i valori trovati nelle variabili a e b. Fatta questa operazione il scrive i valori trovati nelle variabili a e b. Fatta questa operazione il “cursore” si sposta sul secondo risultato trovato, che tornerà alla “cursore” si sposta sul secondo risultato trovato, che tornerà alla successiva fetch. successiva fetch.

Notare che la prima fetch è esterna al ciclo, per gestire il caso di tabella senza Notare che la prima fetch è esterna al ciclo, per gestire il caso di tabella senza righe.righe.

I cursori sono READ ONLY, e NOT SCROLLABLEI cursori sono READ ONLY, e NOT SCROLLABLE

AnalisiAnalisiciclo: ciclo: WHILE NOT WHILE NOT finito finito DODOEND WHILEEND WHILE ciclo; ciclo;

Segue un ciclo di elaborazione, che viene eseguito fino a che il valore di “finito” è falso Segue un ciclo di elaborazione, che viene eseguito fino a che il valore di “finito” è falso (ossia =0 come inizializzato). Tale valore cambia nel momento in cui il cursore ha (ossia =0 come inizializzato). Tale valore cambia nel momento in cui il cursore ha fatto la fetch dell’ultima riga tornata dalla select, e non ha righe su cui spostarsi: in fatto la fetch dell’ultima riga tornata dalla select, e non ha righe su cui spostarsi: in quel momento infatti il SQLSTATE ha valore ‘02000’, e l’handler che abbiamo definito quel momento infatti il SQLSTATE ha valore ‘02000’, e l’handler che abbiamo definito cambia il valore della variabile in 1.cambia il valore della variabile in 1.

IFIF param3 < param1 param3 < param1 THENTHENSETSET param3 = param3 + 1; param3 = param3 + 1;

FETCHFETCH cur1 cur1 INTOINTO a,b; a,b;ELSEELSE

LEAVELEAVE ciclo; ciclo;END IFEND IF;;

Infine all’interno del ciclo si verifica che la variabile param3 abbia raggiunto param1, e in Infine all’interno del ciclo si verifica che la variabile param3 abbia raggiunto param1, e in tal caso con LEAVE si abbandona il ciclo stesso. Se non lo ha raggiunto si effettua tal caso con LEAVE si abbandona il ciclo stesso. Se non lo ha raggiunto si effettua un’altra FETCH del cursore. Nell’esempio non uso a e b, ma potrei farlo...un’altra FETCH del cursore. Nell’esempio non uso a e b, ma potrei farlo...

AnalisiAnalisiIl ciclo quindo termina o quando si è verificata la condizione Il ciclo quindo termina o quando si è verificata la condizione

sui parametri, oppure quando il cursore si è esaurito, e al sui parametri, oppure quando il cursore si è esaurito, e al termine della esecuzione il parametro di output conterrà il termine della esecuzione il parametro di output conterrà il numero di righe lette.numero di righe lette.

Riassumendo in una SP si possono trovare le definizioni di :Riassumendo in una SP si possono trovare le definizioni di :1.1. Variabili (declare, in, out)Variabili (declare, in, out)2.2. Condizioni (sqlstate)Condizioni (sqlstate)3.3. CursoriCursori4.4. HandlerHandler

Si possono usare nel codice:Si possono usare nel codice:1.1. VariabiliVariabili2.2. CursoriCursori3.3. Controllo di flusso (if, loop, repeat, while, iterate, leave)Controllo di flusso (if, loop, repeat, while, iterate, leave)

ModificaModifica

Una procedura può essere eliminata conUna procedura può essere eliminata con

DROP PROCEDUREDROP PROCEDURE <nome> <nome>

E’ possibile modificare i suoi permessi con E’ possibile modificare i suoi permessi con

ALTER PROCEDUREALTER PROCEDURE <nome> SQL SECURITY { DEFINER | INVOKER } <nome> SQL SECURITY { DEFINER | INVOKER }

Nel caso DEFINER è l’utente che ha definito la procedura a dover Nel caso DEFINER è l’utente che ha definito la procedura a dover avere i permessi necessari alla sua esecuzione, nel caso avere i permessi necessari alla sua esecuzione, nel caso INVOKER è invece l’utente che la esegue.INVOKER è invece l’utente che la esegue.

Stored FunctionsStored Functions Rispetto alla definizione delle procedure si aggiunge la Rispetto alla definizione delle procedure si aggiunge la

capacità di tornare un valore con la clausola RETURN, e i capacità di tornare un valore con la clausola RETURN, e i parametri sono esclusivamente in input.parametri sono esclusivamente in input.

E’ obbligatorio tornare un valore!E’ obbligatorio tornare un valore!

drop function drop function funz2;funz2;

DELIMITERDELIMITER // //

CREATECREATE functionfunction funz2(codFis char(16)) funz2(codFis char(16)) returnsreturns decimal decimal

BEGINBEGIN

DECLAREDECLARE c c INTINT defaultdefault 0; 0;

selectselect stipendio stipendio intointo c c FROMFROM impiegati impiegati

wherewhere cf=codFis; cf=codFis;

returnreturn c + 3*c; c + 3*c;

ENDEND;;

////

DELIMITERDELIMITER ; ;

ESERCIZIOESERCIZIO Scrivere una stored procedure che somma tutti gli stipendi degli impiegati.Scrivere una stored procedure che somma tutti gli stipendi degli impiegati.

DELIMITER //DELIMITER //CREATE PROCEDURE p25 (OUT return_val INT)CREATE PROCEDURE p25 (OUT return_val INT)BEGINBEGINDECLARE a,b INT;DECLARE a,b INT;DECLARE c INT default 0;DECLARE c INT default 0;DECLARE cur_1 CURSOR FOR SELECT stipendio FROM imp;DECLARE cur_1 CURSOR FOR SELECT stipendio FROM imp;DECLARE CONTINUE HANDLER FOR NOT FOUNDDECLARE CONTINUE HANDLER FOR NOT FOUND

SET b = 1;SET b = 1;OPEN cur_1;OPEN cur_1;SET b = 0;SET b = 0;REPEATREPEAT

FETCH cur_1 INTO a;FETCH cur_1 INTO a;if b = 0 thenif b = 0 then

SET c=c+a;SET c=c+a;end if;end if;

UNTIL b = 1UNTIL b = 1END REPEAT;END REPEAT;CLOSE cur_1;CLOSE cur_1;SET return_val = c;SET return_val = c;END;END;////DELIMITER ;DELIMITER ;

ESERCIZIOESERCIZIO Scrivere una stored procedure che inserisca nella tabella Scrivere una stored procedure che inserisca nella tabella

impsede1 tutti i codici degli impiegati della sede 1impsede1 tutti i codici degli impiegati della sede 1

DELIMITERDELIMITER // //CREATE PROCEDURE CREATE PROCEDURE p26 ()p26 ()BEGINBEGINDECLAREDECLARE b INT; b INT;DECLAREDECLARE a char(4); a char(4);DECLAREDECLARE cur_1 cur_1 CURSOR FOR SELECT CURSOR FOR SELECT codimp codimp FROMFROM imp imp WHEREWHERE sede='S01'; sede='S01';DECLARE CONTINUE HANDLER FOR NOT FOUNDDECLARE CONTINUE HANDLER FOR NOT FOUNDSETSET b = 1; b = 1;OPENOPEN cur_1; cur_1;FETCHFETCH cur_1 cur_1 INTOINTO a; a;REPEATREPEATINSERT INTOINSERT INTO corsosql.impSede1 corsosql.impSede1 VALUESVALUES (a); (a); FETCHFETCH cur_1 cur_1 INTOINTO a; a;UNTILUNTIL b = 1 b = 1END REPEATEND REPEAT;;CLOSECLOSE cur_1; cur_1;ENDEND;;////DELIMITERDELIMITER ; ;

TRIGGERSTRIGGERS Sono oggetti associati a tabelle, che vengono attivati nel Sono oggetti associati a tabelle, che vengono attivati nel

momento in cui un determinato evento si verifica in quella momento in cui un determinato evento si verifica in quella tabella.tabella.

Nella definizione del trigger stabiliamo per quale evento Nella definizione del trigger stabiliamo per quale evento deve essere attivato, ossia per inserimento di righe, deve essere attivato, ossia per inserimento di righe, modifiche o cancellazioni, e se deve essere eseguito prima modifiche o cancellazioni, e se deve essere eseguito prima o dopo tale eventoo dopo tale evento

Si hanno dunque i seguenti tipi di trigger:Si hanno dunque i seguenti tipi di trigger:1.1. BEFORE INSERTBEFORE INSERT2.2. BEFORE UPDATEBEFORE UPDATE3.3. BEFORE DELETEBEFORE DELETE4.4. AFTER INSERTAFTER INSERT5.5. AFTER UPDATEAFTER UPDATE6.6. AFTER DELETEAFTER DELETE

SintassiSintassiCREATE CREATE

[[DEFINERDEFINER = { = { useruser | CURRENT_USER }] | CURRENT_USER }]

TRIGGERTRIGGER trigger_nametrigger_name trigger_timetrigger_time trigger_eventtrigger_event

ONON tbl_nametbl_name FOR EACH ROW FOR EACH ROW trigger_bodytrigger_body

La clausola La clausola DEFINERDEFINER specifica se come creatore del trigger deve essere considerato l'utente specifica se come creatore del trigger deve essere considerato l'utente attuale (default) o un altro utente specificato nella forma attuale (default) o un altro utente specificato nella forma nomenome@@hosthost..

trigger_timetrigger_time indica il momento di attivazione del trigger. Esso può essere BEFORE o AFTER indica il momento di attivazione del trigger. Esso può essere BEFORE o AFTER la modifica di ogni riga della tabella a cui è associato il trigger.la modifica di ogni riga della tabella a cui è associato il trigger.

trigger_eventtrigger_event è l’evento che scatena l’esecuzione del trigger. Esso può essere INSERT, è l’evento che scatena l’esecuzione del trigger. Esso può essere INSERT, UPDATE, DELETEUPDATE, DELETE

trigger_bodytrigger_body rappresenta il codice che viene eseguito all’attivazione del trigger. rappresenta il codice che viene eseguito all’attivazione del trigger. Normalmente racchiuso tra BEGIN….END.Normalmente racchiuso tra BEGIN….END.

Anche se associato ad una tabella il trigger deve avere nome univoco all’interno del Anche se associato ad una tabella il trigger deve avere nome univoco all’interno del database.database.

Quando si fa riferimento a inserimenti o cancellazioni di righe, non si intende Quando si fa riferimento a inserimenti o cancellazioni di righe, non si intende necessariamente una istruzione INSERT o DELETE, ma qualsiasi operazione dalla quale necessariamente una istruzione INSERT o DELETE, ma qualsiasi operazione dalla quale scaturisca l’evento interessato (ad esempio il caricamento dei dati da shell)scaturisca l’evento interessato (ad esempio il caricamento dei dati da shell)

EsempioEsempiodelimiterdelimiter // //CREATE TRIGGERCREATE TRIGGER upd_check upd_check BEFORE UPDATE ON BEFORE UPDATE ON accountaccountFOR EACH ROWFOR EACH ROWBEGINBEGIN IFIF NEWNEW.amount < 0 .amount < 0 THENTHEN SET NEWSET NEW.amount = 0;.amount = 0; ELSEIFELSEIF NEWNEW.amount > 100 .amount > 100 THENTHEN SET NEWSET NEW.amount = 100;.amount = 100; END IFEND IF;;ENDEND;//;//delimiterdelimiter ; ;

NEW si riferisce alla nuova riga che sta per essere scritta, in questo caso NEW si riferisce alla nuova riga che sta per essere scritta, in questo caso aggiornata, e si può usare in caso di INSERT e UPDATE.aggiornata, e si può usare in caso di INSERT e UPDATE.

E’ disponibile anche OLD, che si riferisce ai valori precedenti la modifica, e si E’ disponibile anche OLD, che si riferisce ai valori precedenti la modifica, e si può utilizzare nel caso di UPDATE e DELETEpuò utilizzare nel caso di UPDATE e DELETE

La modifica con SET è possibile solo per i valori NEWe nei trigger di tipo La modifica con SET è possibile solo per i valori NEWe nei trigger di tipo BEFOREBEFORE

Attenti con i trigger BEFORE: se l’inserimento non riesce potrebbero lasciare Attenti con i trigger BEFORE: se l’inserimento non riesce potrebbero lasciare dati inconsistentidati inconsistenti

EsempioEsempiodelimiterdelimiter // // CREATE TRIGGER CREATE TRIGGER log_upd log_upd AFTER UPDATE ON AFTER UPDATE ON impiegatiimpiegati FOR EACH ROWFOR EACH ROW BEGINBEGIN DECLAREDECLARE u varchar(40); u varchar(40); select user() into u;select user() into u; insert into TB_LOG values(NULL, NOW(), 'UPDATE', OLD.stipendio, insert into TB_LOG values(NULL, NOW(), 'UPDATE', OLD.stipendio,

NEW.stipendio, u);NEW.stipendio, u); ENDEND;//;// delimiterdelimiter ; ;

TransazioniTransazioni L'uso delle transazioni permette di "consolidare" L'uso delle transazioni permette di "consolidare"

le modifiche alla base dati solo in un momento le modifiche alla base dati solo in un momento ben preciso: dal momento in cui avviamo una ben preciso: dal momento in cui avviamo una transazione, gli aggiornamenti rimangono transazione, gli aggiornamenti rimangono sospesi (e invisibili ad altri utenti) fino a quando sospesi (e invisibili ad altri utenti) fino a quando non li confermiamo (commit); in alternativa alla non li confermiamo (commit); in alternativa alla conferma è possibile annullarli (rollback).conferma è possibile annullarli (rollback).

MySQL gira per default in AUTOCOMMIT mode: MySQL gira per default in AUTOCOMMIT mode: tutti gli aggiornamenti vengono automaticamente tutti gli aggiornamenti vengono automaticamente consolidati nel momento in cui sono eseguiticonsolidati nel momento in cui sono eseguiti

Per iniziare una transazione si deve usare allora Per iniziare una transazione si deve usare allora START TRANSACTION: da questo punto in poi START TRANSACTION: da questo punto in poi tutti gli aggiornamenti rimaranno sospesitutti gli aggiornamenti rimaranno sospesi

SintassiSintassiSTART TRANSACTIONSTART TRANSACTION...istruzioni di aggiornamento (1)......istruzioni di aggiornamento (1)...SAVEPOINTSAVEPOINT sp1; sp1;...istruzioni di aggiornamento (2)......istruzioni di aggiornamento (2)...ROLLBACK TO SAVEPOINT ROLLBACK TO SAVEPOINT sp1;sp1;...istruzioni di aggiornamento (3)......istruzioni di aggiornamento (3)...COMMITCOMMIT

COMMIT conferma le modifiche e chiude la transazione, mentre COMMIT conferma le modifiche e chiude la transazione, mentre ROLLBACK annulla tutti gli aggiornamenti eseguiti nel corso ROLLBACK annulla tutti gli aggiornamenti eseguiti nel corso dell’ultima transazionedell’ultima transazione

COMMIT AND CHAIN provoca l’immediata apertura di una nuova COMMIT AND CHAIN provoca l’immediata apertura di una nuova transazione, COMMIT RELEASE chiude la connessione al servertransazione, COMMIT RELEASE chiude la connessione al server

SET AUTOCOMMIT=0 disabilita l’autocommit: tutti gli SET AUTOCOMMIT=0 disabilita l’autocommit: tutti gli aggiornamenti rimangono in sospeso fino al commitaggiornamenti rimangono in sospeso fino al commit

I SAVEPOINT sono degli stati intermedi ai quali possiamo tornare I SAVEPOINT sono degli stati intermedi ai quali possiamo tornare con un ROLLBACKcon un ROLLBACK

OsservazioniOsservazioni

Su MySQL il tutto funziona solo se si usa Su MySQL il tutto funziona solo se si usa InnoDBInnoDB

NON sono annullabili le operazioni che NON sono annullabili le operazioni che creano, eliminano o alterano la struttura creano, eliminano o alterano la struttura di tabelle e database: è bene evitare di di tabelle e database: è bene evitare di includere in una transazione tali includere in una transazione tali operazioni, che tra l’altro nella maggior operazioni, che tra l’altro nella maggior parte dei casi causano una COMMIT parte dei casi causano una COMMIT implicitaimplicita

SELECTSELECT In alcuni casi è utile utilizzare due clausole particolari In alcuni casi è utile utilizzare due clausole particolari

quando si effettua una select:quando si effettua una select:

SELECTSELECT .... ....FOR UPDATEFOR UPDATE

SELECTSELECT .... ....LOCK IN SHARE MODELOCK IN SHARE MODE

La prima stabilisce un LOCK su tutte le righe lette, che La prima stabilisce un LOCK su tutte le righe lette, che impedirà ad altri utenti di leggerle fino al termine della impedirà ad altri utenti di leggerle fino al termine della nostra transazionenostra transazione

La seconda stabilisce un LOCK che impedisce gli La seconda stabilisce un LOCK che impedisce gli aggiornamenti, garantendo che il contenuto rimarrà aggiornamenti, garantendo che il contenuto rimarrà invariato durante la transazioneinvariato durante la transazione

Livello di isolamentoLivello di isolamento Un aspetto importante relativamente alle transazioni è il livello Un aspetto importante relativamente alle transazioni è il livello

di isolamento al quale vengono effettuate. I livelli possibili sono di isolamento al quale vengono effettuate. I livelli possibili sono quattro, e li elenchiamo in ordine crescente:quattro, e li elenchiamo in ordine crescente:

1.1. READ UNCOMMITTED: a questo livello sono visibili gli aggiornamenti READ UNCOMMITTED: a questo livello sono visibili gli aggiornamenti effettuati da altri utenti anche se non consolidati: è un comportamento effettuati da altri utenti anche se non consolidati: è un comportamento non propriamente transazionale, che può dare seri problemi di non propriamente transazionale, che può dare seri problemi di consistenza dei dati; va utilizzato solo quando non ci sono consistenza dei dati; va utilizzato solo quando non ci sono preoccupazioni di questo tipo e c’è bisogno di velocizzare le letturepreoccupazioni di questo tipo e c’è bisogno di velocizzare le letture

2.2. READ COMMITTED: a questo livello gli aggiornamenti diventano READ COMMITTED: a questo livello gli aggiornamenti diventano visibili solo dopo il consolidamentovisibili solo dopo il consolidamento

3.3. REPETEABLE READ: in questo caso perchè un aggiornamento diventi REPETEABLE READ: in questo caso perchè un aggiornamento diventi visibile deve essere non solo consolidato, ma anche la transazione che visibile deve essere non solo consolidato, ma anche la transazione che legge deve essere terminata; in pratica, la stessa lettura ripetuta legge deve essere terminata; in pratica, la stessa lettura ripetuta all'interno di una transazione darà sempre lo stesso risultato; è la all'interno di una transazione darà sempre lo stesso risultato; è la modalità di defaultmodalità di default

4.4. SERIALIZABLE: come nel caso precedente, ma in più, la semplice SERIALIZABLE: come nel caso precedente, ma in più, la semplice lettura di un dato provoca il blocco degli aggiornamenti fino al lettura di un dato provoca il blocco degli aggiornamenti fino al termine della transazione; in sostanza è come se ogni SELECT venisse termine della transazione; in sostanza è come se ogni SELECT venisse effettuata con la clausola LOCK IN SHARE MODEeffettuata con la clausola LOCK IN SHARE MODE

mysql ___. istallare mysql dal link è fare il download di diverse versioni di mysql: dal link è...

Documents