Introduzione ad SQL*Plus di Oracle8i


Indice

  1. Introduzione
  2. Editing di comandi
  3. Gestione utenti
  4. Gestione tavole


1. Introduzione

Per la parte implementativa del corso si fa uso di un DBMS commerciale, in particolare si fa uso di Oracle8i Personal, una versione ridotta di Oracle8i che gira sotto Windows (95, 98, NT, 2000) e Unix (Linux). Per maggiori informazioni su questo sistema si può fare riferimento alla documentazione in linea diponibile sul sito web di Oracle http://www.oracle.com/.

Oracle8i Personal, come tutti i DBMS commerciali, implementa un sottoinsieme dello standard SQL-92. Lo strumento base per interagire con il DBMS di Oracle8i è SQL*Plus, un interprete di comandi SQL con un'interfaccia a linea di comando.


Accesso al DBMS via SQL*Plus

Sotto Windows, ci sono due modi per attivare SQL*Plus.

Per connettersi alla base di dati si devono fornire a SQL*Plus i seguenti parametri:

Se si esegue SQL*Plus da linea di comando si devono fornire questi parametri in linea:
    sqlplus <nome-utente>/<password>@<descrittore-di-connessione>
Ad esempio:
    sqlplus stud00/parola00@oratib.tiburdb

Una volta connessi alla base di dati, dopo una serie di massaggi, appare il prompt di SQL*Plus:

    SQL>
In risposta a questo prompt SQL> possiamo scrivere comandi SQL. I comandi immessi vengono inviati alla base di dati alla quale si è connessi, interpretati ed eseguiti.


Uscire da SQL*Plus

Per uscire da SQL*Plus, si deve digitare:

    quit;
oppure
    exit;
in risposta al prompt.


2. Editing di comandi

In SQL*Plus i comandi possono estendersi su più linee e devono terminare con il punto e virgola ";". Se il comando occupa più linee, ad ogni return viene dato un prompt speciale con il numero di linea corrente fino a che non si digita il punto e virgola o un return lasciando una riga vuota. Nel primo caso viene eseguito il comando; nel secondo caso il comando viene memorizzato su un buffer (si veda Buffer di editing).

Si tenga presente che SQL è case-insensitive. Quindi in SQL*Plus, si possono usare indifferentemente maiuscole o minuscole (questo vale anche per la password). Si noti però che i dati di tipo stringa fanno distinzione tra maiuscole e minuscole.


Buffer di editing

Se si termina un comando con una riga vuota, invece del punto e virgola, il comando viene memorizzato in un buffer. Questo comando può essere eseguito dal buffer digitando:

    run
oppure digitando un singolo slash (/).

Il comando nel buffer può essere editato prima di eseguirlo. Per fare ciò si pu&ogreve; utilizzare un editor di linea interno a SQL*Plus, oppure un editor esterno. I comandi principali dell'editor di linea sono i seguenti:

L

mostra il contenuto del buffer e pone l'ultima linea del buffer come "linea corrente"
L n mostra la linea n-esima del buffer, e la rende la linea corrente
L m n mostra le linee da m a n e rende la linea n la linea corrente
I permette di inserire nuove linee dopo la linea corrente;
per terminare l'inserimento bisogna digitare return due volte
C /vecchio/nuovo sostituisce il testo "vecchio" con "nuovo" nella linea corrente
A testo aggiunge "testo" alla fine della linea corrente
DEL cancella la linea corrente

In alternativa, si può chiamare da SQL*Plus un editor esterno attraverso il comando edit. Se digitiamo:

    edit <nome-file.sql>
il buffer viene memorizzato come file di testo nome-file.sql nella directory corrente e poi viene passato all' editor di testo di Windows (tipicamente "Blocco Note"). È possibile ridefinire l'editor chiamato attraverso il comando define_editor. Ad esempio:
    define_editor = "emacs"
definisce l'editor emacs come editor da chiamare con edit. È anche possibile salvare il buffer (senza editarlo) attraverso il comando
    save <nome-file.sql>


Eseguire comandi memorizzati su file

Anziché eseguire comandi SQL digitandoli su terminale, è spesso più conveniente scriverli in un file di testo e poi richiamarli da SQL*Plus.

Supponiamo di aver scritto alcuni comandi SQL in un file foo.sql nella directory corrente. Possiamo eseguire il file da SQL*Plus con il comando:

     @foo.sql
oppure equivalentemente:
     start foo.sql

Se non viene specificata nessuna estensione per il file, cioè se scriviamo @foo, allora SQL*Plus assume che l'estensione sia .sql. È ovviamente possibile anche specificare il path completo del file, mettendolo tra singoli apici. Ad esempio, possiamo scrivere @'e:\esercitazioni\foo.sql'.

Nota: per realizzare una base di dati è utile preparare i seguenti file:

In alternativa a caricare i comandi da un file utilizzando il comando start, si può utilizzare un editor esterno invocato direttamente da Windows, e scrivere i comandi SQL nella finestra di tale editor. Per eseguire un comando, si seleziona il testo associato usando il mouse, si copia tale testo usando la combinazione di tasti Ctrl-C, e lo si incolla nella finestra di SQL*Plus utilizzando la combimazione di tasti Ctrl-V. Questo permette di eseguire con facilità i comandi uno alla volta (controllando di volta in volta eventuali errori), pur utilizzando tutte le funzionalità messe a disposizione dall'editor esterno (molto più potente dell'editor di linea di SQL*Plus).


Registrare una sessione di lavoro

Per avere una copia su file di una sessione di lavoro, si può usare il comando spool di SQL*Plus. In particolare, digitando:

    spool <nome-file>
viene creato un file con estensione di default .lst nella directory corrente, e in esso viene copiato tutto ciò che appare su terminale fino a che non si esce da SQL*Plus o non si digita
    spool off


Caratteri speciali

I caratteri speciali non possono essere utilizzati se non in stringhe. In queste, per ottenere l'apostrofo (poiché una stringa é delimitata da singoli apici) si usano due apostrofi. Ad esempio:

    'citta'' del sole'
Per altri caratteri, ad esempio &, si usano sequenze di escape. Per definire il carattere di escape si usa il comando:
    set escape <carattere-di-escape>
Ad esempio, con il comando:
    set escape ^
possiamo scrivere 'Johnson ^& son'. Per farsi mostrare il carattere di escape attuale si usa il comando:
    show escape
Per eliminare il carattere di escape definito si usa il comando:
    set escape off


3. Gestione utenti

La gestione utenti comprende la creazione e l'eliminazione di utenti e l'associazione di privilegi agli utenti creati.


Creare ed eliminare utenti

Il comando SQL per creare un nuovo utente ha la seguente forma:
    create user <nome-utente> identified by <password>;

dove <nome-utente> è il nome del nuovo utente e <password> è la password assegnatagli.

L'utente, una volta connessosi alla base di dati, potrà cambiare la password attraverso il comando:

    alter user <nome-utente> identified by <nuova-password>;
Per eliminare un utente si usa il comando:
    drop user <nome-utente> cascade;
che elimina l'utente e tutti gli oggetti della base di dati ad esso associati (ad es. tavole create dall'utente). Se si omette la clusola cascade l'utente viene eliminato solo se nella base di dati non vi sono oggetti ad esso associati.


Privilegi e ruoli di un utente

Una volta creato l'utente si devono associare ad esso gli opportuni permessi attraverso il comando SQL grant. Si ricorda che il comando grant permette di dare diritti di inserimento, cancellazione, aggiornamento, e interrogazione di una tavola a determinati utenti. Inoltre grant può essere usato per associare ruoli prestabiliti. In particolare, in Oracle8i sono predefiniti una serie di ruoli, tra cui:

Ad esempio:
    grant CONNECT to <nome-utente>;
    grant RESOURCE to <nome-utente>;
dà i diritti all'utente <nome-utente> per connettersi alla base di dati e creare e interrogare proprie tavole.

Per revocare privilegi ad un utente si usa il comando SQL revoke. Questo si utilizza pure per revocare ruoli. Ad esempio:

    revoke RESOURCE from <nome-utente>;
revoca il ruolo RESOURCE all'utente <nome-utente>.


4. Gestione tavole

La gestione delle tavole comprende la creazione e l'eliminazione di tavole, la modifica del contenuto delle tavole, e l'interrogazione delle tavole.


Creare ed eliminare tavole

Per creare una tavola si usa il comando SQL standard create table, avente la forma seguente:

    create table <nome-tavola> (
        <lista di attributi e tipi ad essi associati>
    );

Un esempio di creazione è il seguente:

    create table Test (
        i int,
        s char(10)
    );

Questo comando crea una tavola chiamata TEST con due attributi: il primo, chiamato i, è un intero; il secondo, chiamato s, è una stringa lunga al più 10 caratteri.

Per eliminare una tavola dalla base di dati, si usa il comando SQL standard drop table, avente la forma seguente:

    drop table <nome-tavola>;

In generale, dopo aver creato tavole di prova si suggerisce di eliminarle con drop table per mantenere pulita la base di dati. Ad esempio, eseguire:

    drop table Test;
alla fine della sessione di prova.


Inserire e cancellare tuple

Dopo aver creato una tavola possiamo inserirvi tuple utilizzando il comando insert. La maniera più semplice è inserire direttamente i valori:

    insert into <nome-tavola>
        values (<lista ordinata dei valori da inserrire negli attributi>);

Per esempio, possiamo inserire la tupla (10, 'foobar') nella tavola TEST come segue:

    insert into Test values (10, 'foobar');
Analogamente, per cancellare ed aggiornare tuple si utilizzano i comandi delete e update.


Commit e rollback

Le modifiche che si effettuano sulla base di dati non sono permanenti fino a che non si dà il comando:

    commit;
A fronte di tale comando la base di dati viene permanentemente modificata. Prima che sia dato il commit è possibile eliminare tutte le modifiche fatte dopo il commit precedente con il comando:
    rollback;

Si noti che i comandi di aggiornamento tra due commit formano una transazione, cioè un'azione sulla base di dati da considerarsi come una unità.

È possibile far generare i comandi di commit in modo automatico da SQL*Plus dopo ogni istruzione DDL di SQL, digitando:

    set autocommit on
L'autocommit si disattiva digitando:
    set autocommit off
Infine, digitando:
    show autocommit
si verifica lo stato attuale dell'autocommit.


Interrogare tavole

Possiamo vedere quali sono i valori memorizzati in una tavola attraverso una semplice query:

    select * from <nome-tavola>;

Per esempio, dopo aver creato la tavola TEST ed aver inserito la tupla (10,'foobar'), il comando:

    select * from Test;
restituisce il seguente risultato
             I S
    ---------- ----------
            10 foobar


Utilizzare il catalogo

Il DBMS mantiene tutte le informazioni sulla base di dati (metadati) in delle tavole di sistema che formano il cosiddetto catalogo. Le tavole del catalogo sono interrogabili attraverso SQL esattamente come le tavole create dagli utenti. L'elenco completo delle tavole lo si trova nella documentazione online di Oracle8i. Qui ci occupiamo solo della tavola ALL_TABLES, che contiene le infomazioni su tutte le tavole della base di dati. In particolare, se non ci si ricorda quali sono le tavole dell'utente <nome-utente> si può utilizzare la seguente query:

    select TABLE_NAME
    from ALL_TABLES
    where OWNER = '<nome-utente>'
Si noti che il nome dell'utente va scritto utilizzando tutte lettere maiuscole (essendo <nome-utente> una stringa, la distinzione tra maiuscole e minuscole è importante in questo caso).

Dato il nome di una tavola è possibile ottenere i suoi attributi (nome e tipo) con il comando:

    describe <nome-tavola>

Per esempio, per sapere gli attributi memorizzati dal sistema in ALL_TABLES si può usare:

    describe ALL_TABLES


Questo documento e' stato scritto da Diego Calvanese per il Corso di Diploma di Basi di Dati, Ingegneria Informatica, Università di Roma "La Sapienza", anno accademico 2000/2001. Nello scrivere lo stesso si è fatto riferimento a documenti analoghi scritti da Giuseppe De Giacomo (Università di Roma "La Sapienza"), Shuguang Hong (Georgia State University, USA), Tim Finin (University of Maryland, USA), e Jeff Ullman (Stanford University, USA).