MySQL
___
Istallare MySQL

Dal link http://dev.mysql.com/ è fare il
download di diverse versioni di MySQL:
Es. MySQL 5.0 per diverse piattaforme tra cui Linux
e Windows;
 Altri tool e driver utili:

MySQL Administrator;
 MySQL Query Browser;
 MySQL Workbench;
 MySQL Connector/J (JDBC).

Sommario




Introduzione a MySQL
Connessione/Disconnessione da un database MySQL
Programmi client.
Esempi di query: database Menagerie
(http://dev.mysql.com/doc/)



SQL in MySQL DDL e DML.
EXPLAIN.
Funzioni.
MySQL AB

Società fondata dagli sviluppatori di MySQL;

MySQL diventa popolare quando viene
presentata la versione 3.23;

L’insieme di feature che offre coincide con ciò
che la maggior parte degli utenti richiede ad un
DBMS.
MySQL 4.0-4.1-5.0

Feature principali:










InnoDB;
Query Cache;
Comando UNION;
Variabili Dinamiche;
FullText Search;
Sub-Queriy e tabelle derivate;
Prepared Statements;
Protocollo di trasmissione client/server binario;
OpenGIS (dati geografici)
Internazionalizzazione, UTF-8.

Stored Procedure
View
Trigger

Pluggable Storage Engine


RDBMS
Server
Tabelle utente
dizionario
dati
Connessione/disconnessione

Per connettersi al server è necessario fornire login e
password
shell> mysql -h host -u user -p
Enter password: ********

host and user rappresentano:

l’hostname dove risiede MySQL;
 lo username di un utente che possiede un account sul server;
-p specifica al server la richiesta della password all’utente.

C:\>mysql -u alfredo -p
Enter 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:
C:\>mysql –help

Per uscire:
mysql> QUIT
Login tramite Query browser
Nome connessione
Schermata principale di
Query Browser
Comandi SQL
SELECT
INSERT
UPDATE
DELETE
Estrazione Dati
Data manipulation language (DML)
CREATE
ALTER DROP
RENAME
Data definition language (DDL)
TRUNCATE
COMMIT
ROLLBACK
SAVEPOINT
controllo Transazioni
GRANT
REVOKE
Data control language (DCL)
Creazione di un account

Tipicamente viene eseguita dall’utente root,
mediante l’uso del comando GRANT.
C:\>mysql -u root -p
Enter password: *******
mysql> GRANT ALL ON nomeDB.* to
-> ‘user’@’localhost’ IDENTIFIED BY
-> ‘nome_password’;
Connessione da un client

Per consentire la connessione da un server specifico.
mysql> GRANT ALL ON nomeDB.* to
-> ‘user’@’nome_server’ IDENTIFIED BY
-> ‘nome_password’;
Esempi
mysql> 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()
-> ,
-> current_date;
+-------------------+--------------+
| user()
| current_date |
+-------------------+--------------+
| alfredo@localhost | 2004-11-02
|
+-------------------+--------------+
1 row in set (0.00 sec)
mysql>
Prompt di MySQL
Prompt
Significato
mysql>
Pronto per ricevere un comando;
->
In attesa della successiva linea per un comando
multiple-line.
'>
In attesa della successiva linea per un comando
multiple-line, apice di apertura nella riga precedente
(`'').
">
In attesa della successiva linea per un comando
multiple-line, doppio apice di apertura nella riga
precedente (`"').
`>
In attesa della successiva linea per un comando
multiple-line , che fa riferimento ad un identificatore
che inizia con backtick (``').
Selezione di un database

Comandi show - use
mysql> show databases;
+----------+
| Database |
+----------+
| alfredo |
| mysql
|
| test
|
+----------+
3 rows in set (0.00 sec)
mysql> use alfredo;
Database changed
SHOW

SHOW ha diverse opzioni e da informazioni riguardo ai database alle tabella, collone,
indici, ecc. Da anche informazioni riguardo il server.
SHOW
SHOW
SHOW
SHOW
SHOW
SHOW
SHOW
SHOW
SHOW
SHOW
SHOW
SHOW
SHOW
SHOW
SHOW
SHOW
SHOW
[FULL] COLUMNS FROM tbl_name [FROM db_name] [LIKE 'pattern']
CREATE DATABASE db_name
CREATE TABLE tbl_name
DATABASES [LIKE 'pattern']
[STORAGE] ENGINES
ERRORS [LIMIT [offset,] row_count]
GRANTS FOR user
INDEX FROM tbl_name [FROM db_name]
INNODB STATUS
[BDB] LOGS
PRIVILEGES
[FULL] PROCESSLIST
STATUS [LIKE 'pattern']
TABLE STATUS [FROM db_name] [LIKE 'pattern']
[OPEN] TABLES [FROM db_name] [LIKE 'pattern']
[GLOBAL | SESSION] VARIABLES [LIKE 'pattern']
WARNINGS [LIMIT [offset,] row_count]
Creazione di un database

L’amministratore crea il database;
mysql> CREATE DATABASE menagerie;

Successivamente l’utente crea le tabelle che desidera:
CREATE TABLE pet ( name VARCHAR(20),
owner VARCHAR(20),
species VARCHAR(20),
sex CHAR(1),
birth DATE,
death DATE );
Describe
mysql> 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: esempi
mysql> 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: esempi
mysql> 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: esempi
mysql> 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: esempi
mysql> 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: esempi
mysql> 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: esempi
mysql> 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: esempi
mysql> 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 seguente
significato: mancante, sconosciuto ed è trattato
diversamente dagli altri valori.
Per testare il valore NULL non possono essere usati gli
operatori di confronto quali =, <, o <>.
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 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 NULL sono
inseriti all’inizio con ASC 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
-> GROUP BY species, sex;
+---------+------+----------+
| species | sex | COUNT(*) |
+---------+------+----------+
| cat
|
f |
1 |
| cat
|
m |
1 |
| dog
|
f |
1 |
| dog
|
m |
2 |
+---------+------+----------+
WHERE species = 'dog' OR species = 'cat'
mysql> CREATE TABLE event (name VARCHAR(20),
->
date DATE,
->
type VARCHAR(15),
->
remark VARCHAR(255));
mysql> SELECT pet.name,
-> (YEAR(date)-YEAR(birth)) (RIGHT(date,5)<RIGHT(birth,5)) AS age,
-> remark
-> FROM pet, event
-> WHERE pet.name = event.name AND type = 'litter';
+--------+------+-----------------------------+
|
name | age |
remark |
+--------+------+-----------------------------+
| Fluffy |
2 | 4 kittens, 3 female, 1 male |
| Buffy |
4 | 5 puppies, 2 female, 3 male |
| Buffy |
5 |
3 puppies, 3 female |
+--------+------+-----------------------------+
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 (1/2)
Tipo
TINYINT[(M)]
SMALLINT [(M)]
MEDIUMINT [(M)]
INT [(M)]
BIGINT [(M)]
Byte
1
2
3
4
8
Minimum Value
Maximum Value
(Signed/Unsigned)
(Signed/Unsigned)
-128
127
0
255
-32768
32767
0
65535
-8388608
8388607
0
16777215
-2147483648
2147483647
0
4294967295
-9223372036854775808
9223372036854775807
0
18446744073709551615
FLOAT[(M,D)]
4
+/-1.175494351E-38
+/- 3.402823466E+38
DOUBLE [(M,D)]
8
+/-2.2250738585072014E-308
+/-1.7976931348623157E+308
Tipi di dati: Numerici (2/2)






INTEGER
DOUBLE PRECISION
REAL
DECIMAL
NUMERIC
Per il tipo DECIMAL il range dipende da M e
D, occupa M+2 byte.
Tipi di dati: testo
Tipo
Max size
CHAR[(M)]
M
M
VARCHAR(M)
M
L+1
TINYBLOB/ TINYTEXT
28-1
L+1
BLOB/TEXT
216-1
L+2
MEDIUMBLOB/MEDIUMTEXT
224-1
L+3
LONGBLOB/LONGTEXT
232-1
L+4
ENUM(‘value1’,’value2’,…)
65535 elementi
SET (‘value1’,’value2’,…)
64 elementi
• L rappresenta la lunghezza effettiva del testo
Byte
1 o 2 byte
1,2,3,4 o 8 byte
Tipi di dati: date e time
Tipo
Range
Byte
DATE
‘1000-01-01’ ‘9999-12-31’
3
DATETIME
‘1000-01-01 00:00:00’
‘9999-12-31 23:59:59’
8
TIMESTAMP[(M)] Da 19700101000000 ad una data
nel 2037
4
TIME
‘-838:59:59’ - ‘838:59:59’
3
YEAR [(M)]
1901 al 2144 per YEAR(4)
1
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 database con il
nome dato;
Per poter eseguire il comando bisogna avere il
privilegio CREATE per creazione database.
DROP DATABASE
DROP {DATABASE | SCHEMA} [IF
EXISTS] db_name
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 db;
 Per poter eseguire il comando bisogna
avere il privilegio CREATE per le tabelle.

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]
CREATE TABLE (cont.)
type:
TINYINT[(length)] [UNSIGNED] [ZEROFILL]
| SMALLINT[(length)] [UNSIGNED] [ZEROFILL]
| MEDIUMINT[(length)] [UNSIGNED] [ZEROFILL]
| INT[(length)] [UNSIGNED] [ZEROFILL]
| INTEGER[(length)] [UNSIGNED] [ZEROFILL]
| BIGINT[(length)] [UNSIGNED] [ZEROFILL]
| REAL[(length,decimals)] [UNSIGNED] [ZEROFILL]
| DOUBLE[(length,decimals)] [UNSIGNED] [ZEROFILL]
| FLOAT[(length,decimals)] [UNSIGNED] [ZEROFILL]
| DECIMAL(length,decimals) [UNSIGNED] [ZEROFILL]
| NUMERIC(length,decimals) [UNSIGNED] [ZEROFILL]
| DATE
| TIME
| TIMESTAMP
| DATETIME
| CHAR(length) [BINARY | ASCII | UNICODE]
| VARCHAR(length) [BINARY]
| TINYBLOB
| BLOB
| MEDIUMBLOB
| LONGBLOB
| TINYTEXT
| TEXT
| MEDIUMTEXT
| LONGTEXT
| ENUM(value1,value2,value3,...)
| SET(value1,value2,value3,...)
| spatial_type
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 clausola
TEMPORARY. Una tabella TEMPORARY è visibile solo nella
connessione corrente all’uscita la tabella è rimossa.

Bisogna avere il privilegio CREATE TEMPORARY TABLES.

Può essere specificata la parola chiave IF NOT EXISTS per
evitare errori se la tabella già esiste.

Nota: non viene verificato che la tabella che si sta creando ha la stessa
struttura di quella esistente.


MySQL memorizza il formato di ogni tabella
come un file ’.frm' nella directory del db.
Possono essere creati anche altri file.
Nel caso di tabelle di tipo MyISAM il sistema
crea tre file per una tabella tbl_name:
tbl_name.frm
 tbl_name.MYD
 tbl_name.MYI

File di definizione del formato
Data file
Index file



Se NULL o NOT NULL non sono stati specificati il
sistema per default associa il valore NULL.
Una colonna integer può avere l’attributo addizionale
AUTO_INCREMENT. Quando viene inserito un
valore NULL (recommended) o 0 in una colonna
AUTO_INCREMENT, alla colonna viene
automaticamente inserito il successivo valore
disponibile. Tipicamente il valore è value+1, dove value è
il più grande valore presente nella tabella per quel
campo.
La sequenza AUTO_INCREMENT inizia con 1.

KEY è sinonimo di INDEX. Gli attributi PRIMARY KEY
possono essere specificati con la parola chiave KEY quando
vengono definiti. Implementato per compatibilità con altri
sistemi DBMS.

In MySQL, un indice UNIQUE impone che tutti i valori per in
esso siano distinti. Fatta eccezione per i valori NULL se sono
ammessi. Questa regola non è valida per le tabelle di tipo BDB.

Una PRIMARY KEY è una KEY univoca e le colonne sono
definite NOT NULL. Una tabella può avere solo una
PRIMARY KEY. Se non viene associata nessuna PRIMARY
KEY alla tabella ad una applicazione chiede la PRIMARY KEY
della tabella in esame MySQL ritorna il primo indice UNIQUE
definito che non ha colonne a 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
(struttura dati) durante la creazione della tabella.
Bisogna usare la parola chiave USING type_name.
MyISAM
InnoDB
MEMORY/HEAP
BTREE
BTREE
HASH, BTREE
Esempio:
CREATE TABLE lookup
(id INT,
INDEX USING BTREE (id))
ENGINE = MEMORY;
MyISAM



MyISAM è lo storage engine di default dal MySQL
3.23. E’ basato sullo storage ISAM.
Ogni tabella MyISAM è memorizzata all’interno del
disco con tre file.
Per specificare in maniera esplicita la tipoligia di tabella
desiderata bisogna usare il comando ENGINE o
TYPE.
CREATE TABLE t (i INT) ENGINE = MYISAM;
CREATE TABLE t (i INT) TYPE = MYISAM;
Tipi di tabelle
Storage Engine
Descrizione
BDB
Tabelle transaction-safe con page locking.
HEAP
I dati della seguente tabella sono solamente
memorizzati nella memoria principale.
ISAM
Primo storage engine di MySQL
InnoDB
Tabella transaction-safe con lock di righe e
chiavi esterne.
MEMORY
Un alias di HEAP
MERGE
Una collezione di tabelle MyISAM usate
come una singola tabella.
MRG_MyISAM
Un alias di MERGE.
MyISAM
Storage engine binario portabile. Evoluzione
di ISAM.
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 TABLE
DROP [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;
INSERT
INSERT [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 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 le righe. Nel momento in cui la tabella è libera il sistema
inizia con l’inserimento di esse, controllando periodicamente se vi sono richieste verso
la tabella. Nel momento in cui il sistema verifica una richiesta sospende l’inserimento.

Se viene specificata la parola chiave LOW_PRIORITY, l’esecuzione dell’insert viene
ritardata fino a quando vi sono dei client che effettuano richieste verso la tabella.

Se viene specificata la parola chiave IGNORE tutte le righe che provano a duplicare il
contenuto di un campo con indice UNIQUE o PRIMARY KEY vengono ignorate.

Se viene specificata la clausola ON DUPLICATE KEY nel momento in cui si tenta di
inserire una riga duplicata su un indice il sistema effettua l’update specificato per quella
riga.
LOAD DATA
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
[STARTING BY '']
[TERMINATED BY '\n']
]
[IGNORE number LINES]
[(col_name,...)]

Il comando LOAD DATA INFILE consente il
caricamento di una tabella ad alta velocità leggendo le
righe da un file di testo.

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
yyy"Row",1
blablabla yyy"Row",2
Può essere letto e verrà caricato come (“row”,1),
(“row”,2)
SELECT
SELECT
[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]]
Esempio
mysql> SELECT CONCAT(last_name,', ',first_name) AS
full_name
-> FROM mytable ORDER BY full_name;


La clausola FROM table_references indica le tabelle da dove
prelevare le righe.
Per ogni tabella specificata si può specificare un 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 INDEX da
all’ottimizzatore delle regole su come scegliere gli indici.
JOIN
table_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 { OJ
table_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)
Full outer join
Left Outer Join
Le righe escluse
dalla join della
tabella a sx
Join
Le righe che
soddisfano la
join
Right Outer Join
Le righe escluse
dalla join della
tabella a dx
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 table1 che non sono presenti in table2
(ovvero tutte le righe di table1 che non hanno un corrispondente in table2).


La clausola USING (column_list) elenca una lista di colonne che devono essere
presenti in entrambe le tabelle.
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 equivalente a INNER
JOIN o LEFT JOIN con la clausola USING che elenca i campi delle due tabelle.

RIGHT JOIN opera analogamente a LEFT JOIN. Si consiglia di usare LEFT JOIN
invece di RIGHT JOIN, per compatibilità con altri sistemi.
STRAIGHT_JOIN è identica alla JOIN, ad eccezione che le tabella sinistra è sempre
letta prima della tabella destra. Questo può essere utile nei casi in cui l’ottimizzatore
posiziona le tabelle nell’ordine sbagliato.


In una query possono essere specificate delle regole (hints) relativamente agli
indici da usare durante l’esecuzione di una query.

Specificando USE INDEX (key_list), si può dire al MySQL di usare
solamente gli indici specificati in key_list per trovare le righe nella tabella.

La sintassi alternativa IGNORE INDEX (key_list) può essere usata per dire
al MySQL di non usare un particolare indice.

Queste regole sono utili se il comando EXPLAIN mostra che MySQL usa in
maniera non ottimale gli indici.
Si può usare FORCE INDEX. Opera in modo simile a USE INDEX
(key_list) ma in più assume che un full table scan è una operazione molto
dispendiosa.
USE KEY, IGNORE KEY, e FORCE KEY sono sinonimi di USE INDEX,
IGNORE INDEX, and FORCE INDEX.


Sottoquery
Query Principale
?
“Quali impiegati hanno un salario
maggiore del salario di ‘Jones’?”
Sottoquery
?
“Quale e’ il salario di
‘Jones’?”
Sottoquery
SELECT
FROM
WHERE

select_expr
table_references
expr operator
(SELECT
FROM
select_expr
table_references);
L’output di una sottoquery viene dato in input alla
query principale.
Uso di Sottoquery
mysql> SELECT ename
-> FROM
emp
2975
-> WHERE sal >
->
(SELECT sal
->
FROM
emp
->
WHERE empno=7566);
Tipi di Sottoquery

sottoquery su riga singola
Query principale
ritorna
Sottoquery
Singolo valore
• subquery su riga Multipla
Query principale
ritorna
Sottoquery
Un elenco di valori
riferiti ad un campo
• Sottoquery su colonna Multipla
Query principale
ritorna
Sottoquery
Elenco di valori
Riferiti a diverisi campi
Sottoquery su righe multiple
Restituiscono più di una riga
 Vanno usate con operatori di riga multipla

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 correlate


Una sottoquery correlata è una sottoquery che
contiene un riferimento ad una tabella (es. ad un
suo campo) che è presente nella query più esterna.
Esempio:
SELECT * FROM t1
WHERE column1 = ANY (SELECT column1
FROM t2
WHERE t2.column2 = t1.column2);
EXSIST/NOT EXSISITS


Se una sottoquery restituisce un valore qualsiasi
allora la sottoquery EXISTS è TRUE e la
sottoquery NOT EXISTS è FALSE.
Per esempio:
mysql> SELECT column1 FROM t1 WHERE
-> EXISTS (SELECT * FROM t2);



City(id,city,country,district,population)
Cities_Stores(city,store_type,address)
Stores(store_type,description)
Esempi

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à?
SELECT DISTINCT store_type
FROM Stores WHERE NOT EXISTS
(SELECT * FROM Cities_Stores
WHERE Cities_Stores.store_type
= Stores.store_type);
Esempi

Quali tipi di negozi 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 clausola NOT
EXISTS.
Nell’output non esiste una città che non ha un tipo di negozio (store) dei tipi elencati.
Sottoquery a Colonne multiple

Visualizzare: id ordine, id prodotto, e quantità nella tabella item dove id
prodotto e quantità coincidono entrambi con id prodotto e quantità di
un elemento 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;
Uso di una sottoquery
nella clausola FROM
mysql>
->
->
->
->
->
SELECT
FROM
WHERE
AND
a.ename, a.sal, a.deptno, b.salavg
emp a, (SELECT
deptno, avg(sal) salavg
FROM
emp
GROUP BY deptno) b
a.deptno = b.deptno
a.sal > b.salavg;
EXPLAIN
EXPLAIN tbl_name
Oppure
EXPLAIN SELECT select_options
EXPLAIN

Consente di capire le performance di una query
e mostra quali indici effettivamente la query sta
usando.
Le colonne indicizzate devono
essere stand alone
mysql> explain select * from event where year(event.date) < '2003';
+-------+------+---------------+------+---------+------+------+-------------+
| table | type | possible_keys | key | key_len | ref | rows | Extra
|
+-------+------+---------------+------+---------+------+------+-------------+
| event | ALL | NULL
| NULL |
NULL | NULL |
6 | Using where |
+-------+------+---------------+------+---------+------+------+-------------+
1 row in set (0.00 sec)
mysql> explain select * from event where event.date < '2003-01-01';
+-------+------+---------------+------+---------+------+------+-------------+
| table | type | possible_keys | key | key_len | ref | rows | Extra
|
+-------+------+---------------+------+---------+------+------+-------------+
| event | ALL | Index_2
| NULL |
NULL | NULL |
6 | Using where |
+-------+------+---------------+------+---------+------+------+-------------+
1 row in set (0.00 sec)
Funzioni SQL
Input
Funzioni
arg 1
Output
Elaborazione
arg 2
arg n
Valori dei
Risultati
Due Tipi di Funzioni SQL
Funzioni
Funzioni
Single-row
Funzioni
Multiple-row
Funzioni
Stringhe
Generali
Funzioni
(Single-Row)
Conversione
Numeri
Date
Operatori di confronto



= , <> != , <= < >= , > <=> (NULL-safe), IS NULL, IS NOT NULL
expr BETWEEN min AND max
expr NOT BETWEEN min AND max



expr IN (value,...)
expr NOT IN (value,...)



Equivalente a NOT (expr BETWEEN min AND max).
Equivalente a NOT (expr IN (value,...)).
ISNULL(expr)
COALESCE(list)

Ritorna il primo elemento non-NULL nella lista:
mysql>
->
mysql>
->

SELECT COALESCE(NULL,1);
1
SELECT COALESCE(NULL,NULL,NULL);
NULL
INTERVAL(N,N1,N2,N3,...)

Ritorna 0 se N < N1, 1 se N < N2 ecc.o -1 se N è NULL. N1 < N2 < N3 < ... < Nn
mysql>
->
mysql>
->
mysql>
->
SELECT INTERVAL(23, 1, 15, 17, 30, 44, 200);
3
SELECT INTERVAL(10, 1, 10, 100, 1000);
2
SELECT INTERVAL(22, 23, 30, 44, 200);
0
Controllo 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>
->
mysql>
->
mysql>
->

IF(expr1,expr2,expr3)
mysql>
->
mysql>
->
mysql>
->

SELECT CASE 1 WHEN 1 THEN "one" WHEN 2 THEN "two" ELSE "more" END;
"one"
SELECT CASE WHEN 1>0 THEN "true" ELSE "false" END;
"true"
SELECT CASE BINARY "B" WHEN "a" THEN 1 WHEN "b" THEN 2 END;
NULL
SELECT IF(1>2,2,3);
3
SELECT IF(1<2,'yes','no');
'yes'
SELECT IF(STRCMP('test','test1'),'no','yes');
'no'
Altre funzioni


IFNULL(expr1,expr2)
NULLIF(expr1,expr2)
Funzioni su Stringhe
Funzioni
su stringhe
Funzioni
Conversioni Case
Funzioni di
Manipolazione Stringhe
LOWER
UPPER
CONCAT
SUBSTR
INITCAP
LENGTH
INSTR
LPAD
TRIM
RIGHT
Funzioni di manipolazione stringhe






ASCII(str)
BIN(N)
BIT_LENGTH(str)
CHAR(N,...)
CHAR_LENGTH(str)
CHARACTER_LENGTH(str)


CHARACTER_LENGTH() sinonimo di
CHAR_LENGTH().
COMPRESS(string_to_compress)

CONCAT(str1,str2,...)

Ritorna la stringa risultato della concatenazione delle stringhe contenute come argomento. Restituisce NULL se uno
qualisasi degli argomenti è NULL.
mysql> SELECT CONCAT(‘apulvirenti', ‘@', ‘dmi.unict.it'); ->
‘[email protected]'
mysql> SELECT CONCAT('My', NULL, 'QL'); -> NULL
mysql> SELECT CONCAT(14.3); -> '14.3'


CONCAT_WS(separator, str1, str2,...)
CONV(N,from_base,to_base)

Converte numeri tra due differenti basi. Ritorna NULL se uno dei due argomenti è NULL.
mysql>
mysql>
mysql>
mysql>

SELECT
SELECT
SELECT
SELECT
CONV("a",16,2); -> '1010'
CONV("6E",18,8); -> '172'
CONV(-17,10,-18); -> '-H'
CONV(10+"10"+'10'+0xa,10,10); -> '40'
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 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,...)

Complementare di ELT(). Ritorna l’indice della stringa str in str1, str2,ecc. Ritorna 0 se non
viene trovata.
mysql> SELECT FIELD('ej', 'Hej', 'ej', 'Heja', 'hej', 'foo'); -> 2
mysql> SELECT FIELD('fo', 'Hej', 'ej', 'Heja', 'hej', 'foo'); -> 0


FIND_IN_SET(str,strlist)
HEX(N_or_S)

INSERT(str,pos,len,newstr)
mysql> SELECT INSERT('Quadratic', 3, 4, 'What'); -> 'QuWhattic'

INSTR(str,substr)
mysql> SELECT INSTR('foobarbar', 'bar'); -> 4
mysql> SELECT INSTR('xbar', 'foobar'); -> 0

LCASE(str) – UCASE(str)


Sinonimo di LOWER() – UPPER().
LEFT(str,len)
mysql> SELECT LEFT('foobarbar', 5); -> 'fooba'

LENGTH(str)
mysql> SELECT LENGTH('text'); -> 4



LOCATE(substr,str)
LOCATE(substr,str,pos)
LPAD(str,len,padstr)


mysql> SELECT LPAD('hi',4,'??'); -> '??hi'
LTRIM(str)

mysql> SELECT LTRIM(' barbar'); -> 'barbar'

POSITION(substr IN str)



QUOTE(str)
REPEAT(str,count)


mysql> SELECT REPEAT('MySQL', 3); ->
'MySQLMySQLMySQL'
REPLACE(str,from_str,to_str)


Sinonimo di LOCATE(substr,str).
mysql> SELECT REPLACE('www.mysql.com', 'w', 'Ww'); > 'WwWwWw.mysql.com'
REVERSE(str)

mysql> SELECT REVERSE('abc'); -> 'cba‘.

RIGHT(str,len)
mysql> SELECT RIGHT('foobarbar', 4); -> 'rbar‘.

RPAD(str,len,padstr)
mysql> SELECT RPAD('hi',5,'?'); -> 'hi???'

RTRIM(str)
mysql> SELECT RTRIM('barbar '); -> 'barbar'
Funzioni di confronto tra stringhe

STRCMP(expr1,expr2)
 STRCMP() ritorna 0 se le due stringhe coincidono, -1 se il
primo argomento è minore del secondo, 1 altrimenti.
mysql>
->
mysql>
->
mysql>
->
SELECT STRCMP('text', 'text2');
-1
SELECT STRCMP('text2', 'text');
1
SELECT STRCMP('text', 'text');
0

expr LIKE pat [ESCAPE 'escape-char'] Ritorna 1 (TRUE) o 0
(FALSE).
mysql>
->
mysql>
->
mysql>
->
mysql>
->
SELECT
1
SELECT
1
SELECT
0
SELECT
1
'David!' LIKE 'David_';
'David!' LIKE '%D%v%';
'David!' LIKE 'David\_';
'David_' LIKE 'David\_';
Per specificare un carattere di ESCAPE diverso da \:
mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|';
-> 1

Funzioni di confronto tra stringhe
MATCH (col1,col2,...) AGAINST (expr [IN
BOOLEAN MODE | WITH QUERY EXPANSION] )

MATCH ... AGAINST() è utilizzata per ricerche full text, ritorna
la rilevanza tra il testo che si trova nelle colonne (col1,col2,...) e
la query expr. La similarità è un valore positivo in virgola mobile.
mysql> CREATE TABLE articles (
-> id INT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY,
-> title VARCHAR(200),
-> body TEXT,
-> FULLTEXT (title,body)
-> );
Query OK, 0 rows affected (0.00 sec)
mysql>
->
->
->
->
->
->
INSERT INTO articles (title,body) VALUES
('MySQL Tutorial','DBMS stands for DataBase ...'),
('How To Use MySQL Efficiently','After you went through a ...'),
('Optimizing MySQL','In this tutorial we will show ...'),
('1001 MySQL Tricks','1. Never run mysqld as root. 2. ...'),
('MySQL vs. YourSQL','In the following database comparison ...'),
('MySQL Security','When configured properly, MySQL ...');
Query OK, 6 rows affected (0.00 sec) Records: 6 Duplicates: 0 Warnings: 0
mysql> SELECT * FROM articles
-> WHERE MATCH (title,body) AGAINST ('database');
+----+-------------------+--------------------------------------+
| id | title
|
body |
+----+-------------------+--------------------------------------+
| 5 | MySQL vs. YourSQL | In the following database comparison.|
| 1 | MySQL Tutorial
| DBMS stands for DataBase ...
|
+----+-------------------+--------------------------------------+
2 rows in set (0.00 sec)
mysql> SELECT id, MATCH (title,body) AGAINST ('Tutorial')
-> FROM articles;
+----+-----------------------------------------+
| id | MATCH (title,body) AGAINST ('Tutorial') |
+----+-----------------------------------------+
| 1 |
0.64840710366884 |
| 2 |
0 |
| 3 |
0.66266459031789 |
| 4 |
0 |
| 5 |
0 |
| 6 |
0 |
+----+-----------------------------------------+
6 rows in set (0.00 sec)
mysql>
->
->
->
SELECT id, body, MATCH (title,body) AGAINST
('Security implications of running MySQL as root') AS score
FROM articles WHERE MATCH (title,body) AGAINST
('Security implications of running MySQL as root');
+----+-------------------------------------+-----------------+
| id |
body |
score |
+----+-------------------------------------+-----------------+
| 4 | 1. Never run mysqld as root. 2. ... | 1.5055546709332 |
| 6 | When configured properly, MySQL ... |
1.31140957288 |
+----+-------------------------------------+-----------------+
2 rows in set (0.00 sec)
mysql> SELECT * FROM articles WHERE MATCH (title,body)
-> AGAINST ('+MySQL -YourSQL' IN BOOLEAN MODE);
+----+------------------------------+-------------------------------------+
| id |
title |
body |
+----+------------------------------+-------------------------------------+
| 1 |
MySQL Tutorial |
DBMS stands for DataBase ... |
| 2 | How To Use MySQL Efficiently |
After you went through a ... |
| 3 |
Optimizing MySQL |
In this tutorial we will show ... |
| 4 |
1001 MySQL Tricks | 1. Never run mysqld as root. 2. ... |
| 6 |
MySQL Security | When configured properly, MySQL ... |
+----+------------------------------+-------------------------------------+

Questa query restituisce tutte le righe che contengono la parola “MySQL” e
non contengono la parola “YourSQL”.
mysql> SELECT * FROM articles
-> WHERE MATCH (title,body) AGAINST ('database');
+----+-------------------+------------------------------------------+
| id |
title |
body |
+----+-------------------+------------------------------------------+
| 5 | MySQL vs. YourSQL | In the following database comparison ... |
| 1 |
MySQL Tutorial |
DBMS stands for DataBase ... |
+----+-------------------+------------------------------------------+
2 rows in set (0.00 sec)
mysql> SELECT * FROM articles
-> WHERE MATCH (title,body)
-> AGAINST ('database' WITH QUERY EXPANSION);
+----+-------------------+------------------------------------------+
| id |
title |
body |
+----+-------------------+------------------------------------------+
| 1 |
MySQL Tutorial |
DBMS stands for DataBase ... |
| 5 | MySQL vs. YourSQL | In the following database comparison ... |
| 3 | Optimizing MySQL |
In this tutorial we will show ... |
+----+-------------------+------------------------------------------+
3 rows in set (0.00 sec)
Funzioni matematiche





ABS(X)
FLOOR(X), CEILING(X)
SIN(X), COS(X)…
LN(X), LOG(X), LOG(B,X)
Ecc.
Operatori logici




NOT (! )
AND (&& )
OR (|| )
XOR
View
CREATE
[OR REPLACE]
[ALGORITHM = {UNDEFINED | MERGE |
TEMPTABLE}]
[DEFINER = { user | CURRENT_USER }] [SQL
SECURITY { DEFINER | INVOKER }] VIEW
view_name [(column_list)]
AS select_statement
[WITH [CASCADED | LOCAL] CHECK OPTION]
Definizione di stored procedure




Una stored routine è costituita o da una procedura o da una
funzione
Una stored procedure è costituita da un insieme di istruzioni
SQL che vengono memorizzate nel server con un nome
identificativo, può essere invocata con CALL e torna indietro
valori usando le variabili di output
Una stored function può essere chiamata mediante il solo nome,
e può ritornare un valore scalare
Delle stored routines possono chiamare altre stored routines
Proprietà

Una stored routine è associata ad un particolare database, e
questo vuol dire che:
1.
2.
3.

Quando viene invocata, implicitamente viene eseguito USE
<database>, non sono ammessi USE all’interno della routine
E’ possibile riferirsi ad una routine non presente nel database corrente
prefissandola con il nome del suo database
Il DROP del db provoca il DROP delle routine associate
Se non indicato diversamente le SR sono associate al DB di
default
Perché usare una SR?


Girano in qualsiasi ambiente. Dato che sono sul server
del DB, non dipendono dall’applicativo che le usa e dal
linguaggio di programmazione. L’aggiornamento di una
SR aggiorna la logica di funzionamento del DB senza la
necessità di modificare i client
Possono ridurre il traffico di rete, utilizzando dei result
set direttamente sul DB senza muoverli verso il client
per l’elaborazione.
Sintassi
CREATE
[DEFINER = { user | CURRENT_USER }]
PROCEDURE sp_name ([proc_parameter[,...]])
[characteristic ...] routine_body
CREATE
[DEFINER = { user | CURRENT_USER }]
FUNCTION sp_name ([func_parameter[,...]])
RETURNS type
[characteristic ...] routine_body
Esempio di procedura
DELIMITER //
CREATE PROCEDURE simpleproc (OUT param1 int)
BEGIN
SELECT COUNT(*) INTO param1 FROM imp;
END;
//
DELIMITER ;
CALL simpleproc(@a);
SELECT @a;
Osservazioni




DELIMITER cambia il “terminatore” di linea da ; a //, in modo che sia
possibile usare ; nella definizione della procedura e non venga interpretato da
mysql
La procedura torna un risultato tramite l’unico parametro definito, che è un
parametro di uscita. Il parametro viene riempito dalla istruzione CALL, e letto
tramite una semplice SELECT
E’ possibile avere procedure molto più complesse
Per ottenere informazioni a proposito delle procedure:
SHOW PROCEDURE STATUS;
SHOW CREATE PROCEDURE <nome>;
Procedura complessa
DELIMITER //
CREATE PROCEDURE procedura1 (param1 INT, param2 CHAR(3),
OUT param3 INT)
BEGIN
DECLARE finito INT default 0;
DECLARE a INT;
DECLARE b CHAR(50);
DECLARE cur1 CURSOR FOR SELECT id,nome
FROM clienti WHERE cat = param2;
DECLARE CONTINUE HANDLER FOR SQLSTATE '02000'
SET finito = 1;
OPEN cur1;
SET param3 = 0;
FETCH cur1 INTO a,b;
ciclo: WHILE NOT finito DO
IF param3 < param1 THEN
SET param3 = param3 + 1;
FETCH cur1 INTO a,b;
ELSE
LEAVE ciclo;
END IF;
END WHILE ciclo;
END; //
DELIMITER ;
Analisi
DELIMITER //
Dice al server che l’istruzione di CREATE non termina con il ; che invece mi serve
all’interno delle Stored Procedure
CREATE PROCEDURE procedura1 (param1 INT, param2 CHAR(3), OUT param3 INT)
La procedura ha come nome procedura1, e usa tre parametri, i primi due di input e
l’ultimo di output
BEGIN
END
Il codice da eseguire deve essere delimitato da BEGIN e END
Analisi
DECLARE finito INT default 0;
DECLARE a INT;
DECLARE b CHAR(50);
Definiamo tre variabili da usare all’interno della routine, una di queste inizializzata con un default
DECLARE cur1 CURSOR FOR SELECT id,nome
FROM clienti WHERE cat = param2;
Definiamo un “cursore”
DECLARE CONTINUE HANDLER FOR SQLSTATE '02000'
SET finito = 1;
Definiamo un “handler” che non interrompe l’esecuzione se si verifica la condizione indicata
L’ordine delle dichiarazioni è importante, deve essere quello qui illustrato!
Analisi
OPEN cur1;
SET param3 = 0;
Questa è la prima vera operazione, l’apertura del cursore. In questo modo viene eseguita
la select, che costituisce il corpo del cursore. Inizializziamo il parametro di output e
passiamo alla
FETCH cur1 INTO a,b;
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 “cursore” si sposta sul secondo
risultato trovato, che tornerà alla successiva fetch.
Notare che la prima fetch è esterna al ciclo, per gestire il caso di tabella senza righe.
I cursori sono READ ONLY, e NOT SCROLLABLE
Analisi
ciclo: WHILE NOT finito DO
END WHILE ciclo;
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 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 cambia il valore della variabile in 1.
IF param3 < param1 THEN
SET param3 = param3 + 1;
FETCH cur1 INTO a,b;
ELSE
LEAVE ciclo;
END IF;
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 un’altra FETCH del
cursore. Nell’esempio non uso a e b, ma potrei farlo...
Analisi
Il ciclo quindo termina o quando si è verificata la condizione sui parametri,
oppure quando il cursore si è esaurito, e al termine della esecuzione il
parametro di output conterrà il numero di righe lette.
Riassumendo in una SP si possono trovare le definizioni di :
1.
2.
3.
4.
Variabili (declare, in, out)
Condizioni (sqlstate)
Cursori
Handler
Si possono usare nel codice:
1.
2.
3.
Variabili
Cursori
Controllo di flusso (if, loop, repeat, while, iterate, leave)
Modifica

Una procedura può essere eliminata con
DROP PROCEDURE <nome>

E’ possibile modificare i suoi permessi con
ALTER PROCEDURE <nome> SQL SECURITY { DEFINER | INVOKER }

Nel caso DEFINER è l’utente che ha definito la procedura a dover avere i permessi
necessari alla sua esecuzione, nel caso INVOKER è invece l’utente che la esegue.
Stored Functions


Rispetto alla definizione delle procedure si aggiunge la capacità di tornare un
valore con la clausola RETURN, e i parametri sono esclusivamente in input.
E’ obbligatorio tornare un valore!
drop function funz2;
DELIMITER //
CREATE function funz2(codFis char(16)) returns decimal
BEGIN
DECLARE c INT default 0;
select stipendio into c FROM impiegati
where cf=codFis;
return c + 3*c;
END;
//
DELIMITER ;
ESERCIZIO

Scrivere una stored procedure che somma tutti gli stipendi degli impiegati.
DELIMITER //
CREATE PROCEDURE p25 (OUT return_val INT)
BEGIN
DECLARE a,b INT;
DECLARE c INT default 0;
DECLARE cur_1 CURSOR FOR SELECT stipendio FROM imp;
DECLARE CONTINUE HANDLER FOR NOT FOUND
SET b = 1;
OPEN cur_1;
SET b = 0;
REPEAT
FETCH cur_1 INTO a;
if b = 0 then
SET c=c+a;
end if;
UNTIL b = 1
END REPEAT;
CLOSE cur_1;
SET return_val = c;
ESERCIZIO

Scrivere una stored procedure che inserisca nella tabella impsede1 tutti i codici degli
impiegati della sede 1
DELIMITER //
CREATE PROCEDURE p26 ()
BEGIN
DECLARE b INT;
DECLARE a char(4);
DECLARE cur_1 CURSOR FOR SELECT codimp FROM imp WHERE sede='S01';
DECLARE CONTINUE HANDLER FOR NOT FOUND
SET b = 1;
OPEN cur_1;
FETCH cur_1 INTO a;
REPEAT
INSERT INTO corsosql.impSede1 VALUES (a);
FETCH cur_1 INTO a;
UNTIL b = 1
END REPEAT;
CLOSE cur_1;
END;
//
DELIMITER ;
TRIGGERS



Sono oggetti associati a tabelle, che vengono attivati nel momento in cui un
determinato evento si verifica in quella tabella.
Nella definizione del trigger stabiliamo per quale evento deve essere attivato,
ossia per inserimento di righe, modifiche o cancellazioni, e se deve essere
eseguito prima o dopo tale evento
Si hanno dunque i seguenti tipi di trigger:
1.
2.
3.
4.
5.
6.
BEFORE INSERT
BEFORE UPDATE
BEFORE DELETE
AFTER INSERT
AFTER UPDATE
AFTER DELETE
Sintassi
CREATE
[DEFINER = { user | CURRENT_USER }]
TRIGGER trigger_name trigger_time trigger_event
ON tbl_name FOR EACH ROW trigger_body

La clausola DEFINER specifica se come creatore del trigger deve essere considerato l'utente attuale (default)
o un altro utente specificato nella forma nome@host.

trigger_time 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.

trigger_event è l’evento che scatena l’esecuzione del trigger. Esso può essere INSERT, UPDATE, DELETE

trigger_body rappresenta il codice che viene eseguito all’attivazione del trigger. Normalmente racchiuso tra
BEGIN….END.
Anche se associato ad una tabella il trigger deve avere nome univoco all’interno del database.
Quando si fa riferimento a inserimenti o cancellazioni di righe, non si intende necessariamente una istruzione
INSERT o DELETE, ma qualsiasi operazione dalla quale scaturisca l’evento interessato (ad esempio il
caricamento dei dati da shell)


Esempio
delimiter //
CREATE TRIGGER upd_check BEFORE UPDATE ON account
FOR EACH ROW
BEGIN
IF NEW.amount < 0 THEN
SET NEW.amount = 0;
ELSEIF NEW.amount > 100 THEN
SET NEW.amount = 100;
END IF;
END;//
delimiter ;
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.
E’ disponibile anche OLD, che si riferisce ai valori precedenti la modifica, e si può
utilizzare nel caso di UPDATE e DELETE
La modifica con SET è possibile solo per i valori NEWe nei trigger di tipo BEFORE
Attenti con i trigger BEFORE: se l’inserimento non riesce potrebbero lasciare dati
inconsistenti
Esempio
delimiter //
CREATE TRIGGER log_upd AFTER UPDATE ON impiegati
FOR EACH ROW
BEGIN
DECLARE u varchar(40);
select user() into u;
insert into TB_LOG values(NULL, NOW(), 'UPDATE', OLD.stipendio,
NEW.stipendio, u);
END;//
delimiter ;
Transazioni



L'uso delle transazioni permette di "consolidare" le modifiche
alla base dati solo in un momento ben preciso: dal momento in
cui avviamo una transazione, gli aggiornamenti rimangono
sospesi (e invisibili ad altri utenti) fino a quando non li
confermiamo (commit); in alternativa alla conferma è possibile
annullarli (rollback).
MySQL gira per default in AUTOCOMMIT mode: tutti gli
aggiornamenti vengono automaticamente consolidati nel
momento in cui sono eseguiti
Per iniziare una transazione si deve usare allora START
TRANSACTION: da questo punto in poi tutti gli aggiornamenti
rimaranno sospesi
Sintassi
START TRANSACTION
...istruzioni di aggiornamento (1)...
SAVEPOINT sp1;
...istruzioni di aggiornamento (2)...
ROLLBACK TO SAVEPOINT sp1;
...istruzioni di aggiornamento (3)...
COMMIT




COMMIT conferma le modifiche e chiude la transazione, mentre
ROLLBACK annulla tutti gli aggiornamenti eseguiti nel corso dell’ultima
transazione
COMMIT AND CHAIN provoca l’immediata apertura di una nuova
transazione, COMMIT RELEASE chiude la connessione al server
SET AUTOCOMMIT=0 disabilita l’autocommit: tutti gli aggiornamenti
rimangono in sospeso fino al commit
I SAVEPOINT sono degli stati intermedi ai quali possiamo tornare con un
ROLLBACK
Osservazioni


Su MySQL il tutto funziona solo se si usa InnoDB
NON sono annullabili le operazioni che creano,
eliminano o alterano la struttura di tabelle e database: è
bene evitare di includere in una transazione tali
operazioni, che tra l’altro nella maggior parte dei casi
causano una COMMIT implicita
SELECT

In alcuni casi è utile utilizzare due clausole particolari quando si effettua una
select:
SELECT ....FOR UPDATE
SELECT ....LOCK IN SHARE MODE


La prima stabilisce un LOCK su tutte le righe lette, che impedirà ad altri
utenti di leggerle fino al termine della nostra transazione
La seconda stabilisce un LOCK che impedisce gli aggiornamenti, garantendo
che il contenuto rimarrà invariato durante la transazione
Livello di isolamento

Un aspetto importante relativamente alle transazioni è il livello di isolamento al quale
vengono effettuate. I livelli possibili sono quattro, e li elenchiamo in ordine crescente:
1.
2.
3.
4.
READ UNCOMMITTED: a questo livello sono visibili gli aggiornamenti effettuati da altri
utenti anche se non consolidati: è un comportamento non propriamente transazionale, che
può dare seri problemi di consistenza dei dati; va utilizzato solo quando non ci sono
preoccupazioni di questo tipo e c’è bisogno di velocizzare le letture
READ COMMITTED: a questo livello gli aggiornamenti diventano visibili solo dopo il
consolidamento
REPETEABLE READ: in questo caso perchè un aggiornamento diventi visibile deve essere
non solo consolidato, ma anche la transazione che legge deve essere terminata; in pratica, la
stessa lettura ripetuta all'interno di una transazione darà sempre lo stesso risultato; è la
modalità di default
SERIALIZABLE: come nel caso precedente, ma in più, la semplice lettura di un dato
provoca il blocco degli aggiornamenti fino al termine della transazione; in sostanza è come se
ogni SELECT venisse effettuata con la clausola LOCK IN SHARE MODE