MySQL - Dichiarazioni di Riferimento

Benvenuti, futuri maghi dei database! Oggi ci immergeremo nel mondo magico delle dichiarazioni di MySQL. Non preoccupatevi se non avete mai scritto una riga di codice prima - alla fine di questo tutorial, sarete in grado di evocare incantesimi di database come un professionista!

Dichiarazioni di Definizione dei Dati

Iniziamo con i mattoni del nostro regno del database: le Dichiarazioni di Definizione dei Dati. Questi sono i comandi che utilizziamo per creare, modificare e eliminare la struttura del nostro database.

CREATE TABLE

Immaginate di costruire una biblioteca. La prima cosa di cui avete bisogno sono scaffali, giusto? In MySQL, i nostri "scaffali" sono le tabelle. Creiamo una!

CREATE TABLE books (
id INT PRIMARY KEY AUTO_INCREMENT,
title VARCHAR(100) NOT NULL,
author VARCHAR(50),
publication_year INT
);

Questa dichiarazione... voglio dire, incantesimo, crea una tabella chiamata "books" con quattro colonne:

• id: Un identificatore univoco per ogni libro
• title: Il titolo del libro (fino a 100 caratteri)
• author: L'autore del libro (fino a 50 caratteri)
• publication_year: L'anno di pubblicazione del libro

ALTER TABLE

Oh no! Abbiamo dimenticato di aggiungere una colonna per il genere del libro. Nessun problema, possiamo modificare la nostra tabella:

ALTER TABLE books
ADD COLUMN genre VARCHAR(30);

Questo aggiunge una nuova colonna chiamata "genre" alla nostra tabella "books".

DROP TABLE

Se decidiamo che non abbiamo più bisogno della nostra tabella (forse stiamo passando agli e-book?), possiamo rimuoverla:

DROP TABLE books;

Attenzione con questo comando, però! È come dare fuoco al vostro scaffale - non c'è modo di tornare indietro!

Dichiarazioni di Manipolazione dei Dati

Ora che abbiamo la nostra struttura, riempiamola di dati!

INSERT

È giunto il momento di aggiungere dei libri alla nostra biblioteca:

INSERT INTO books (title, author, publication_year, genre)
VALUES ('Gatsby il Magnifico', 'F. Scott Fitzgerald', 1925, 'Classico');

Questo aggiunge un libro alla nostra tabella. Potete aggiungere più libri in una sola volta:

INSERT INTO books (title, author, publication_year, genre)
VALUES
('Il Buio Uccide', 'Harper Lee', 1960, 'Narrativa'),
('1984', 'George Orwell', 1949, 'Fantascienza');

SELECT

Ora, vediamo quali libri abbiamo:

SELECT * FROM books;

Questo recupera tutte le colonne (*) dalla tabella "books". Potete essere più specifici:

SELECT title, author FROM books WHERE publication_year < 1950;

Questo recupera solo il titolo e l'autore dei libri pubblicati prima del 1950.

UPDATE

Oh, abbiamo fatto un errore! "1984" è in realtà una distopia:

UPDATE books
SET genre = 'Distopia'
WHERE title = '1984';

Questo cambia il genere per il libro intitolato "1984".

DELETE

Supponiamo che vogliamo rimuovere tutti i libri pubblicati prima del 1930:

DELETE FROM books
WHERE publication_year < 1930;

Attenzione con DELETE - come DROP, è permanente!

Dichiarazioni Transazionali e di Blocco

A volte, dobbiamo assicurarci che una serie di operazioni avvenga tutte insieme, o non avvenga affatto. Ecco dove entrano in gioco le transazioni.

START TRANSACTION

START TRANSACTION;
INSERT INTO books (title, author, publication_year, genre)
VALUES ('Orgoglio e Pregiudizio', 'Jane Austen', 1813, 'Romanzo');
UPDATE books SET publication_year = 1960 WHERE title = 'Il Buio Uccide';
COMMIT;

Questo garantisce che sia l'INSERT che l'UPDATE avvengano insieme. Se c'è un errore, né l'uno né l'altro avranno effetto.

ROLLBACK

Se cambi idea a metà transazione:

START TRANSACTION;
DELETE FROM books WHERE publication_year < 1900;
-- Oh no, non volevamo farlo!
ROLLBACK;

ROLLBACK annulla tutte le modifiche fatte dall'ultimo START TRANSACTION.

Dichiarazioni Preparate

Le dichiarazioni preparate sono come le ricette - le impostate una volta, poi le utilizzate più volte con ingredienti diversi.

PREPARE stmt FROM 'SELECT * FROM books WHERE author = ?';
SET @a = 'George Orwell';
EXECUTE stmt USING @a;

Questo prepara una dichiarazione per trovare i libri di un autore specifico, poi la esegue per George Orwell.

Dichiarazioni Composte

Le dichiarazioni composte ci permettono di raggruppare più dichiarazioni insieme. Vengono spesso utilizzate in stored procedures e funzioni.

DELIMITER //
CREATE PROCEDURE CountBooks()
BEGIN
DECLARE bookCount INT;
SELECT COUNT(*) INTO bookCount FROM books;
SELECT CONCAT('Ci sono ', bookCount, ' libri nella biblioteca.') AS Message;
END //
DELIMITER ;

CALL CountBooks();

Questa stored procedure conta i libri e visualizza un messaggio.

Variabili nei Programmi Archiviati

Le variabili nei programmi archiviati sono come scatole piccole dove possiamo conservare informazioni temporaneamente.

DELIMITER //
CREATE PROCEDURE OldestBook()
BEGIN
DECLARE oldestYear INT;
DECLARE oldestTitle VARCHAR(100);

SELECT MIN(publication_year), title
INTO oldestYear, oldestTitle
FROM books;

SELECT CONCAT('Il libro più vecchio è ', oldestTitle, ' pubblicato nel ', oldestYear) AS Message;
END //
DELIMITER ;

CALL OldestBook();

Questa stored procedure trova il libro più vecchio e ci informa.

Dichiarazioni di Controllo del Flusso di MySQL

Le dichiarazioni di controllo del flusso ci aiutano a prendere decisioni nel nostro codice.

DELIMITER //
CREATE PROCEDURE CategoryByYear(IN pub_year INT)
BEGIN
DECLARE category VARCHAR(20);
IF pub_year < 1900 THEN
SET category = 'Molto Vecchio';
ELSEIF pub_year < 2000 THEN
SET category = 'Classico';
ELSE
SET category = 'Moderno';
END IF;
SELECT category AS 'Categoria del Libro';
END //
DELIMITER ;

CALL CategoryByYear(1925);

Questa categorizza un libro in base all'anno di pubblicazione.

Dichiarazioni di Cursori di MySQL

I cursori ci permettono di iterare attraverso un set di risultati una riga alla volta.

DELIMITER //
CREATE PROCEDURE ListBooks()
BEGIN
DECLARE done INT DEFAULT FALSE;
DECLARE book_title VARCHAR(100);
DECLARE cur CURSOR FOR SELECT title FROM books;
DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = TRUE;

OPEN cur;

read_loop: LOOP
FETCH cur INTO book_title;
IF done THEN
LEAVE read_loop;
END IF;
SELECT book_title;
END LOOP;

CLOSE cur;
END //
DELIMITER ;

CALL ListBooks();

Questa stored procedure elenca tutti i titoli dei libri uno per uno.

Dichiarazioni di Gestione delle Condizioni di MySQL

Le dichiarazioni di gestione delle condizioni ci permettono di gestire errori e avvisi in modo elegante.

DELIMITER //
CREATE PROCEDURE SafeInsert(IN book_title VARCHAR(100), IN book_author VARCHAR(50))
BEGIN
DECLARE EXIT HANDLER FOR 1062
BEGIN
SELECT 'Errore: Entry duplicata' AS Message;
END;

INSERT INTO books (title, author) VALUES (book_title, book_author);
SELECT 'Libro aggiunto con successo' AS Message;
END //
DELIMITER ;

CALL SafeInsert('Gatsby il Magnifico', 'F. Scott Fitzgerald');

Questa stored procedure inserisce un libro in modo sicuro, gestendo il caso in cui il libro potrebbe già esistere.

E voilà! Avete appena compiuto i vostri primi passi nel mondo delle dichiarazioni di MySQL. Ricordate, la pratica rende perfetti, quindi non avete paura di sperimentare con questi comandi. Prima di sapere, sarete in grado di gestire database come un vero professionista!

Credits: Image by storyset