FASI DI PROGETTAZIONE BASE DATI – NEGOZIO DI PESCI

Per progettare una base di dati per un negozio di pesci, è necessario seguire un processo ben strutturato che consenta di gestire correttamente le informazioni relative ai pesci in vendita, ai clienti, agli ordini, ai pagamenti e alla gestione del magazzino. Di seguito, ti guiderò attraverso le fasi principali del processo di progettazione, passo dopo passo, con esempi pratici.

1. Analisi dei Requisiti

La prima fase consiste nell'identificare le esigenze specifiche del negozio di pesci e le funzionalità necessarie per la gestione del business. Bisogna capire quali dati devono essere archiviati, quali operazioni devono essere eseguite e come le diverse entità (clienti, pesci, ordini, pagamenti, ecc.) sono correlate.

Requisiti principali:

  • Clienti: Ogni cliente ha informazioni come nome, indirizzo, telefono, email.

  • Pesci: Ogni pesce ha un nome, una specie, un prezzo, una quantità disponibile in magazzino, una descrizione, e forse un tipo di acquario richiesto.

  • Ordini: Un ordine contiene informazioni su quali pesci sono stati acquistati, in quale quantità, e a quale prezzo.

  • Pagamenti: I pagamenti devono essere registrati, indicando il metodo di pagamento, la data e l'importo.

  • Acquisti da fornitori: I pesci vengono acquistati dai fornitori, e questa relazione deve essere tracciata.

Domande da porsi:

  • Quali informazioni devono essere archiviate per i pesci (specie, prezzo, quantità)?

  • Come devono essere gestiti gli ordini (da quale cliente, in che data, con quali pesci)?

  • Come viene gestito il pagamento degli ordini?

  • Come vengono gestiti gli acquisti da fornitori (per esempio, quando arriva una nuova fornitura di pesci)?

2. Disegno Logico dei Dati

In questa fase, traduciamo i requisiti raccolti in una struttura logica, cioè in una rappresentazione delle entità e delle loro proprietà, così come le relazioni che intercorrono tra di esse.

Entità principali:

  • Cliente (ID_cliente, nome, indirizzo, telefono, email)

  • Pesce (ID_pesce, nome, specie, prezzo, quantità_disponibile, tipo_acquario)

  • Ordine (ID_ordine, data_ordine, ID_cliente, stato_ordine)

  • Dettaglio_Ordine (ID_ordine, ID_pesce, quantità, prezzo_unitario)

  • Pagamento (ID_pagamento, ID_ordine, data_pagamento, metodo_pagamento, importo)

  • Fornitore (ID_fornitore, nome_fornitore, contatti)

  • Fornitura (ID_fornitore, ID_pesce, quantità_fornita, data_fornitura)

Relazioni tra le entità:

  • Un Cliente può fare molti Ordini.

  • Un Ordine può contenere molti Dettagli_Ordine (cioè pesci acquistati).

  • Un Ordine può essere associato a un Pagamento.

  • Un Pesce può essere acquistato in più Ordini.

  • Un Pesce può essere fornito da più Fornitori.

  • Un Fornitore può fornire molti Pesci.

3. Modello Entità-Relazione (ER)

In questa fase, creiamo un modello entità-relazione (ER), che rappresenta graficamente le entità e le relazioni tra di esse. Un diagramma ER aiuta a visualizzare come i dati sono strutturati e collegati tra loro.

Entità:

  • Cliente: ID_cliente, nome, indirizzo, telefono, email

  • Pesce: ID_pesce, nome, specie, prezzo, quantità_disponibile, tipo_acquario

  • Ordine: ID_ordine, data_ordine, ID_cliente, stato_ordine

  • Dettaglio_Ordine: ID_ordine, ID_pesce, quantità, prezzo_unitario

  • Pagamento: ID_pagamento, ID_ordine, data_pagamento, metodo_pagamento, importo

  • Fornitore: ID_fornitore, nome_fornitore, contatti

  • Fornitura: ID_fornitore, ID_pesce, quantità_fornita, data_fornitura

Relazioni:

  • Cliente 1:N Ordine: Un cliente può fare molti ordini.

  • Ordine 1:N Dettaglio_Ordine: Un ordine può contenere molti dettagli di ordine (pesci acquistati).

  • Ordine 1:1 Pagamento: Ogni ordine è associato a un pagamento (se effettuato).

  • Pesce N:M Dettaglio_Ordine: Un pesce può apparire in molti ordini, e ogni ordine può contenere più pesci.

  • Fornitore N:M Pesce: Un fornitore può fornire più pesci, e ogni pesce può essere fornito da più fornitori.

4. Creazione del Modello Relazionale

In questa fase, il modello ER viene tradotto in un modello relazionale, in cui le entità del modello ER diventano tabelle e le relazioni sono rappresentate da chiavi esterne.

Esempio di tabelle SQL:

CREATE TABLE Cliente (
    ID_cliente INT PRIMARY KEY,
    nome VARCHAR(100),
    indirizzo VARCHAR(200),
    telefono VARCHAR(15),
    email VARCHAR(100)
);

CREATE TABLE Pesce (
    ID_pesce INT PRIMARY KEY,
    nome VARCHAR(100),
    specie VARCHAR(50),
    prezzo DECIMAL(10, 2),
    quantità_disponibile INT,
    tipo_acquario VARCHAR(50)
);

CREATE TABLE Ordine (
    ID_ordine INT PRIMARY KEY,
    data_ordine DATE,
    ID_cliente INT,
    stato_ordine VARCHAR(50),
    FOREIGN KEY (ID_cliente) REFERENCES Cliente(ID_cliente)
);

CREATE TABLE Dettaglio_Ordine (
    ID_ordine INT,
    ID_pesce INT,
    quantità INT,
    prezzo_unitario DECIMAL(10, 2),
    PRIMARY KEY (ID_ordine, ID_pesce),
    FOREIGN KEY (ID_ordine) REFERENCES Ordine(ID_ordine),
    FOREIGN KEY (ID_pesce) REFERENCES Pesce(ID_pesce)
);

CREATE TABLE Pagamento (
    ID_pagamento INT PRIMARY KEY,
    ID_ordine INT,
    data_pagamento DATE,
    metodo_pagamento VARCHAR(50),
    importo DECIMAL(10, 2),
    FOREIGN KEY (ID_ordine) REFERENCES Ordine(ID_ordine)
);

CREATE TABLE Fornitore (
    ID_fornitore INT PRIMARY KEY,
    nome_fornitore VARCHAR(100),
    contatti VARCHAR(200)
);

CREATE TABLE Fornitura (
    ID_fornitore INT,
    ID_pesce INT,
    quantità_fornita INT,
    data_fornitura DATE,
    PRIMARY KEY (ID_fornitore, ID_pesce),
    FOREIGN KEY (ID_fornitore) REFERENCES Fornitore(ID_fornitore),
    FOREIGN KEY (ID_pesce) REFERENCES Pesce(ID_pesce)
);

5. Popolamento e Test dei Dati

Ora che la struttura del database è pronta, possiamo inserire alcuni dati di esempio per testare il sistema e vedere se le query funzionano correttamente.

Esempio di inserimento di dati:

-- Inserimento di un cliente
INSERT INTO Cliente (ID_cliente, nome, indirizzo, telefono, email)
VALUES (1, 'Alessandro Rossi', 'Via delle Rose 10, Firenze', '0551234567', Questo indirizzo email è protetto dagli spambots. È necessario abilitare JavaScript per vederlo.');

-- Inserimento di un pesce
INSERT INTO Pesce (ID_pesce, nome, specie, prezzo, quantità_disponibile, tipo_acquario)
VALUES (1, 'Pesce Betta', 'Betta splendens', 5.99, 50, 'Acquario Tropicale');

-- Inserimento di un ordine
INSERT INTO Ordine (ID_ordine, data_ordine, ID_cliente, stato_ordine)
VALUES (1, '2025-04-09', 1, 'In elaborazione');

-- Inserimento di un dettaglio ordine
INSERT INTO Dettaglio_Ordine (ID_ordine, ID_pesce, quantità, prezzo_unitario)
VALUES (1, 1, 3, 5.99);

-- Inserimento di un pagamento
INSERT INTO Pagamento (ID_pagamento, ID_ordine, data_pagamento, metodo_pagamento, importo)
VALUES (1, 1, '2025-04-09', 'Carta di credito', 17.97);

-- Inserimento di un fornitore
INSERT INTO Fornitore (ID_fornitore, nome_fornitore, contatti)
VALUES (1, 'Acquariologia Srl', 'Via Acquari 25, Milano');

-- Inserimento di una fornitura
INSERT INTO Fornitura (ID_fornitore, ID_pesce, quantità_fornita, data_fornitura)
VALUES (1, 1, 100, '2025-04-01');

6. Test delle Query

A questo punto, possiamo eseguire delle query per testare il sistema. Ad esempio, per ottenere tutti gli ordini di un cliente, possiamo usare una query simile a questa:

SELECT O.ID_ordine, O.data_ordine, P.nome, DO.quantità, DO.prezzo_unitario
FROM Ordine O
JOIN Dettaglio_Ordine DO ON O.ID_ordine = DO.ID_ordine
JOIN Pesce P ON DO.ID_pesce = P.ID_pesce
WHERE O.ID_cliente = 1;

Conclusione

Concludendo, le fasi di progettazione per una base di dati di un negozio di pesci includono la raccolta dei requisiti, la progettazione logica dei dati, la creazione del modello entità-relazione (ER), la traduzione in modello relazionale, e infine i test con dati di esempio. Queste fasi ti permetteranno di creare un sistema efficiente per gestire clienti, ordini, pesci, pagamenti, fornitori e forniture, garantendo una gestione ottimale del negozio di pesci.

 

 

Back to top