MySQL ___

Materiale didattico Slide del corso: http://www.dmi.unict.it/~ggiuffrida/ Libro di testo: Paul DoBois, MySQL, Pearson Education, 2004. Documentazione on-line MySQL www.mysql.com

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 Connector/J (JDBC). MySQL Migration Toolkit MySQL Workbench

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: Sub-Queriy e tabelle derivate; 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.

Per avere l’help: C:\>mysql –help Per uscire: mysql> QUIT 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 Estrazione Dati INSERT UPDATE DELETE Data manipulation language (DML) CREATE ALTER DROP RENAME TRUNCATE Data definition language (DDL) 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 [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 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}$';

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( 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 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 Byte Minimum Value Maximum Value (Signed/Unsigned) TINYINT[(M)] 1 -128 127 255 SMALLINT [(M)] 2 -32768 32767 65535 MEDIUMINT [(M)] 3 -8388608 8388607 16777215 INT [(M)] 4 -2147483648 2147483647 4294967295 BIGINT [(M)] 8 -9223372036854775808 9223372036854775807 18446744073709551615 FLOAT[(M,D)] +/-1.175494351E-38 +/- 3.402823466E+38 DOUBLE [(M,D)] +/-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 L rappresenta la lunghezza effettiva del testo Tipo Max size Byte CHAR[(M)] M VARCHAR(M) L+1 TINYBLOB/ TINYTEXT 28-1 BLOB/TEXT 216-1 L+2 MEDIUMBLOB/MEDIUMTEXT 224-1 L+3 LONGBLOB/LONGTEXT 232-1 L+4 ENUM(‘value1’,’value2’,…) 65535 elementi 1 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 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’ YEAR [(M)] 1901 al 2144 per YEAR(4) 1

CREATE DATABASE CREATE DATABASE crea un database con il nome dato; 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 TABLE crea una tabella nel db; 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)

Bisogna avere il privilegio CREATE TEMPORARY TABLES. 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 ’ 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 File di definizione del formato tbl_name.MYD Data file tbl_name.MYI 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 BTREE InnoDB BTREE MEMORY/HEAP 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 CREATE TABLE new_table (...); 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}, ... 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.

mysql> LOAD DATA LOCAL INFILE 'pet.txt' INTO TABLE pet; Caricamento dei dati: mysql> LOAD DATA LOCAL INFILE 'pet.txt' INTO TABLE pet; mysql> LOAD DATA LOCAL INFILE 'event.txt' INTO TABLE event;

Può essere letto e verrà caricato come (“row”,1), (“row”,2) 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 Right Outer Join Join Le righe escluse dalla join della tabella a sx Le righe che soddisfano la 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’?” Le sottoquery sono utilizzate per risolvere un problema Supponiamo di voler scrivere una query per trovare chi ha il salario più alto del salario di Jones. Per risolvere tale problema si hanno di bisogno di due query. Una per trovare quanto guadagna Jones e l’altra per sapere chi guadagna di più. Il problema può essere risolto eseguendo una query dentro un alrta. La query interna restituisce un valore che è utilizzato come condizione nella query principale. Equivale ad eseguire in modo sequenziale due query dove l’output di una è utilizzato come condizione nell’altra.

Sottoquery SELECT select_expr FROM table_references WHERE expr operator (SELECT select_expr FROM table_references); L’output di una sottoquery viene dato in input alla query principale. Sottoquery Una sottoquery è un comando SELECT è un comando select integrato all’interno di un altro comando SELECT.Con l’uso delle sottoquery possono essere costruti dei comandi potenti. Sono utili per selezionare dati da una tabella con una condizione che dipende dai dati stessi. Le sottoquery possono essere inserite all’interno delle segueti clausole: WHERE HAVING FROM Nella sintassu: operatore include un operatore di confronto come as >, =, o IN Note: Gli operatori di confronto appartengono a due classi:operatori su riga singola (>, =, >=, <, <>, <=) operatori su righe multiple (IN, ANY, ALL). Note Sottoquert addizionali possono essere inserite nei comandi CREATE VIEW, CREATE TABLE, UPDATE, INTO del comando INSERT, e SET din un comando UPDATE.

Uso di Sottoquery mysql> SELECT ename -> FROM emp -> WHERE sal > -> (SELECT sal -> FROM emp -> WHERE empno=7566); 2975 Oso delle sottoquery La query interna determina il salario dell’impiegato 7566. La query esterna determina prende come input il salario e restituisce gli impiegati che hanno un salario maggiore.

Tipi di Sottoquery sottoquery su riga singola Singolo valore Query principale Sottoquery ritorna Singolo valore subquery su riga Multipla Un elenco di valori riferiti ad un campo Query principale Sottoquery ritorna Sottoquery su colonna Multipla Elenco di valori Riferiti a diverisi campi Query principale Sottoquery ritorna Tipi di Sottoquery Sottoquery a riga singola: Restituiscono solo una riga dalla query interna. Sottoquery a riga multipla: La query interna restituisce più di una riga Sottoquery a colonna Multipla: La query interna restituisce più di una colonna

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 a riga multipla Le sottoquery a riga multipla restituiscono più di una riga. Per gestirle si ha di bisogno degli operatori a riga multipla . Esempio Trovare gli impiegati che guadagnano un salario uguale al minimo salario di per dipartimento. La query interna, eseguita per prima, restituirà tre rige: 800, 950, 1300. La query principale userà tali valori all’interno della condizione: SQL> SELECT ename, sal, deptno 2 FROM emp 3 WHERE sal IN (SELECT MIN(sal) 4 FROM emp 5 GROUP BY deptno); SQL> SELECT ename, sal, deptno 2 FROM emp 3 WHERE sal IN (800, 950, 1300);

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à? FROM Stores WHERE NOT EXISTS (SELECT * FROM Cities_Stores WHERE Cities_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 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;

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'; | event | ALL | Index_2 | NULL | NULL | NULL | 6 | Using where |

Funzioni SQL Funzioni Input arg 1 arg 2 arg n Output Valori dei Risultati Elaborazione

Due Tipi di Funzioni SQL Single-row Funzioni Multiple-row

Funzioni Stringhe Generali Numeri Funzioni (Single-Row) Conversione Date

Operatori di confronto = , <> != , <= < >= , > <=> (NULL-safe), IS NULL, IS NOT NULL expr BETWEEN min AND max expr NOT BETWEEN min AND max Equivalente a NOT (expr BETWEEN min AND max). expr IN (value,...) expr NOT IN (value,...) Equivalente a NOT (expr IN (value,...)). ISNULL(expr) COALESCE(list) 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,...) 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 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 funzioni IFNULL(expr1,expr2) NULLIF(expr1,expr2)

Manipolazione Stringhe Funzioni su Stringhe Funzioni su stringhe Funzioni Conversioni Case Funzioni di Manipolazione Stringhe LOWER UPPER INITCAP CONCAT SUBSTR 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_WS(separator, str1, str2,...) CONV(N,from_base,to_base) 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'); -> ‘apulvirenti@dmi.unict.it' 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> 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,...) 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'

FIND_IN_SET(str,strlist) HEX(N_or_S) 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) INSTR(str,substr) LCASE(str) – UCASE(str) 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,pos) LPAD(str,len,padstr) LTRIM(str) mysql> SELECT LPAD('hi',4,'??'); -> '??hi' LTRIM(str) mysql> SELECT LTRIM(' barbar'); -> 'barbar'

POSITION(substr IN str) QUOTE(str) REPEAT(str,count) Sinonimo di LOCATE(substr,str). QUOTE(str) REPEAT(str,count) mysql> SELECT REPEAT('MySQL', 3); -> 'MySQLMySQLMySQL' REPLACE(str,from_str,to_str) mysql> SELECT REPLACE('www.mysql.com', 'w', 'Ww'); -> 'WwWwWw.mysql.com' REVERSE(str) mysql> SELECT REVERSE('abc'); -> 'cba‘.

RIGHT(str,len) RPAD(str,len,padstr) RTRIM(str) 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> SELECT STRCMP('text', 'text2'); -> -1 mysql> SELECT STRCMP('text2', 'text'); -> 1 mysql> SELECT STRCMP('text', 'text'); -> 0

expr LIKE pat [ESCAPE 'escape-char'] Ritorna 1 (TRUE) o 0 (FALSE). mysql> SELECT 'David!' LIKE 'David_'; -> 1 mysql> SELECT 'David!' LIKE '%D%v%'; mysql> SELECT 'David!' LIKE 'David\_'; -> 0 mysql> SELECT 'David_' LIKE 'David\_'; Per specificare un carattere di ESCAPE diverso da \: mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|';

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) -> WHERE MATCH (title,body) -> AGAINST ('database' WITH QUERY EXPANSION); | 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]