InnoMarts logo
InnoMarts
Fast websites
← Back to course

Primi Passi con PostgreSQL

Primi Passi con PostgreSQL

Benvenuto nel corso PostgreSQL.

Sì.

Stiamo entrando nel mondo dei database.

Non andare in panico.

Un database non è un drago che vive sotto il server.

Anche se a volte si comporta così.

PostgreSQL è uno dei sistemi di database più potenti e rispettati al mondo.

Viene usato da sviluppatori, aziende, startup, banche, web app, API, dashboard e probabilmente anche da almeno un sistema misterioso che nessuno osa toccare perché “funziona, non riavviarlo.”

In questo corso impareremo PostgreSQL passo dopo passo.

Niente magia.

Niente teoria spaventosa tutta insieme.

Niente “leggi 900 pagine di documentazione e raggiungi l’illuminazione.”

Costruiremo comprensione attraverso la pratica.

Oggi iniziamo dalle basi.

Cos’è PostgreSQL.

Come funziona.

Come installarlo.

Come aprire la shell di PostgreSQL.

Come creare un database.

Come creare una tabella.

Come inserire dati.

Come leggere dati.

Piccoli passi.

Progresso reale.

Molto database.

Cosa Imparerai

In questa lezione imparerai:

Alla fine di questa lezione avrai un database PostgreSQL funzionante sul tuo computer.

Non solo teoria.

Un database reale.

Piccolo.

Fresco.

Pronto a salvare dati.

Come un quaderno.

Ma con più punto e virgola.

Che Cos'è PostgreSQL?

PostgreSQL è un sistema di gestione di database relazionali.

Suona serio.

Perché lo è.

Ma l’idea è semplice.

PostgreSQL salva dati.

Puoi usarlo per salvare:

Un sito può dimenticare tutto quando aggiorni la pagina.

Un database ricorda.

È il suo lavoro.

PostgreSQL è molto bravo a ricordare.

A volte troppo bravo.

Cancella con attenzione.

Che Cos'è un Database?

Un database è un posto dove i dati vengono salvati in modo organizzato.

Immagina un database come un armadio digitale.

Dentro l’armadio hai tabelle.

Ogni tabella salva un tipo di informazione.

Per esempio:

Database: online_shop

Tabelle:
  users
  products
  orders

La tabella users salva utenti.

La tabella products salva prodotti.

La tabella orders salva ordini.

Idea semplice.

Molto potente.

Come scatole in garage.

Solo che PostgreSQL non dimentica dove ha messo il cacciavite.

Di solito.

Che Cos'è una Tabella?

Una tabella salva dati in righe e colonne.

Esempio:

tabella users

id | name   | email
---|--------|------------------
1  | Anna   | anna@example.com
2  | Marco  | marco@example.com
3  | Viktor | viktor@example.com

Ogni colonna descrive un tipo di dato.

Per esempio:

Ogni riga è un record.

Un utente.

Un prodotto.

Un ordine.

Una tabella è come un foglio Excel.

Ma più forte.

Più strutturata.

Meno probabile che venga distrutta da qualcuno che trascina una cella per sbaglio alle 2 di notte.

Che Cos'è SQL?

SQL significa Structured Query Language.

È il linguaggio che usiamo per parlare con i database.

Con SQL possiamo dire:

SELECT * FROM users;

Questo significa:

Dammi tutti gli utenti.

Possiamo anche dire:

INSERT INTO users (name, email)
VALUES ('Anna', 'anna@example.com');

Questo significa:

Aggiungi un nuovo utente.

SQL non è JavaScript.

SQL ha il suo stile.

Le sue regole.

Il suo drama.

Ma non è impossibile.

Lo imparerai passo dopo passo.

SQL è come dare istruzioni a un bibliotecario molto serio.

Se l’istruzione è chiara, il bibliotecario ti dà i dati.

Se l’istruzione è sbagliata, il bibliotecario ti giudica silenziosamente con un messaggio di errore.

Installare PostgreSQL

Devi avere PostgreSQL installato sul sistema.

Scegli il comando per la tua distribuzione Linux.

Arch Linux

sudo pacman -S postgresql

Inizializza il database cluster:

sudo -iu postgres initdb -D /var/lib/postgres/data

Avvia PostgreSQL:

sudo systemctl enable --now postgresql

Controlla lo stato:

systemctl status postgresql

Se vedi active (running), bene.

PostgreSQL è vivo.

Probabilmente sta già giudicando il tuo SQL.

Ubuntu o Debian

sudo apt update
sudo apt install postgresql postgresql-contrib

Avvia PostgreSQL:

sudo systemctl enable --now postgresql

Controlla lo stato:

systemctl status postgresql

Fedora

sudo dnf install postgresql-server postgresql-contrib

Inizializza PostgreSQL:

sudo postgresql-setup --initdb

Avvia PostgreSQL:

sudo systemctl enable --now postgresql

Controlla lo stato:

systemctl status postgresql

Bene.

Ora PostgreSQL dovrebbe essere in esecuzione.

Se non lo è, non andare in panico.

L’installazione di un database a volte si comporta come un gatto che entra in una scatola.

Dovrebbe funzionare.

Ma potrebbe avere bisogno di incoraggiamento.

Aprire PostgreSQL con psql

PostgreSQL include uno strumento da terminale chiamato psql.

psql ti permette di parlare direttamente con PostgreSQL.

Aprilo con:

sudo -iu postgres psql

Dovresti vedere qualcosa tipo:

postgres=#

Questo significa che sei dentro la shell di PostgreSQL.

Complimenti.

Ora stai parlando direttamente con il database.

Usa i tuoi poteri con responsabilità.

Per uscire da psql, scrivi:

\q

Importante:

I comandi PostgreSQL spesso richiedono un punto e virgola:

SELECT version();

Ma i comandi speciali di psql, come \q, \l e \dt, non richiedono punto e virgola.

Sì.

Ci sono due tipi di comandi.

Perché i database amano tenere svegli i principianti.

Controllare la Versione di PostgreSQL

Dentro psql, esegui:

SELECT version();

Dovresti vedere informazioni sulla versione di PostgreSQL.

Questo conferma che PostgreSQL funziona.

Hai appena chiesto al database:

Chi sei?

E lui ha risposto.

Educatamente.

Con troppe informazioni.

Elencare i Database

Dentro psql, esegui:

\l

Questo elenca i database.

Potresti vedere database come:

postgres
template0
template1

Questi sono database predefiniti.

Non eliminarli.

Sono importanti.

PostgreSQL li ha creati per motivi di sistema.

Quando PostgreSQL crea qualcosa chiamato template0, tu lascialo stare.

Lui sa cose.

Creare il Tuo Primo Database

Ora crea il tuo primo database.

Dentro psql, esegui:

CREATE DATABASE learning_postgresql;

Non dimenticare il punto e virgola.

Se tutto funziona, PostgreSQL dice:

CREATE DATABASE

Ora elenca di nuovo i database:

\l

Dovresti vedere:

learning_postgresql

Complimenti.

Hai creato un database.

Un piccolo regno per i tuoi dati.

Ancora niente castello.

Ma abbiamo la terra.

Connettersi al Database

Per connetterti al nuovo database, esegui:

\c learning_postgresql

Dovresti vedere qualcosa tipo:

You are now connected to database "learning_postgresql"

Ora il prompt potrebbe cambiare:

learning_postgresql=#

Questo significa che stai lavorando dentro il tuo nuovo database.

Bene.

Fai attenzione.

Ora stai operando dentro il tuo regno dei dati.

Piccolo regno.

Ma conta.

Creare la Tua Prima Tabella

Ora crea una tabella chiamata students.

Esegui:

CREATE TABLE students (
  id SERIAL PRIMARY KEY,
  name VARCHAR(100) NOT NULL,
  age INTEGER,
  email VARCHAR(150)
);

Questo crea una tabella con quattro colonne:

Capiscilo bene.

id SERIAL PRIMARY KEY

Crea un ID auto-incrementale.

PostgreSQL assegnerà automaticamente un numero a ogni riga.

name VARCHAR(100) NOT NULL

Crea una colonna di testo per il nome dello studente.

NOT NULL significa che il nome è obbligatorio.

Niente studenti misteriosi senza nome.

age INTEGER

Crea una colonna numerica.

email VARCHAR(150)

Crea una colonna di testo per l’email.

Bene.

Ora abbiamo una tabella.

L’armadio del database ha il suo primo cassetto.

Molto emozionante.

Per i database.

Mostrare le Tabelle

Per mostrare le tabelle nel database corrente, esegui:

\dt

Dovresti vedere:

students

Se la vedi, bene.

La tua tabella esiste.

Se non la vedi, controlla:

PostgreSQL di solito ti dice cosa è andato storto.

Non sempre con gentilezza.

Ma te lo dice.

Inserire Dati

Ora aggiungiamo studenti.

Esegui:

INSERT INTO students (name, age, email)
VALUES ('Anna', 22, 'anna@example.com');

PostgreSQL dovrebbe dire:

INSERT 0 1

Questo significa che una riga è stata inserita.

Ora aggiungi altri studenti:

INSERT INTO students (name, age, email)
VALUES ('Marco', 28, 'marco@example.com');

INSERT INTO students (name, age, email)
VALUES ('Viktor', 33, 'viktor@example.com');

Ora abbiamo dati.

Dati reali.

Non molti dati.

Ma abbastanza per far sentire utile il database.

Come dare a un quaderno la sua prima pagina.

Leggere Dati con SELECT

Per leggere tutti gli studenti, esegui:

SELECT * FROM students;

Dovresti vedere qualcosa tipo:

id |  name  | age |       email
---+--------+-----+-------------------
1  | Anna   | 22  | anna@example.com
2  | Marco  | 28  | marco@example.com
3  | Viktor | 33  | viktor@example.com

Questa è la tua prima query SQL.

Capiscila.

SELECT

significa:

Prendi dati.

*

significa:

Tutte le colonne.

FROM students

significa:

Dalla tabella students.

Quindi:

SELECT * FROM students;

significa:

Prendi tutte le colonne da tutti gli studenti.

Semplice.

Potente.

A volte troppo potente.

Nelle applicazioni reali spesso eviti SELECT * quando non ti servono tutte le colonne.

Ma per imparare è perfetto.

Selezionare Colonne Specifiche

Puoi selezionare solo alcune colonne:

SELECT name, email FROM students;

Output:

 name  |       email
-------+-------------------
 Anna  | anna@example.com
 Marco | marco@example.com
 Viktor| viktor@example.com

Questo è utile quando non ti servono tutti i dati.

Magari ti servono nomi ed email.

Non le età.

Quindi chiedi solo nomi ed email.

PostgreSQL apprezza richieste precise.

Anche gli umani.

Di solito.

Parole Chiave SQL

Potresti notare che le parole chiave SQL sono scritte in maiuscolo:

SELECT * FROM students;

Ma funziona anche così:

select * from students;

SQL è quasi sempre case-insensitive per le parole chiave.

Però scrivere le parole chiave in maiuscolo rende le query più leggibili.

Quindi in questo corso scriveremo:

SELECT
FROM
WHERE
INSERT
UPDATE
DELETE

Non è obbligatorio.

Ma è una buona abitudine.

Le buone abitudini rendono il debugging futuro meno doloroso.

Non indolore.

Meno doloroso.

I Punto e Virgola Contano

In SQL, i comandi di solito finiscono con punto e virgola:

SELECT * FROM students;

Se dimentichi il punto e virgola, psql aspetta altro input.

Esempio:

SELECT * FROM students

Poi il prompt può cambiare e aspettare.

Puoi completare il comando scrivendo:

;

Questo è un momento classico da principiante.

Pensi che PostgreSQL sia bloccato.

Ma sta solo aspettando.

Come un cameriere che non se ne va perché non hai finito la frase.

Comandi psql Utili

Ecco alcuni comandi utili di psql:

\l

Elenca i database.

\c database_name

Connettiti a un database.

\dt

Mostra le tabelle.

\d table_name

Mostra la struttura della tabella.

Esempio:

\d students

\q

Esci da psql.

Questi comandi non sono SQL.

Sono comandi speciali di psql.

Per questo iniziano con \.

Il backslash è la tua bacchetta magica del terminale.

Una bacchetta molto piccola.

Controllare la Struttura della Tabella

Esegui:

\d students

Dovresti vedere la struttura della tabella.

Mostrerà colonne, tipi e vincoli.

Potresti vedere qualcosa tipo:

id    | integer
name  | character varying(100)
age   | integer
email | character varying(150)

Questo ti aiuta a ispezionare la tabella.

Molto utile quando dimentichi cosa hai creato.

E dimenticherai.

Tutti dimenticano.

I database ricordano.

Gli umani fingono.

Errori Comuni

Dimenticare il Punto e Virgola

Sbagliato:

SELECT * FROM students

Corretto:

SELECT * FROM students;

I comandi SQL di solito hanno bisogno di ;.

Piccolo simbolo.

Grande importanza.

Come l’ultima vite in una mensola.

Non Connettersi al Database Giusto

Potresti creare una tabella in un database e poi cercarla in un altro.

Esempio:

\c postgres
\dt

Potresti non vedere la tabella students.

Perché?

Perché l’hai creata dentro:

learning_postgresql

Torna lì:

\c learning_postgresql
\dt

Ora la tabella appare.

I database sono mondi separati.

Non cercare i tuoi calzini a casa del vicino.

Confondere SQL e Comandi psql

Questo è SQL:

SELECT * FROM students;

Questo è un comando psql:

\dt

I comandi SQL di solito finiscono con ;.

I comandi psql di solito no.

Strumenti diversi.

Stesso terminale.

Leggera confusione.

Normale.

Dimenticare le Virgolette per il Testo

Sbagliato:

INSERT INTO students (name, age, email)
VALUES (Anna, 22, anna@example.com);

Corretto:

INSERT INTO students (name, age, email)
VALUES ('Anna', 22, 'anna@example.com');

I valori di testo vogliono virgolette singole.

I numeri no.

PostgreSQL è severo.

Come un commercialista con la tastiera.

Pratica

Crea una nuova tabella chiamata books.

Deve avere:

Esempio:

CREATE TABLE books (
  id SERIAL PRIMARY KEY,
  title VARCHAR(150) NOT NULL,
  author VARCHAR(100),
  year_published INTEGER
);

Inserisci tre libri:

INSERT INTO books (title, author, year_published)
VALUES ('Clean Code', 'Robert C. Martin', 2008);

Poi leggi tutti i libri:

SELECT * FROM books;

Poi leggi solo i titoli:

SELECT title FROM books;

Questo ti aiuterà a praticare:

La pratica conta.

PostgreSQL non entra nel cervello solo dagli occhi.

Servono dita.

Tastiera.

Errori.

E magari caffè.

Mini Challenge

Crea un database chiamato:

personal_library

Dentro, crea una tabella chiamata:

books

La tabella deve salvare:

Aggiungi almeno cinque libri.

Poi esegui:

SELECT * FROM books;

Bonus:

Seleziona solo:

title, author

È semplice.

Ma è già una struttura database reale.

Piccolo database.

Concetto reale.

Grande passo.

Riepilogo

Oggi hai imparato:

Questo è un inizio forte.

Ora hai PostgreSQL installato.

Hai creato un database.

Hai creato una tabella.

Hai inserito dati.

Hai selezionato dati.

Questo è già il ritmo centrale dei database:

Creare struttura.

Inserire dati.

Leggere dati.

Tutto il resto si costruisce sopra.

Molto lentamente.

Molto potentemente.

Molto PostgreSQL.

Prossima Lezione

Nella prossima lezione impareremo di più su database e tabelle.

Guarderemo meglio:

Perché un brutto design di tabella è come un garage disordinato.

All’inizio sembra tutto ok.

Poi un giorno ti serve un cavo.

E crolla tutto.