Descrizione e specifiche

Si desidera sviluppare un database che contenga tutte le informazioni relative ad un generico campionato di calcio, partendo da un insieme di requisiti. L'insieme di operazioni volte ad ottenere questo risultato può essere schematizzata qui di seguito:

Analisi dei requisiti: saranno analizzate le caratteristiche del sistema

Schema Concettuale della base di dati, attraverso il modello Entità-Relazione

Analisi delle funzioni, ovvero descrizione delle operazioni che si prevede effettuare su questo database, con il relativo carico

Ristrutturazione del modello E-R, per poi giungere allo schema logico

Progettazione Logica del Modello Relazionale

Implementazione di alcune operazioni

Specifiche sui dati

Lo scopo dell'esercitazione è quello di costruire una base di dati per gestire le informazioni relative a un campionato di calcio.

Una partita è caratterizzata dal girone di appartenenza della squadra, dalla data della giornata in cui è stata disputata, dal numero progressivo della giornata e dalle squadre fra cui la partita si è svolta. Ogni squadra è caratterizzata dal suo nome, dalla città di appartenenza e dall'allenatore.

Per ogni partita si vuole registrare se la squadra ha giocato o meno la partita in casa. Di ogni squadra sono noti i giocatori, ognuno dei quali caratterizzato da nome, data e città di nascita e ruolo principale.

Per ogni giornata del campionato si vogliono sapere i punti relativi a ogni squadra, i giocatori di ogni squadra che hanno effettivamente giocato ed in che ruolo. Per ogni partita, si vuole tenere traccia dell'arbitro, caratterizzato dal nome, e dalla città di nascita.

Di ogni partita se ne vuole conoscere il risultato finale ed i giocatori che hanno segnato.

Si deve tenere traccia storica di tutte le partite disputate, con i relativi risultati, squadre e giocatori partecipanti.

Specifiche sulle operazioni

Prima di considerare l'insieme di operazioni effettuabili sul database, si considerano alcune premesse: si suppone che il numero di squadre partecipanti ad un qualunque girone sia fissato, come normalmente avviene nella realtà. Si considera allora un numero di 20 squadre per girone, per un totale di 3 gironi. Le operazioni che si intende realizzare sono le seguenti:

O1 Introduci una nuova Giornata (frequenza 3 a settimana)

O2 Introduci nuova Partita (frequenza 30 a settimana)

O3 Introduci un nuovo Giocatore (frequenza 2 al mese)

O4 Introduci una nuova Squadra (frequenza 60 all'anno)

O5 Introduci un nuovo Allenatore (frequenza 1 al mese)

O6 Introduci un nuovo Arbitro (frequenza 1 al mese)

O7 Introduci Giocatore convocato (frequenza 1000 a settimana )

O8 Visualizza scheda Squadra (frequenza 100 a settimana)

O9 Visualizza risultati Squadra (frequenza 300 a settimana)

O10 Visualizza scheda Giocatore (frequenza 200 a settimana)

O11 Visualizza Giornata (frequenza 50 a settimana)

O12 Introduci Risultato (frequenza 30 a settimana)

O13 Visualizza Risultato (frequenza 100 a settimana)

O14 Visualizza Classifica (frequenza 20 a settimana)

O15 Sposta Giocatore da una Squadra ad un'altra Squadra (frequenza 2 al mese)

O16 Visualizza le partite giocate da un Giocatore (frequenza 10 a settimana)

O17 Visualizza le partite dirette da un Arbitro (frequenza 5 a settimana)

O18 Aggiungi Giocatore a Squadra (frequenza 30 all'anno)

O19 Visualizza Classifica Marcatori (frequenza 20 a settimana)

1 Analisi dei Requisiti

Si vuole analizzare la il problema, cercando di dare una struttura ai requisiti che via via si raccolgono, estrapolando dai dati inizialmente ambigui e disomogenei un insieme organizzato ed omogeneo di dati.

Prima di tutto si individuano gli elementi fondamentali del problema, aventi spesso vita propria, ed ad essi si associano delle entità, indicando in particolare il significato dell'entità ed i termini ad essa collegati.

Successivamente si riorganizza l'insieme di informazioni possedute suddividendole in categorie legate alle entità appena create. In questa fase si cerca di filtrare tutte le ambiguità andando per esempio ad eliminare tutti i sinonimi, usando lo stesso termine per lo stesso concetto.

Al termine di questa fase si ottengono le seguenti specifiche:

Dati di carattere generale

Glossario dei termini

Dati sulla Partita

Dati sulle Squadre

Dati sull'Allenatore

Dati sull'Arbitro

Dati sui Giocatori

Dati sulla Giornata

Dati sul Risultato

2 Progettazione Concettuale

Sulla base delle considerazioni fatte in precedenza, si ottiene il seguente schema concettuale:

Per giungere a questo schema prima di tutto si è considerata la Squadra come un'entità: essa è collegata alle entità Giocatore, Allenatore e Partita. Supponendo che la squadra possa avere un allenatore differente col passare del tempo, si è schematizzato esso stesso come un'entità, piuttosto che come un semplice attributo.

Importante è il concetto di entità Partita: l'entità Partita consiste fondamentalmente in una coppia di squadre. Ad essa fa riferimento sia l'entità Arbitro che l'entità Giornata: quest'ultima tiene traccia della data e del giorno delle partite.

L'entità partita e l'entità Giocatore sono messe in relazione attraverso la relazione Convoca, la quale permette di rappresentare quei giocatori che hanno effettivamente partecipato ad una determinata Partita, nonché fornire l'informazione sul ruolo da essi avuto e gli eventuali goal effettuati.

Un'altra entità è il Giocatore: esso può essere convocato in una determinata giornata da una Squadra.

Dizionario dei dati - Entità

Dizionario dei dati - Relazioni

3 Analisi delle funzioni

Ai fini della realizzazione dello schema logico, è necessaria una valutazione del carico che questa applicazione possiede. Ciò viene effettuato in due passi:

1. andando a ricavare il volume dei dati memorizzati ovvero il numero di istanze di ogni dato
2. andando a ricavare il modo con cui le varie operazioni accedono ai dati e la frequenza con cui lo fanno

Il primo passo viene realizzato costruendo una tabella, detta Tavola dei volumi,  nella quale vengono mostrati, per ogni entità, relazione ed attributo, il numero previsto di istanze che quell'oggetto avrà. Nella figura seguente è mostrata la tavola dei volumi:

Tavola dei volumi

Per effettuare il calcolo dei volumi si è sono fatte alcune le seguenti considerazioni:

1. si hanno 60 squadre, quindi  38 giornate, per cui si hanno 38x30 = 1140 Partite, Risultati, Arbitraggi, Incontri
2. si suppone che ogni squadra abbia una media di 22 giocatori, per cui i Giocatori sotto contratto saranno 22x60 = 1120
3. si suppone che i giocatori in totale siano 1600
4. si suppone che in media ogni squadra convochi 18 giocatori a partita, per cui il numero totale di giocatori convocati è 18x30x38 = 20520

Il secondo passo dell'analisi delle funzioni consiste come detto in precedenza nel caratterizzare le operazioni. Si introduce una tabella, detta Tavola delle frequenze, la quale fornisce la frequenza con la quale si ripeteranno a regime le varie operazioni. Segue la tabella citata:

Tavola delle frequenze

4 Progettazione logica indipendente dal modello

Si vuole effettuare la progettazione logica del database. Fondamentalmente essa è costituita da una sequenza di operazioni che una dopo l'altra conducono alla fine allo schema logico definitivo. Tipicamente le fasi che vengono seguite possono essere riassunte in un insieme di operazioni del tipo seguente:

Analisi delle ridondanze: si verifica la presenza di eventuali ridondanze nello schema concettuale. Normalmente esse possono presentarsi in corrispondenza di cicli di relazioni o di attributi che contengano informazioni ricavabili in maniera alternativa. In base ad un'analisi del carico dell'operazione si decide se conviene tenere o eliminare la ridondanza

Eliminazione delle gerarchie ovvero di tutte le entità dovute a generalizzazioni

Partizionamento/accorpamento delle Entità e delle Relazioni

Scelta degli identificatori primari

Al fine di analizzare le eventuali ridondanze presenti si effettua un'analisi di tutte le operazioni richieste al database.

4.1 Analisi delle operazioni

O1 Introduci una nuova Giornata

L'introduzione di una nuova giornata corrisponde ad inserire i due attributi Data Giornata, Numero Giornata dell'entità Giornata.

O2 Introduci nuova Partita

Questa operazione consiste nell'inserire una singola partita nell'ambito di una determinata giornata: per far ciò è necessario introdurre i due attributi dell'entità Partita, ovvero Casa e Girone; successivamente è necessario introdurre l'informazione relativa all'arbitro che dirigerà la partita ed infine il numero della Giornata. Nella figura seguente si mostrano le entità e relazioni coinvolte dall'operazione (sono stati evidenziati solo gli attributi effettivamente utilizzati in questa operazione):

O3 Introduci Giocatore

L'introduzione di un Giocatore è un'operazione molto semplice: si suppone prima di tutto che un giocatore possa esistere a prescindere dalle squadre ovvero che non debba per forza essere sotto contratto. Ciò schematizza una tipica situazione reale: esistono molti giocatori che non sono iscritti nel campionato italiano ma sono osservati da molte squadre ai fini di un futuro acquisto.

Quindi l'ipotesi di considerare i giocatori non legati inizialmente alle squadre permette di poter trattare operazioni di acquisto/cessione degli stessi a club non iscritti al campionato italiano.

A questo punto si osserva che l'inserimento di un nuovo Giocatore consiste semplicemente nell'inserire i suoi dati anagrafici, il suo Codice Fiscale ed il suo Ruolo Principale.

O4 Introduci una nuova Squadra

Analogamente al caso precedente, si suppone che una Squadra possa esistere a prescindere dai Giocatori e dagli Allenatore: per questo motivo la creazione di una squadra consiste semplicemente nel fornire gli attributi Nome squadra e Città Squadra.

O5 Introduci Allenatore

L'introduzione di un Allenatore è contestuale alla sua assegnazione ad una determinata Squadra: d'altra parte se un allenatore non lavora per nessuna squadra basterà lasciare nullo il campo relativo alla squadra allenata. Si considera di questa scelta semplicemente perché si suppone che normalmente si hanno pochi cambiamenti di allenatore all'anno e quindi non varrebbe la pena creare un'operazione dedicata all'assegnazione di una determinata squadra ad un allenatore.

O6 Introduci Arbitro

In maniera analoga ai casi precedentemente esaminati, l'introduzione dell'Arbitro è facilmente ottenibile inserendo gli attributi Nome Arbitro, Città Arbitro e CF Arbitro.

O7 Introduci Giocatore convocato

L'operazione di inserimento di un giocatore convocato è molto importante in quanto coinvolge diverse relazioni ed entità, come si può osservare nella figura seguente: essa consiste nell'associare un Giocatore con il relativo Ruolo ad una determinata Partita. La partita a sua volta è individuata dal Numero della Giornata. Segue che lo schema concettuale che rappresenta le entità e relazioni coinvolte dall'operazione è il seguente:

O8 Visualizza scheda Squadra

Questa operazione consiste prima di tutto nel mostrare gli attributi di una Squadra, Nome Squadra e

Città Squadra; è necessario quindi specificare l'Allenatore ed i Giocatori. In particolare, per i Giocatori bisognerà fornire il Nome ed il Ruolo Principale ricoperto. Da queste considerazioni si può ricavare il seguente schema concettuale dell'operazione:

O9 Visualizza Risultati Squadra

Lo scopo di questa importante operazione è quello di calcolare i risultati di una Squadra, in particolare interessa ricavare le seguenti informazioni: Goal Fatti, Goal Subiti, Partite Vinte, Partite Perse, Partite Pareggiate, Punti Realizzati.

In base allo schema concettuale costruito, si può intuire che le entità e le relazioni coinvolte in questa operazione, possono essere mostrate nel seguente schema:

Ora a questo punto si vuole fare un'analisi del carico applicativo che questa operazione dovrebbe imporre; per far ciò si introduce la tavola degli accessi di questa operazione:

La seguente tabella mostra che per una generica squadra, per calcolare la sua posizione in classifica e le altre statistiche, è necessario effettuare fino a 38 accessi in lettura (si considera la situazione peggiore che corrisponde all'ultima partita di campionato). Considerato che questa operazione viene realizzata 300 volte a settimana, in totale si dovranno effettuare 1140 accessi in lettura alla relazione Incontro e 1140 accessi in lettura all'entità Partita, per un totale di 2280 accessi.

A questo punto si vuole vedere se, inserendo una ridondanza, si possa snellire il carico di lavoro dell'applicazione: per far ciò si introduce un attributo (Risultati Squadra) composto alla squadra, il quale rechi i seguenti attributi: Goal Fatti, Goal Subiti, Partite Vinte, Partite Perse, Partite Pareggiate, Punti Realizzati.

Ad ogni inserimento del risultato di una Partita si aggiorna l'attributo recante le informazioni sui risultati raggiunti dalla Squadra, Risultati Squadra. Si supponga per esempio di essere alla decima giornata: ciò vuol dire che Risultati Squadra fornirà per ogni Squadra il numero di punti, goal fatti e così via, aggiornato alla decima giornata appunto. Inserendo allora i risultato di una partita dell'undicesima giornata, basterà aggiornare per le squadre coinvolte i relativi risultati.

È evidente che con un tale tipo di approccio, ogni volta che si intende calcolare i risultati raggiunti da una squadra, non bisognerà effettuare una ricerca su tutte le partite effettuate, ma basterà semplicemente andare a fare una lettura di Risultati Squadra.

Si vuole vedere a questo punto il carico applicativo di questa operazione attraverso la tavola degli accessi:

Per ogni squadra, quando si inserisce il risultato di una Partita, dovendo aggiornare l'attributo Risultati Squadra, bisognerà:

1. leggere il suo valore corrente (L)
2. aggiornarlo (W) tenendo conto dell'ultima partita

Questa operazione andrà ripetuta 300 volte a settimana. Tenendo conto che le scritture hanno un peso doppio rispetto alle letture e ricordando che in totale ci sono 60 squadre, si ottiene il numero di accessi:

1. per la prima lettura si hanno 1 accesso a settimana per 60 squadre ovvero 60 accessi a settimana
2. per la prima scrittura si ha un accesso a settimana per 60 squadre, il tutto moltiplicato per due, per tenere in conto il fatto che si fa una scrittura, per cui si ottengono 120 accessi a settimana
3. la terza operazione, ovvero la  lettura di Risultati Squadra avviene 300 volte a settimana

In totale quindi il numero di accessi a settimana è pari a 480. Si osserva quindi che l'introduzione di una ridondanza riduce notevolmente il numero di accessi al database, senza tuttavia ingombrare molta memoria in più per conservare questo nuovo attributo.

Si ottiene allora il nuovo schema, mostrato nella figura seguente:

O10 Visualizza Scheda Giocatore

La scheda di un Giocatore consiste nel mostrare i suoi Dati Anagrafici, il Ruolo Principale, la Squadra per la quale gioca ed il numero di Goal fatti. Ovviamente lo schema al quale si può far riferimento in tal caso è il seguente:

In questo caso si osserva la presenza di una ridondanza, presente nell'attributo Goal Fatti: infatti essi potrebbero essere calcolati a partire dall'esame di tutte le convoche dei Giocatori. Ciò non conviene perché ciò implicherebbe molti accessi al database: è meglio un attributo del genere, il quale sia aggiornato ogni qual volta viene inserito un nuovo risultato.

O11 Visualizza Giornata

Questa operazione permette di fornire tutte le informazioni relative ad una giornata del campionato: Data e Numero della Giornata, Partite e Risultati di quest'ultime, se presenti. Lo schema al quale si può fare riferimento è il seguente:

O12 Introduci Risultato

Questa operazione consiste nell'inserire il risultato di una singola partita, fornendo in particolare le seguenti informazioni: Goal Squadra 1, Goal Squadra 2, Marcatori, squadra che gioca in Casa. Inoltre, successivamente a questa operazione è necessario aggiornare i Risultati Squadra (necessario per l'operazione O9) ed i Goal Fatti da ogni Giocatore (necessario per l'operazione O10). Per questi motivi lo schema concettuale al quale si fa riferimento è il seguente:

O13 Visualizza Risultato

Questa operazione consiste nel fornire tutte le informazioni relative ad una partita avvenuta; in particolare si intende fornire il numero di goal di ogni squadra, i Giocatori convocati ed i Marcatori della partita. Anche in questo caso bisognerà riferirsi per il funzionamento di questa operazione ad uno schema analogo a quello dell'operazione precedente.

O14 Visualizza Classifica

In base all'introduzione dell'attributo Risultati Squadra, il calcolo della classifica diventa un'operazione molto semplice, in quanto consiste nell'ordinare i Risultati Squadra già disponibili in base al punteggio di ogni squadra.

O15 Sposta Giocatore da una squadra all'altra

Questa è un'operazione molto semplice in quanto consiste nell'aggiornare solo la relazione contratto.

O16 Visualizza partite Giocate da un calciatore

La funzione richiesta in tal caso è quella di fornire quali partite un giocatore ha disputato ed i relativi goal effettuati. Per far ciò bisogna far riferimento al seguente schema concettuale:

O17 Visualizza partite dirette da un Arbitro

Analogamente al caso precedente, la relazione in questione può essere realizzata in maniera molto semplice andando a considerare la relazione esistente tra Partita ed Arbitro attraverso la relazione Arbitraggio.

O18 Aggiungi Giocatore a Squadra

L'inserimento di un nuovo giocatore si realizza semplicemente aggiornando la relazione esistente tra Giocatore e Squadra.

O19 Visualizza Classifica Marcatori

La classifica marcatori può essere facilmente ricavata andando ad ordire i giocatori presenti all'interno della relazione Convoca, in base al numero di Goal fatti.

4.2 Partizionamento/accorpamento delle Entità e delle Relazioni

Si evidenzia prima di tutto che non è necessario effettuare nessuna eliminazione delle gerarchie in quanto non esistono generalizzazioni nello schema.

Si vuole effettuare una riorganizzazione delle Entità e delle Relazioni al fine di rendere più efficienti le operazioni. Infatti si ottiene che il numero di accessi diminuisce

1. separando attributi di un concetto che vengono acceduti separatamente
2. raggruppando attributi di concetti diversi acceduti  insieme

In realtà le uniche modifiche che devono essere realizzate in tal senso sullo schema consistono nell'eliminare gli attributi composti. In tal caso si otterranno le seguenti modifiche:

5 Progettazione Logica del Modello Relazionale

La traduzione del modello E-R nel modello Relazionale avviene in due fasi:

1. traduzione delle entità in R-relazioni ovvero si traducono le entità del modello E-R ristrutturato in relazioni del modello relazionale. Questo passo individua un insieme di attributi iniziali per queste R-relazioni
2. a questi attributi vanno aggiunti successivamente altri attributi derivanti dalla traduzione delle relazioni del modello E-R

5.1 Traduzione di entità

Segue direttamente la traduzione delle entità:

• Giornata(NumeroGiornata, DataGiornata)

• Partita(NomePartita, Girone, Casa, GoalSquadra1, GoalSquadra2)

• Arbitro(CFArbitro, NomeArbitro, CittàArbitro)

• Giocatore(CFGiocatore, RuoloPrincipale, DataGiocatore, NomeGiocatore, CittàGiocatore)

• Squadra(NomeSquadra, CittàSquadra, GoalFatti, GoalSubiti,PuntiClassifica, PartiteVinte, PartitePerse, PartitePareggiate)

• Allenatore(NomeAllenatore, DataContratto)

5.2 Traduzione di relazioni

Si esaminino preliminarmente le relazioni uno a uno: per codificare la relazione Arbitraggio si aggiunge l'attributo Arbitro alla R-relazione Partita definita nel paragrafo precedente. Ovviamente deve essere presente un vincolo di integrità referenziale tra l'attributo Arbitro della R-relazione Partita e l'attributo CFArbitro della R-relazione Arbitro.

Per quanto riguarda la relazione Direzione, si fa un ragionamento analogo: si aggiunge a tal proposito l'attributo Allenatore alla R-relazione Squadra definita nel paragrafo precedente. Si introduce quindi un vincolo di integrità referenziale tra l'attributo Allenatore della R-relazione Squadra e l'attributo NomeAllenatore della R-relazione Allenatore.

Si passa ora ad esaminare le relazioni uno a molti: per schematizzare la relazione Calendario si aggiunge l'attributo Giornata alla R-relazione Partita. Il vincolo di integrità referenziale in questo caso è tra l'attributo Giornata della R-relazione Partita e l'attributo NumeroGiornata della R-relazione Giornata.

Per la relazione Contratto si aggiunge l'attributo Squadra alla R-relazione Giocatore. Il vincolo di integrità referenziale in questo caso è tra l'attributo Squadra della R-relazione Giocatore e l'attributo NomeSquadra della R-relazione Squadra.

La relazione Convoca può essere realizzata andando ad introdurre un'altra R-relazione; si considera allora la relazione Convoca nella maniera seguente:

Convoca(CFGiocatore, NomePartita, Ruolo)

Il vincolo di integrità referenziale che si ottiene è tra l'attributo NomePartita della R-relazione Partita e l'attributo NomePartita della R-relazione Convoca.

L'ultima operazione che bisogna fare è tradurre l'unica relazione molti a molti presente: la relazione in questione è Incontro. Essa può essere facilmente schematizzata con la R-Relazione seguente:

Incontro(NomePartita, Squadra)

dove NomePartita e Squadra sono legati da vincoli di integrità referenziale rispettivamente con NomePartita di Partita e NomeSquadra di Squadra.

In base a tutte le considerazioni fatte fin'ora si ottiene lo schema logico completo del database:

6 Implementazione delle funzioni  e delle tabelle

A questo punto si vogliono introdurre gli script delle tabelle e delle operazioni. Prima di far ciò si provvede però a realizzare uno schema che mostri graficamente la struttura ottenuta, evidenziando tutte le tabelle create, le loro chiavi primarie e quelle esterne.

6.1 Script di installazione

Si vogliono inserire gli script di installazione di tutte le tabelle del database: per far ciò è necessario prima di tutto effettuare un dimensionamento dei tablespace delle tabelle in questione. A tal fine è necessario tener conto del volume dei dati che queste tabelle devono contenere e delle frequenze con le quali si accede ad esse per aggiungere nuovi dati.

Inizialmente si ricava una dimensione base della tabella, la quale dipende fondamentalmente dal volume di dati a regime o dopo un certo tempo dalla messa in utilizzo del database.

Successivamente risulta necessario definire anche la velocità con cui la tabella incrementa le proprie dimensioni: quest'ultima dipende ovviamente dalla frequenza con cui essa viene aggiornata con nuovi valori.

Queste fondamentalmente sono le considerazioni effettuate per ricavare la dimensione di ogni tabella creata.

Per il dimensionamento delle tabelle è stata usata la seguente formula:

Dimensione Iniziale = Q + p₂*Q = p₁*N_T*Sum_i(Dim _ A_i*N_Ai) + p₂*Q

dove

Q è la dimensione totale che la tabella deve avere a regime

p₁ è una percentuale della dimensione totale che si intende allocare inizialmente

p₂ è una percentuale che permette di allocare una quantità ulteriore di memoria, per tenere conto dei vari indici usati

N_T è il numero di tuple

Dim _ A_i è la dimensione dell'attributo

N_Ai è la lunghezza in byte dell'attributo

A titolo di esempio si mostrano qui di seguito i calcoli effettuati per dimensionare il tablespace di alcune tabelle: per far ciò è necessario analizzare tutti i campi che compongono questa tabella.

Tabella Arbitro

A partire da queste informazioni è semplice il dimensionamento della tabella:

Dimensione = 50*(16 + 20 + 20)*2 + 0.2*[50*(16 + 20 + 20)*2] = 6.5 KB

avendo ipotizzato che il numero di tuple medio sia pari a 50 e che sia dimensionata già inizialmente la tabella con la dimensione che dovrebbe avere a regime. Questa scelta è chiaramente dipendente dal fatto che la dimensione della tabella a regime è esigua, cosa che implica che possa essere già allocata interamente in memoria.

Infine si considera che, a partire dal numero base di 50 arbitri mediamente presenti, ne possa essere comunque inserito qualcun altro durante il corso del campionato. A tal proposito si predispone un incremento costante della dimensione della tabella pari ad 1 KB, valore più che sufficiente a soddisfare questi requisiti.

Tabella Partita

Dimensione = 1140*(40 + 1 + 20 + 2 + 2 + 16)*2 + 0.2*[1140*(40 + 1 + 20 + 2 + 2 + 16)*2] = 216 KB

In questo caso non si suppongono ulteriori incrementi della tabella in quanto il numero di partite del campionato è fissato e quindi non si manifesta la possibilità di un incremento delle dimensioni.

A questo punto seguono gli script di installazione delle tabelle:

Tabella Allenatore

CREATE TABLE 'TEMPES11'.'ALLENATORE' ('NOME _ ALLENATORE'

VARCHAR2(20 byte) NOT NULL, 'DATA _ CONTRATTO' DATE NOT NULL,

CONSTRAINT 'PK _ ALLENATORE' PRIMARY KEY('NOME _ ALLENATORE')

USING INDEX 

TABLESPACE 'USERS'

STORAGE ( INITIAL 3K NEXT 1K MINEXTENTS 1 MAXEXTENTS

2147483645 PCTINCREASE 0) PCTFREE 10 INITRANS 2 MAXTRANS 255)

LOGGING

Tabella Arbitro

CREATE TABLE 'TEMPES11'.'ARBITRO' ('CF _ ARBITRO' VARCHAR2(16 byte)

NOT NULL, 'NOME _ ARBITRO' VARCHAR2(20 byte) NOT NULL,

'CITTÀ _ ARBITRO' VARCHAR2(20 byte) NOT NULL,

CONSTRAINT 'PK _ ARBITRO' PRIMARY KEY('CF _ ARBITRO')

USING INDEX 

TABLESPACE 'USERS'

STORAGE ( INITIAL 10K NEXT 2K MINEXTENTS 1 MAXEXTENTS

2147483645 PCTINCREASE 0) PCTFREE 10 INITRANS 2 MAXTRANS 255)

LOGGING

Tabella Convoca

CREATE TABLE 'TEMPES11'.'CONVOCA' ('GIOCATORE' VARCHAR2(16 byte)

NOT NULL, 'PARTITA' VARCHAR2(40 byte) NOT NULL, 'RUOLO'

VARCHAR2(20 byte) NOT NULL, 'GOAL _ FATTI' NUMBER(2),

CONSTRAINT 'FK _ CONVOCA _ GIO' FOREIGN KEY('GIOCATORE')

REFERENCES 'TEMPES11'.'GIOCATORE'('CF _ GIOCATORE'),

CONSTRAINT 'FK _ CONVOCA _ PAR' FOREIGN KEY('PARTITA')

REFERENCES 'TEMPES11'.'PARTITA'('NOME _ PARTITA'),

CONSTRAINT 'PK _ CONVOCA' PRIMARY KEY('GIOCATORE', 'PARTITA')

USING INDEX 

TABLESPACE 'USERS'

STORAGE ( INITIAL 240K NEXT 60K MINEXTENTS 1 MAXEXTENTS

2147483645 PCTINCREASE 0) PCTFREE 10 INITRANS 2 MAXTRANS 255)

LOGGING

Tabella Giocatore

CREATE TABLE 'TEMPES11'.'GIOCATORE' ('CF _ GIOCATORE' VARCHAR2(16

byte) NOT NULL, 'RUOLO _ PRINCIPALE' VARCHAR2(20 byte) NOT NULL,

'DATA _ DI _ NASCITA' DATE NOT NULL, 'NOME _ GIOCATORE' VARCHAR2(20

byte) NOT NULL, 'CITTÀ _ GIOCATORE' VARCHAR2(20 byte) NOT NULL,

'SQUADRA' VARCHAR2(20 byte),

CONSTRAINT 'FK _ GIOC _ SQUADRA' FOREIGN KEY('SQUADRA')

REFERENCES 'TEMPES11'.'SQUADRA'('NOME _ SQUADRA'),

CONSTRAINT 'PK _ GIOCATORE' PRIMARY KEY('CF _ GIOCATORE')

USING INDEX 

TABLESPACE 'USERS'

STORAGE ( INITIAL 40K NEXT 5K MINEXTENTS 1 MAXEXTENTS

2147483645 PCTINCREASE 0) PCTFREE 10 INITRANS 2 MAXTRANS 255)

LOGGING

Tabella Giornata

CREATE TABLE 'TEMPES11'.'GIORNATA' ('NUMERO _ GIORNATA' NUMBER(2)

NOT NULL, 'DATA _ GIORNATA' DATE NOT NULL,

CONSTRAINT 'PK _ GIORNATA' PRIMARY KEY('NUMERO _ GIORNATA')

USING INDEX 

TABLESPACE 'USERS'

STORAGE ( INITIAL 64K NEXT 0K MINEXTENTS 1 MAXEXTENTS

2147483645 PCTINCREASE 0) PCTFREE 10 INITRANS 2 MAXTRANS 255)

LOGGING

Tabella Incontro

CREATE TABLE 'TEMPES11'.'INCONTRO' ('NOME _ PARTITA' VARCHAR2(40

byte) NOT NULL, 'SQUADRA' VARCHAR2(20 byte) NOT NULL,

CONSTRAINT 'FK _ INCONTRO _ PAR' FOREIGN KEY('NOME _ PARTITA')

REFERENCES 'TEMPES11'.'PARTITA'('NOME _ PARTITA'),

CONSTRAINT 'FK _ INCONTRO _ SQU' FOREIGN KEY('SQUADRA')

REFERENCES 'TEMPES11'.'SQUADRA'('NOME _ SQUADRA'),

CONSTRAINT 'PK _ INCONTRO' PRIMARY KEY('NOME _ PARTITA',

'SQUADRA')

USING INDEX 

TABLESPACE 'USERS'

STORAGE ( INITIAL 20K NEXT 0K MINEXTENTS 1 MAXEXTENTS

2147483645 PCTINCREASE 0) PCTFREE 10 INITRANS 2 MAXTRANS 255)

LOGGING;

Tabella Partita

CREATE TABLE 'TEMPES11'.'PARTITA' ('NOME _ PARTITA' VARCHAR2(40

byte) NOT NULL, 'GIRONE' NUMBER(1) NOT NULL, 'CASA'

VARCHAR2(20 byte) NOT NULL, 'GOAL _ SQUADRA _ 1' NUMBER(2),

'GOAL _ SQUADRA _ 2' VARCHAR2(2 byte), 'ARBITRO' VARCHAR2(16

byte), 'GIORNATA' NUMBER(2) NOT NULL,

CONSTRAINT 'FK _ PARTITA' FOREIGN KEY('ARBITRO')

REFERENCES 'TEMPES11'.'ARBITRO'('CF _ ARBITRO'),

CONSTRAINT 'FK _ PARTITA _ GIORN' FOREIGN KEY('GIORNATA')

REFERENCES 'TEMPES11'.'GIORNATA'('NUMERO _ GIORNATA'),

CONSTRAINT 'PK _ PARTITA' PRIMARY KEY('NOME _ PARTITA')

USING INDEX 

TABLESPACE 'USERS'

STORAGE ( INITIAL 216K NEXT 0K MINEXTENTS 1 MAXEXTENTS

2147483645 PCTINCREASE 0) PCTFREE 10 INITRANS 2 MAXTRANS 255)

LOGGING

Tabella Squadra

CREATE TABLE 'TEMPES11'.'SQUADRA' ('NOME _ SQUADRA' VARCHAR2(20

byte) NOT NULL, 'CITTÀ _ SQUADRA' VARCHAR2(20 byte) NOT NULL,

'GOAL _ FATTI' NUMBER(2) DEFAULT 0, 'GOAL _ SUBITI' NUMBER(2)

DEFAULT 0, 'PUNTI _ CLASSIFICA' NUMBER(2) DEFAULT 0,

'PARTITE _ VINTE' NUMBER(2) DEFAULT 0, 'PARTITE _ PAREGGIATE'

NUMBER(2) DEFAULT 0, 'PARTITE _ PERSE' NUMBER(2) DEFAULT 0,

'ALLENATORE' VARCHAR2(20 byte) NOT NULL,

CONSTRAINT 'FK _ SQUADRA _ ALL' FOREIGN KEY('ALLENATORE')

REFERENCES 'TEMPES11'.'ALLENATORE'('NOME _ ALLENATORE'),

CONSTRAINT 'PK _ SQUADRA' PRIMARY KEY('NOME _ SQUADRA')

USING INDEX 

TABLESPACE

'USERS'

STORAGE ( INITIAL 2K NEXT 0K MINEXTENTS 1 MAXEXTENTS

2147483645 PCTINCREASE 0) PCTFREE 10 INITRANS 2 MAXTRANS 255)

LOGGING;

6.2 Procedure PL-SQL

Una volta realizzate le varie tabelle è necessario ovviamente implementare le funzioni descritte in precedenza attraverso delle procedure dedicate. Si mostrano qui di seguito le procedure realizzate per la maggior parte delle operazioni.

O1 Introduci una nuova Giornata

CREATE OR REPLACE  PROCEDURE 'TEMPES11'.'INSERT _ GIORNATA' (

num _ gior IN GIORNATA.NUMERO _ GIORNATA%TYPE,

data _ gior IN GIORNATA.DATA _ GIORNATA%TYPE) AS

BEGIN

INSERT INTO GIORNATA (NUMERO _ GIORNATA,DATA _ GIORNATA)

VALUES (num _ gior,data _ gior);

COMMIT;

END INSERT _ GIORNATA

O2 Introduci una nuova Partita

CREATE OR REPLACE  PROCEDURE INSERT _ PARTITA (

nome _ part IN PARTITA.NOME _ PARTITA%TYPE,

gir IN PARTITA.GIRONE%TYPE,

casa IN PARTITA.CASA%TYPE,

gior IN PARTITA.GIORNATA%TYPE) AS

BEGIN

INSERT INTO PARTITA (NOME _ PARTITA,GIRONE,CASA,GIORNATA)

VALUES (nome _ part,gir,casa,gior);

COMMIT;

END INSERT _ PARTITA

O3 Introduci una nuovo Giocatore

CREATE OR REPLACE  PROCEDURE INSERT _ GIOCATORE (

cf IN GIOCATORE.CF _ GIOCATORE%TYPE,

ruolo IN GIOCATORE.RUOLO _ PRINCIPALE%TYPE,

dat IN GIOCATORE.DATA _ DI _ NASCITA%TYPE,

nome IN GIOCATORE.NOME _ GIOCATORE%TYPE,

città IN GIOCATORE.CITTÀ _ GIOCATORE%TYPE,

squad IN GIOCATORE.SQUADRA%TYPE) AS

BEGIN

INSERT INTO GIOCATORE (CF _ GIOCATORE,RUOLO _ PRINCIPALE,DATA _ DI _ NASCITA,NOME _ GIOCATORE,CITTÀ _ GIOCATORE,SQUADRA)

VALUES (cf,ruolo,dat,nome,città,squad);

COMMIT;

END INSERT _ GIOCATORE

O4 Introduci una nuova Squadra

CREATE OR REPLACE  PROCEDURE 'TEMPES11'.'INSERT _ SQUADRA' (

nome IN SQUADRA.NOME _ SQUADRA%TYPE,

città IN SQUADRA.CITTÀ _ SQUADRA%TYPE,

allen IN SQUADRA.ALLENATORE%TYPE) AS

BEGIN

INSERT INTO SQUADRA (NOME _ SQUADRA,CITTÀ _ SQUADRA,ALLENATORE)

VALUES (nome,città,allen);

COMMIT

END INSERT _ SQUADRA;

O5 Introduci un nuovo Allenatore

CREATE OR REPLACE  PROCEDURE INSERT _ ALLENATORE (

nome IN ALLENATORE.NOME _ ALLENATORE%TYPE,

dat IN ALLENATORE.DATA _ CONTRATTO%TYPE) AS

BEGIN

INSERT INTO ALLENATORE (NOME _ ALLENATORE,DATA _ CONTRATTO)

VALUES (nome,dat);

COMMIT

END INSERT _ ALLENATORE;

O6 Introduci un nuovo Arbitro

CREATE OR REPLACE  PROCEDURE INSERT _ ARBITRO (

cf IN ARBITRO.CF _ ARBITRO%TYPE,

nome IN ARBITRO.NOME _ ARBITRO%TYPE,

città IN ARBITRO.CITTÀ _ ARBITRO%TYPE) AS

BEGIN

INSERT INTO ARBITRO (CF _ ARBITRO,NOME _ ARBITRO,CITTÀ _ ARBITRO)

VALUES (cf,nome,città);

COMMIT;

END INSERT _ ARBITRO;

O7 Introduci Giocatore convocato

CREATE OR REPLACE  PROCEDURE INSERT _ CONVOCA (

gioc IN CONVOCA.GIOCATORE%TYPE,

part IN CONVOCA.PARTITA%TYPE,

ruolo IN CONVOCA.RUOLO%TYPE) AS

BEGIN

INSERT INTO CONVOCA (GIOCATORE,PARTITA,RUOLO)

VALUES (gioc,part,ruolo);

COMMIT

END INSERT _ CONVOCA;

O8 Visualizza scheda Squadra

CREATE OR REPLACE  PROCEDURE 'TEMPES11'.'SHOW _ SQUADRA' (

inNome SQUADRA.NOME _ SQUADRA%TYPE

AS

BEGIN

DECLARE

CURSOR c1 IS

SELECT NOME _ SQUADRA,CITTÀ _ SQUADRA,ALLENATORE FROM SQUADRA WHERE NOME _ SQUADRA = inNome;

CURSOR c2 IS

SELECT NOME _ GIOCATORE FROM GIOCATORE WHERE SQUADRA = inNome;

BEGIN

DBMS _ OUTPUT.PUT _ LINE('SQUADRA '||'CITTÀ '||'ALLENATORE');

FOR c1 _ rec IN c1 LOOP

DBMS _ OUTPUT.PUT _ LINE(c1 _ rec.NOME _ SQUADRA||' '||c1 _ rec.CITTÀ _ SQUADRA||' '||c1 _ rec.ALLENATORE);

END LOOP;

DBMS _ OUTPUT.PUT _ LINE('NOME GIOCATORE');

FOR c2 _ rec IN c2 LOOP

DBMS _ OUTPUT.PUT _ LINE(c2 _ rec.NOME _ GIOCATORE);

END LOOP;

END

END SHOW _ SQUADRA;

O9 Visualizza Risultati Squadra

CREATE OR REPLACE  PROCEDURE 'TEMPES11'.'SHOW _ RIS _ SQUADRA' (

inNome SQUADRA.NOME _ SQUADRA%TYPE

)

AS

BEGIN

DECLARE

nome SQUADRA.NOME _ SQUADRA%TYPE;

par _ par SQUADRA.NOME _ SQUADRA%TYPE;

gol _ fat SQUADRA.NOME _ SQUADRA%TYPE;

gol _ sub SQUADRA.NOME _ SQUADRA%TYPE;

punti SQUADRA.NOME _ SQUADRA%TYPE;

par _ vin SQUADRA.NOME _ SQUADRA%TYPE;

par _ per SQUADRA.NOME _ SQUADRA%TYPE;

BEGIN

SELECT NOME _ SQUADRA INTO nome FROM SQUADRA WHERE NOME _ SQUADRA = inNome;

SELECT PARTITE _ PAREGGIATE INTO par _ par FROM SQUADRA WHERE NOME _ SQUADRA = inNome;

SELECT GOAL _ FATTI INTO gol _ fat FROM SQUADRA WHERE NOME _ SQUADRA = inNome;

SELECT GOAL _ SUBITI INTO gol _ sub FROM SQUADRA WHERE NOME _ SQUADRA = inNome;

SELECT PUNTI _ CLASSIFICA INTO punti FROM SQUADRA WHERE NOME _ SQUADRA = inNome;

SELECT PARTITE _ VINTE INTO par _ vin FROM SQUADRA WHERE NOME _ SQUADRA = inNome;

SELECT PARTITE _ PAREGGIATE INTO par _ per FROM SQUADRA WHERE NOME _ SQUADRA = inNome;

DBMS _ OUTPUT.PUT _ LINE('SQUADRA: '||nome );

DBMS _ OUTPUT.PUT _ LINE('GOAL FATTI: '||gol _ fat );

DBMS _ OUTPUT.PUT _ LINE('GOAL SUBITI: '||gol _ sub );

DBMS _ OUTPUT.PUT _ LINE('PARTITE VINTE: '||par _ vin );

DBMS _ OUTPUT.PUT _ LINE('PARTITE PERSE: '||par _ per );

DBMS _ OUTPUT.PUT _ LINE('PARTITE PAREGGIATE: '||par _ par );

DBMS _ OUTPUT.PUT _ LINE('PUNTI IN CLASSIFICA: '||punti );

END

END SHOW _ RIS _ SQUADRA;

O10 Visualizza Scheda Giocatore

CREATE OR REPLACE  PROCEDURE 'TEMPES11'.'SHOW _ GIOCATORE' (

inNome GIOCATORE.CF _ GIOCATORE%TYPE

AS

BEGIN

DECLARE

goal CONVOCA.GOAL _ FATTI%TYPE;

squad GIOCATORE.SQUADRA%TYPE;

CURSOR c1 IS

SELECT NOME _ GIOCATORE,DATA _ DI _ NASCITA,CITTÀ _ GIOCATORE,RUOLO _ PRINCIPALE FROM GIOCATORE WHERE CF _ GIOCATORE = inNome;

BEGIN

DBMS _ OUTPUT.PUT _ LINE('NOME '||'DATA DI NASCITA '||'CITTÀ '||'RUOLO PRINCIPALE');

FOR c1 _ rec IN c1 LOOP

DBMS _ OUTPUT.PUT _ LINE(c1 _ rec.NOME _ GIOCATORE||'       '||c1 _ rec.DATA _ DI _ NASCITA||' '||c1 _ rec.CITTÀ _ GIOCATORE||' '||c1 _ rec.RUOLO _ PRINCIPALE);

END LOOP;

SELECT SUM(GOAL _ FATTI) INTO goal FROM CONVOCA WHERE GIOCATORE = inNome;

IF goal IS NULL THEN

DBMS _ OUTPUT.PUT _ LINE('Il giocatore non ha mai segnato goal!!!');

ELSE

DBMS _ OUTPUT.PUT _ LINE('GOAL FATTI: '||goal);

END IF;

SELECT SQUADRA INTO squad FROM GIOCATORE WHERE CF _ GIOCATORE = inNome;

IF squad = 'ESTERO' THEN

DBMS _ OUTPUT.PUT _ LINE('Il giocatore non è sotto contratto per nessuna Squadra Italiana');

ELSE

DBMS _ OUTPUT.PUT _ LINE('SQUADRA: '||squad);

END IF;

END

END SHOW _ GIOCATORE;

O11 Visualizza Giornata

CREATE OR REPLACE  PROCEDURE 'TEMPES11'.'SHOW _ GIORNATA' (

numero GIORNATA.NUMERO _ GIORNATA%TYPE

AS

BEGIN

DECLARE

part PARTITA.NOME _ PARTITA%TYPE;

goal1 PARTITA.GOAL _ SQUADRA _ 1%TYPE;

goal2 PARTITA.GOAL _ SQUADRA _ 1%TYPE;

ospite SQUADRA.NOME _ SQUADRA%TYPE;

CURSOR c1 IS

SELECT NOME _ PARTITA,GOAL _ SQUADRA _ 1,GOAL _ SQUADRA _ 2 FROM PARTITA WHERE GIORNATA = numero;

BEGIN

FOR c1 _ rec IN c1 LOOP

DBMS _ OUTPUT.PUT _ LINE(c1 _ rec.NOME _ PARTITA||' : '||c1 _ rec.GOAL _ SQUADRA _ 1||'-'||c1 _ rec.GOAL _ SQUADRA _ 2);

END LOOP;

END;

END SHOW _ GIORNATA;

O12 Introduci Risultato

CREATE OR REPLACE  PROCEDURE 'TEMPES11'.'INSERT _ RISULTATO' (

part CONVOCA.PARTITA%TYPE,

marcatore CONVOCA.GIOCATORE%TYPE,

goal CONVOCA.GOAL _ FATTI%TYPE : = 0,

casa PARTITA.CASA%TYPE,

aggiorna BOOLEAN

)

AS

BEGIN

DECLARE

CURSOR c1 IS

SELECT SQUADRA FROM INCONTRO WHERE NOME _ PARTITA = part;

goal1 CONVOCA.GOAL _ FATTI%TYPE;

goal2 CONVOCA.GOAL _ FATTI%TYPE;

goaltemp CONVOCA.GOAL _ FATTI%TYPE;

ospite SQUADRA.NOME _ SQUADRA%TYPE;

par _ vin NUMBER(2);

par _ per NUMBER(2);

par _ par NUMBER(2);

gol _ fat NUMBER(2);

gol _ sub NUMBER(2);

punti NUMBER(2);

BEGIN

AGGIORNAMENTO GOAL GIOCATORE */

SELECT GOAL _ FATTI INTO goaltemp FROM CONVOCA WHERE (PARTITA = part AND GIOCATORE = marcatore);

goaltemp: = goaltemp + goal;

UPDATE CONVOCA SET GOAL _ FATTI = goaltemp WHERE (PARTITA = part AND GIOCATORE = marcatore);

COMMIT;

AGGIORNAMENTO RISULTATO */

IF aggiorna = TRUE THEN

/*----- ----- --------RICERCA SQUADRA DI SQUADRA OSPITE ED IN CASA----- ----- ------*/

FOR c1 _ rec IN c1 LOOP

IF c1 _ rec.SQUADRA ! = casa THEN ospite : = c1 _ rec.SQUADRA;

END IF;

END LOOP;

/*---------CALCOLO DEI GOAL FATTI DA UNA SQUADRA NELLA PARTITA-----------*/

SELECT SUM(GOAL _ FATTI) INTO goal1

FROM CONVOCA,GIOCATORE

WHERE CONVOCA.GIOCATORE = GIOCATORE.CF _ GIOCATORE AND PARTITA = part AND SQUADRA = casa;

SELECT SUM(GOAL _ FATTI) INTO goal2

FROM CONVOCA,GIOCATORE

WHERE CONVOCA.GIOCATORE = GIOCATORE.CF _ GIOCATORE AND PARTITA = partita AND SQUADRA = ospite;

UPDATE PARTITA SET GOAL _ SQUADRA _ 1 = goal1 WHERE NOME _ PARTITA = part;

UPDATE PARTITA SET GOAL _ SQUADRA _ 2 = goal2 WHERE NOME _ PARTITA = part;

COMMIT;

/*------------AGGIORNAMENTO DEI GOAL FATTI E SUBITI DALLE SQUADRE-----------*/

SELECT GOAL _ FATTI INTO gol _ fat FROM SQUADRA WHERE SQUADRA.NOME _ SQUADRA = casa;

SELECT GOAL _ SUBITI INTO gol _ sub FROM SQUADRA WHERE SQUADRA.NOME _ SQUADRA = casa;

gol _ fat : = gol _ fat + goal1;

gol _ sub : = gol _ sub + goal2;

UPDATE SQUADRA SET GOAL _ FATTI = gol _ fat WHERE SQUADRA.NOME _ SQUADRA = casa;

UPDATE SQUADRA SET GOAL _ SUBITI = gol _ sub WHERE SQUADRA.NOME _ SQUADRA = casa;

SELECT GOAL _ FATTI INTO gol _ fat FROM SQUADRA WHERE SQUADRA.NOME _ SQUADRA = ospite;

SELECT GOAL _ SUBITI INTO gol _ sub FROM SQUADRA WHERE SQUADRA.NOME _ SQUADRA = ospite;

gol _ fat : = gol _ fat + goal2;

gol _ sub : = gol _ sub + goal1;

UPDATE SQUADRA SET GOAL _ FATTI = gol _ fat WHERE SQUADRA.NOME _ SQUADRA = ospite;

UPDATE SQUADRA SET GOAL _ SUBITI = gol _ sub WHERE SQUADRA.NOME _ SQUADRA = ospite;

COMMIT;

/*-----------AGGIORNAMENTO DEI PUNTI IN CLASSIFICA E DELLE PARTITE VINTE                -------- ----- ------ ------PERSE E PAREGGIATE-------- ----- ------ ----------*/

IF goal1 > goal2 THEN

par _ vin : = 1;

par _ per : = 0;

par _ par

SELECT PARTITE _ VINTE INTO par _ vin FROM SQUADRA WHERE SQUADRA.NOME _ SQUADRA = casa;

SELECT PARTITE _ PERSE INTO par _ per FROM SQUADRA WHERE SQUADRA.NOME _ SQUADRA = ospite;

par _ vin : = par _ vin + 1;

par _ per : = par _ per + 1;

UPDATE SQUADRA SET PARTITE _ VINTE = par _ vin WHERE SQUADRA.NOME _ SQUADRA = casa;

UPDATE SQUADRA SET PARTITE _ PERSE = par _ per WHERE SQUADRA.NOME _ SQUADRA = ospite;

SELECT PUNTI _ CLASSIFICA INTO punti FROM SQUADRA WHERE SQUADRA.NOME _ SQUADRA = casa;

punti : = punti + 3;

UPDATE SQUADRA SET PUNTI _ CLASSIFICA = punti WHERE SQUADRA.NOME _ SQUADRA = casa;

COMMIT

ELSE

IF goal1 = goal2 THEN

par _ vin : = 0;

par _ per : = 1;

par _ par

SELECT PARTITE _ PAREGGIATE INTO par _ par FROM SQUADRA WHERE SQUADRA.NOME _ SQUADRA = casa;

par _ par : = par _ par + 1;

UPDATE SQUADRA SET PARTITE _ PAREGGIATE = par _ par WHERE SQUADRA.NOME _ SQUADRA = casa;

SELECT PARTITE _ PAREGGIATE INTO par _ par FROM SQUADRA WHERE SQUADRA.NOME _ SQUADRA = ospite;

par _ par : = par _ par + 1;

UPDATE SQUADRA SET PARTITE _ PAREGGIATE = par _ par WHERE SQUADRA.NOME _ SQUADRA = ospite;

SELECT PUNTI _ CLASSIFICA INTO punti FROM SQUADRA WHERE SQUADRA.NOME _ SQUADRA = casa;

punti : = punti + 1;

UPDATE SQUADRA SET PUNTI _ CLASSIFICA = punti WHERE SQUADRA.NOME _ SQUADRA = casa;

SELECT PUNTI _ CLASSIFICA INTO punti FROM SQUADRA WHERE SQUADRA.NOME _ SQUADRA = ospite;

punti : = punti + 1;

UPDATE SQUADRA SET PUNTI _ CLASSIFICA = punti WHERE SQUADRA.NOME _ SQUADRA = ospite;

COMMIT

ELSE

par _ vin : = 0;

par _ per : = 0;

par _ par : = 1;

SELECT PARTITE _ VINTE INTO par _ vin FROM SQUADRA WHERE SQUADRA.NOME _ SQUADRA = ospite;

SELECT PARTITE _ PERSE INTO par _ per FROM SQUADRA WHERE SQUADRA.NOME _ SQUADRA = casa;

par _ vin : = par _ vin + 1;

par _ per : = par _ per + 1;

UPDATE SQUADRA SET PARTITE _ VINTE = par _ vin WHERE SQUADRA.NOME _ SQUADRA = ospite;

UPDATE SQUADRA SET PARTITE _ PERSE = par _ per WHERE SQUADRA.NOME _ SQUADRA = casa;

SELECT PUNTI _ CLASSIFICA INTO punti FROM SQUADRA WHERE SQUADRA.NOME _ SQUADRA = ospite;

punti : = punti + 3;

UPDATE SQUADRA SET PUNTI _ CLASSIFICA = punti WHERE SQUADRA.NOME _ SQUADRA = ospite;

COMMIT

END IF;

END IF;

END IF;

END;

END INSERT _ RISULTATO;

O14 Visualizza Classifica

CREATE OR REPLACE  PROCEDURE 'TEMPES11'.'SHOW _ CLASSIFICA' (

girone PARTITA.GIRONE%TYPE

AS

BEGIN

DECLARE

CURSOR c1 IS

SELECT NOME _ SQUADRA,PARTITE _ VINTE,PARTITE _ PAREGGIATE,PARTITE _ PERSE,GOAL _ FATTI,GOAL _ SUBITI,PUNTI _ CLASSIFICA

FROM SQUADRA,INCONTRO,PARTITA

WHERE SQUADRA.NOME _ SQUADRA = INCONTRO.SQUADRA AND INCONTRO.NOME _ PARTITA = PARTITA.NOME _ PARTITA AND PARTITA.GIRONE = girone

ORDER BY(PUNTI _ CLASSIFICA);

BEGIN

FOR c1 _ rec IN c1 LOOP

DBMS _ OUTPUT.PUT _ LINE(c1 _ rec.NOME _ SQUADRA||' '||c1 _ rec.PARTITE _ VINTE||' '||c1 _ rec.PARTITE _ PAREGGIATE||' '||c1 _ rec.PARTITE _ PERSE||' '||c1 _ rec.GOAL _ FATTI||' '||c1 _ rec.GOAL _ SUBITI||' '||c1 _ rec.PUNTI _ CLASSIFICA);

END LOOP;

END;

END SHOW _ CLASSIFICA;

O19 Visualizza Classifica Marcatori

CREATE OR REPLACE  PROCEDURE 'TEMPES11'.'SHOW _ CLASS _ MARC' (

girone PARTITA.GIRONE%TYPE

AS

BEGIN

DECLARE

CURSOR c1 IS

SELECT GIOCATORE,GOAL _ FATTI

FROM CONVOCA,PARTITA

WHERE CONVOCA.PARTITA = PARTITA.NOME _ PARTITA AND PARTITA.GIRONE = girone

ORDER BY(GOAL _ FATTI);

BEGIN

FOR c1 _ rec IN c1 LOOP

DBMS _ OUTPUT.PUT _ LINE(c1 _ rec.GIOCATORE||' '||c1 _ rec.GOAL _ FATTI);

END LOOP;

END;

END SHOW _ CLASS _ MARC;

7 Conclusioni

Il proposito di questo paragrafo è quello di effettuare un bilancio del progetto effettuato. La struttura del database realizzato fondamentalmente può rappresentare in maniera veritiera la struttura di un campionato di calcio. Esso tiene infatti conto degli avvenimenti tipici di un campionato, quali partite, gestione di giocatori, risultati parziali e totali, nonché una gestione delle statistiche relative ad ogni squadra.

Nell'ambito della progettazione della base di dati in questione si è ritenuto come elemento cardine della struttura l'entità partita: intorno ad essa sono stati sviluppati i moduli dell'intero database. È evidente cioè una struttura che tende a centralizzare la maggior parte delle operazioni del database.

Da un lato si può dire che la scelta di accentrare il funzionamento del database intorno ad alcuni elementi cardine rende concettualmente più semplice l'approccio al database; d'altra parte, concentrare in pochi punti le operazioni rende più complicata l'intera gestione, sicuramente meno flessibile di una struttura nella quale le varie funzionalità sono decentrate.

Una pecca del sistema è senza dubbio una certa ridondanza presente nella gestione delle partite: infatti le partite sono rappresentate da stringhe tipo "Ancona-Milan" le quali rappresentano una ridondanza in quanto ricavabili a partire dalle singole squadre. La scelta di una rappresentazione del genere, che tra l'altro complica anche lo stesso accesso alle tabelle medesime, è stata effettuata per conservare una certa generalità. Infatti, individuando con delle stringhe le partite, non le si lega necessariamente alle squadre che partecipano ad esse.

Si sono realizzate una serie di procedure, le quali realizzano la maggior parte delle operazioni richieste ad un database di questo tipo. Ciò sicuramente suggerisce un possibile utilizzo del database con le relative procedure nell'ambito di un linguaggio evoluto come Java: in tal caso, nell'ambito di un ambiente graficamente evoluto, le procedure in questione possono essere integrate con i costrutti avanzati del ava, al fine di ottenere un sistema di gestione evoluto del database.

Ulteriore evoluzione può essere dunque senza dubbio lo sviluppo di un sistema client-server che permetta ad utenti di accedere al database e visualizzare statistiche relative al campionato di calcio, sfruttando sempre le procedure in oggetto.