Sei sulla pagina 1di 31

ISTITUTO TECNICO INDUSTRIALE STATALE

"Leonardo da Vinci"
Rimini

ESAME DI STATO a. s. 2010 – 2011

Manuale di Informatica con i seguenti


argomenti:

 SQL

 MySQL

 HTML

 PHP
Indice
Indice.................................................................................................................................2
STRUCTURED QUERY LANGUAGE..................................................................................3
Data Definition Language..................................................................................................3
Operazioni sulle TABELLE..............................................................................................3
Manipolazione dei dati (DML)...........................................................................................4
Operazione sui DATI.......................................................................................................4
Query Language.................................................................................................................4
Interrogazione dei dati: comando SELECT....................................................................4
Operazioni Relazionali....................................................................................................5
Funzioni di AGGREGAZIONE.........................................................................................7
Ordinamenti....................................................................................................................8
Raggruppamenti.............................................................................................................8
Condizioni di ricerca.......................................................................................................8
Comandi per la sicurezza (DCL).....................................................................................9
Le VISTE.........................................................................................................................9
Interrogazioni nidificate...............................................................................................10
Tipi di dati MySql.............................................................................................................14
Numerici.......................................................................................................................14
Data e ora.....................................................................................................................14
Stringhe........................................................................................................................14
Le principali funzioni incluse in MySQL..........................................................................15
Funzioni matematiche..................................................................................................15
Funzioni per le stringhe di caratteri.............................................................................15
Funzioni data e ora.......................................................................................................16
Altre Funzioni...............................................................................................................17
PHP..................................................................................................................................18
Funzioni per la gestione degli array.............................................................................18
Funzioni MySQL...........................................................................................................18
Riempimento tabella HTML..........................................................................................20
Gestione delle sessioni..................................................................................................20
Altre funzioni................................................................................................................20
Istruzioni PHP...............................................................................................................21
STRUCTURED QUERY LANGUAGE

Data Definition Language


Operazioni sulle TABELLE
D Definizione della Tabella Creazione della tabella Dipendenti con
D CREATE TABLE nomeTabella chiave primaria numerica che si
(NomeCampo1 Tipo, incrementa automaticamente
L NomeCampo2, Tipo [not null]*,
……………………. CREATE TABLE Dipendenti
Primary Key(NomeCampo1),
(
Foreign Key (NomeCampox)
Matricola int not null auto_increment,
references
CodAz char(5),
NomeTabellax(NomeCampoTabellax) Cognome char(30) not null,
[ON DELETE azione**] Nome char(30)
[ON UPDATE azione**] Livello smallint,
); Primary key(Matricola),
* in tutte le righe della tabella questa Foreign key (CodAz) references
colonna deve essere riempita Aziende(CodAz)
** azione può essere ON DELETE RESTRICT ON UPDATE
-CASCADE =in caso di cancellazione o
modifica della chiave nella tabella padre CASCADE
vengono aggiornati o cancellati anche tutti i );
record collegati nella tabella figlia;
-SET NULL= in caso di modifica della
chiave o cancellazione del record nella
tabella padre, nei record collegati della
tabella figlia la chiave esterna viene
impostata a NULL;
-RESTRICT viene impedita la modifica della
chiave o la cancellazione di un record che
ha record collegati nella tabella figlia, E’ il
valore di default.
Inserimento di un nuovo Aggiunta del campo Nascita dopo il campo
Attributo Nome
ALTER TABLE nomeTabella ALTER TABLE Personale
ADD nomeAttributo Tipo ADD Nascita date AFTER Nome;
[AFTER nomeCampo];
Cancellazione di un Attributo Eliminazione del campo Livello
ALTER TABLE nomeTabella ALTER TABLE Personale
DROP nomeAttributo; DROP Livello;
Sostituzione del campo chiave Il campo chiave passa da Matricola a codice
con altro campo fiscale
ALTER TABLE nomeTabella Drop ALTER TABLE Personale Drop Primary Key,
Primary Key, ADD Primary ADD Primary Key(‘cod_fisc’);
Key(nuovoCampoChiave);
Modificare il tipo di un campo Il campo quant della tabella vendite passa da
ALTER TABLE nomeTabella int a float
CHANGE nomeCampo ALTER TABLE vendite
nuovoTipo; CHANGE quant float;
Creazione di un Indice Creazione indice Ipers
CREATE [UNIQUE]* INDEX CREATE UNIQUE INDEX Ipers
nomeIndice ON Personale (Cognome, Nome);
ON nomeTabella (Attributi1,
Attrib2..);
* se non si vogliono valori duplicati
Cancellazione di una Tabella Cancellazione tabella Personale
DROP TABLE nomeTabella; DROP TABLE Personale;
Cancellazione di un Indice Cancellazione indice Ipers
DROP INDEX nomeIndice ON DROP INDEX Ipers ON Personale;
nomeTabella;
Rinominare una tabella Rinominare la tabella Personale in
ALTER TABLE nomeVecchio Dipendenti
RENAME nomeNuovo; ALTER TABLE ‘Personale’ RENAME
‘Dipendenti’;

Rinominare un campo Rinominare il campo Stipendio in StipBase


ALTER TABLE nomeTabella ALTER TABLE Personale
CHANGE nomeCampoVecchio CHANGE Stipendio StipBase Real;
nomeCampoNuovo Tipo;

Manipolazione dei dati (DML)


Operazione sui DATI
D Inserimento di un nuovo Inserimento di un nuovo dipendente
M Record INSERT INTO Personale
INSERT INTO nomeTabella (Matricola, Cognome, Nome, Livello)
L
(Campo1, Campo2, …….. VALUES (‘AB541’, ‘Rossi’, ‘Mario’,
Campon) ‘Impiegato’);
VALUES (‘Dato1’, ‘Dato2’,
………, Daton);
Cancellazione di un Record Cancellazione record per cui la matricola è
DELETE FROM nomeTabella AQ123
WHERE DELETE FROM Personale
[campoChiave=’ValoreChiave’]; WHERE matricola=’AQ123’;
Condizion ---------
Cancellazione dei record per cui lo stipendio è
inferiore a 750
DELETE FROM Personale
WHERE stipendio < 750;
Modifica di un Campo Cambiare il livello del dipendente con
UPDATE nomeTabella matricola AA345
SET campo=’dato’ UPDATE Personale
WHERE SET Livello = 6
[campoChiave=’ValoreChiave’]; WHERE Matricola = ‘AA345’;
CONDIZIONE ----------
Aumentare lo stipendio del 5% a tutti i
dipendenti con livello superiore a 5
UPDATE Personale
SET Stipendio=Stipendio*1.05
WHERE Livello > 5;
Query Language
Interrogazione dei dati: comando SELECT
Struttura generale Elenco degli Impiegati della provincia di Milano
SELECT [*] Campo1, Campo2, ….. *
Campon SELECT Cognome, Nome
FROM Tabella1, Tabella2, ……. FROM Personale
Tabellan WHERE Funzione=’Impiegato’ AND
WHERE Condizione; ** Prov = ‘MI’;
* Mettendo l’* si intendono tutti gli attributi
** Si possono combinare più condizioni con gli *Interessa sapere solo il Cognome e Nome
operatori OR, AND e NOT
Predicato ALL Elenco dei dipendenti di Milano
Indica la richiesta di tutte le righe che SELECT ALL * FROM Personale
soddisfano le condizioni del comando. WHERE Prov = ’MI’; è equivalente a…..
Essendo di default non è necessario SELECT * FROM Personale
specificarlo WHERE Prov = ’MI’;
Predicato DISTINCT Elenco di tutte le Funzioni
Le righe che risultano doppie sono SELECT DISTINCT Funzione
ridotte a una. FROM Personale;
SELECT DISTINCT nomeCampo
FROM nomeTabella;
Clausola AS Elenco delle provincie di provenienza dei
I nome dei campi della tabella dipendenti
risultante dall’interrogazione tramite SELECT DISTINCT Prov AS PROVINCIA
Select sono uguali ai campi che sono FROM Personale;
stati selezionati. Se si vogliono
cambiare si usa AS. Elenco dei stipendi attuali e aumentati del 5%
SELECT campoTabPartenza AS SELECT Cognome, Nome, Stipendio As Attuale,
campoTabArrivo Stipendio * 1,05 AS Nuovo
FROM TabPartenza; FROM Personale;
Supporta anche il calcolo di
espressioni 
Select con Parametri Elenco dei dipendenti in relazione alla
SELECT Campo1, Campo2, ……. Funzione scelta dall’utente
Campon SELECT Cognome, Nome
FROM nomeTabella FROM Personale
WHERE nomeCampo=[parametro] WHERE Funzione = [TipoFunzione];

Operazioni Relazionali
Selezione (opera una selezione delle Elenco di tutti i Dirigenti
righe) SELECT * FROM Personale
Si usa la clausola WHERE del WHERE Funzione = ‘Dirigente’;
comando Select

Proiezione (opera una selezione delle Elenco solo di Cognome e Nome di tutti i
colonne) dipendenti
Si scelgono solo alcuni dei campi della SELECT Cognome, Nome
tabella FROM Personale;

Congiunzione Elenco di tutti i dipendenti con descrizione e


La congiunzione tra più tabelle si indirizzo della filiale ove lavorano
ottiene elencando le tabelle dopo il SELECT *
FROM, separate dalla virgola e nella FROM Personale, Dipendenza
clausola WHERE l’uguaglianza degli WHERE Filiale = CodFiliale
attributi in comune. * con il segno = si chiama equi-join che in
Si utilizza la notazione punto per > Access si chiama inner-join
chiarezza: ----------
 NomeTabella.NomeCampo Elenco per ciascun dipendente, del proprio
Self-join: congiunzione della tabella dirigente
con se stessa (ad es. si vuole SELECT Tab1.Cognome, Tab1.Nome,
aggiungere un nuovo campo che Tab2.Cognome
contiene valori di altri campi). Per FROM Personale AS Tab1, Personale As
risolverlo si usa l’alias per il nome Tab2
della tabella, si definiscono cioè 2 WHERE Tab1.Dirigente = Tab2.Matricola;
nomi diversi (con AS) per la stessa
tabella

Esempi di Selezione, Congiunzione Elenco degli Impiegati con la relativa sede di


e Proiezione insieme appartenenza (descrizione e indirizzo)
SELECT Personale.Cognome, Personale.Nome,
Filiale.Descrizione, Filiale.Indirizzo
FROM Personale, Filiale
WHERE Personale.Filiale =
Dipendenza.CodFiliale
AND Personale.Funzione =
’Impiegato’;
Clausola INTO Creazione della tabella dei Dirigenti a partire
Consente di memorizzare il risultato dai dipendenti
dell’operazione in una tabella SELECT * INTO Manager
SELECT * INTO NuovaTabella FROM Personale
FROM VecchiaTabella WHERE Funzione = ‘Dirigente’;
WHERE Condizione
Comando INSERT INTO Aggiunta nella tabella Personale di nuovi
Consente di aggiungere nuovi record dipendenti provenienti dalla tabella
provenienti da un’altra tabella NuoviAssunti
INSERT INTO VecchiaTabella INSERT INTO Personale
SELECT * SELECT *
FROM NuovaTabella; FROM NuoviAssunti;
Funzioni di AGGREGAZIONE
Funzione COUNT Contare il nr. di righe presenti nella tab.
Conta il nr. di righe presenti in una Personale
tabella. Essa vuole un parametro che SELECT COUNT(*) restituisce la
può essere il nome di un campo oppure cardinalità della tab.
l’*. Con il nome del campo le celle FROM Personale;
contenenti NULL non vengono contate. ----------
Invece se si usa * vengono contate anche Contare i dipendenti per cui il livello è
le celle contenenti NULL. specificato
SELECT COUNT(Livello)
FROM Personale;
Consente di ottenere il nr. delle righe ----------
che soddisfano la condizione. Contare il nr. di dipendenti milanesi
SELECT COUNT(*)
FROM Personale
WHERE Prov = ‘MI’;
----------
COUNT(DISTINCT x)
Consente di ottenere il nr. dei valori A quanti diversi livelli appartengono i
diversi tra loro nella colonna x che dipendenti milanesi ?
soddisfano la condizione scritta dopo SELECT COUNT(DISTINCT Livello)
WHERE. FROM Personale
La clausola Distinct non può essere WHERE Prov = ‘MI’;
usata nel formato Count(*). ----------
Il risultato del conteggio può essere
descritto con un’opportuna intestazione SELECT COUNT(DISTINCT Livello) AS
aggiungendo la clausola AS. Livelli
FROM Personale
WHERE Prov = ‘MI’;
Funzione SUM Somma degli stipendi dei dipendenti del
Restituisce la somma di tutti i valori livello 5
contenuti in una colonna specificata SELECT SUM(Stipendi)
come argomento della funzione. Se nel FROM Personale
comando SELECT è presente la WHERE Livello = 5;
condizione WHERE, la funzione somma ----------
solo le righe che soddisfano la Se il totale delle fatture viene calcolato come
condizione. NULL viene considerato 0 Quantità * Prezzo allora il Totale può essere
SELECT SUM(DISTINCT Stipendi) così calcolato:
Consente di sommare solo gli stipendi SELECT SUM(PrezzUnit * Quant) AS Totale
diversi tra loro. FROM Fatture;
L’argomento può essere anche un’espressione
numerica.
Funzione AVG Calcolo dello stipendio medio degli Impiegati
Restituisce la media dei valori (numerici) SELECT AVG(StipBase)
contenuti in una colonna. L’argomento FROM Personale
può essere anche un’espressione WHERE Funzione = ‘Impiegati’;
numerica. Essa non include nel calcolo i
valori di tipo NULL si può aggiungere
l’opzione Distinct.
Funzione MIN e MAX Calcolo dello stipendio minimo e massimo
Restituisce il valore minimo/massimo tra dei dipendenti
quelli di una determinata colonna SELECT MIN(StipBase), MAX(StipBase)
specificata come argomento. Può essere FROM Personale;
utilizzata anche per campi di tipo ----------
carattere. Si può utilizzare la clausola Il primo e l’ultimo cognome dei dipendenti
Where. L’argomento può essere SELECT MIN(Cognome), MAX(Cognome)
un’espressione numerica ignorano i FROM Personale;
campi con valore NULL.
Ordinamenti
Clausola ORDER BY Elenco alfabetico dei dipendenti
Consente di ottenere i risultati SELECT Cognome, Nome, Nascita
dell’interrogazione ordinati secondo i FROM Personale
valori di 1 o + colonne tra quelle ORDER BY Cognome, Nome; *
elencate nella Select. L’ordinamento è * l’ordinamento è su 2 campi: a parità di
crescente (ASC) per default quindi è cognome i dipendenti vengono ordinati per
necessario specificarlo solo per il nome.
decrescente (DESC). ----------
SELECT Campo1, Campo2,….. Elenco dei dipendenti in ordine decrescente di
Campon stipendio
FROM Personale SELECT Cognome, StipBase
ORDER BY Campo1, Campon; FROM Personale
Per gli ordinamenti complessi occorre ORDER BY StipBase DESC, Cognome;
specificare Desc per i campi ordinati
in senso decrescente.
Generalmente la clausola Order By è
l’ultimo elemento di 1 comando SQL.
Raggruppamenti
Clausola Group By Elenco delle funzioni dei dipendenti con la
Con le f. di aggregazione (Sum, Count) somma degli stipendi e il numero dei
è possibile estendere la struttura del dipendenti appartenenti alle diverse funzioni.
comando Select con l’aggiunta di SELECT Funzione, SUM(StipBase), COUNT(*)
Group By. Si crea quindi una riga FROM Personale
per ogni raggruppamento. GROUP BY Funzione;
Se la Select non contiene 1 f. di ----------
aggregazione i valori di Elenco dei livelli esistenti tra i dipendenti che
raggruppamento non vengono prodotti svolgono la f. di Impiegato con il nr. di
in output. Tutti gli attributi che dipendenti per ciascun livello.
compaiono accanto alla Select devono SELECT Livello, COUNT(Livello) AS Conteggio
essere inclusi nel Group By oppure FROM Personale
devono essere argomenti di 1 f. di WHERE Funzione = ‘Impiegato’
aggregazione. GROUP BY Livello;

Clausola HAVING Lista delle funzioni dei dipendenti con lo


La Select con raggruppamento può stipendio medio per ciascuna funzione, dopo
essere ampliata con Having: essa aver raggruppato i dipendenti per funzione,
sottopone al controllo di 1 o + purché i dipendenti con quella funzione siano
condizioni i gruppi creati con Group + di 2.
By. La condizione dopo Having SELECT Funzione, AVG(StipBase)
normalmente controlla il valore FROM Personale
restituito dalle f. di aggregazione GROUP BY Funzione
(Count, Sum, Avg, ecc.). In genere, HAVING COUNT(*) > 2;
quindi, Having viene usata insieme a ----------
Group By: dopo che Group By ha Elenco delle filiali con + di 10 impiegati
formato i raggruppamenti di righe, SELECT Filiale, COUNT(Filiale) AS Conteggio
Having serve a visualizzare le righe FROM Personale
che soddisfano alle condizioni scritte WHERE Funzione = ‘Impiegato’
accanto a Having. Se la Select GROUP BY Filiale
contiene la clausola Where, i valori HAVING COUNT(*) > 10;
vengono raggruppati dopo aver
operato la selezione sulle righe che
rispettano le condizioni scritte accanto
a Where. Quindi Where agisce sulle
righe della tabella mentre Having
sulle righe contenenti i risultati delle
f. di aggregazione.
Condizioni di ricerca
Sono utilizzate insieme alle clausole Where e Having per determinare i criteri di
selezione rispettivamente delle righe e dei raggruppamenti. Si utilizzano gli operatori
relazionali (>, =, <, <=, ecc.) e booleani (And, Not, Or) e altre parole del linguaggio
SQL che rendono la ricerca più raffinata; vedere di seguito.
Operatore BETWEEN Elenco dei dipendenti assunti tra 1/1/95 e
Controlla se un valore è compreso 31/12/99
all’interno di 1 intervallo di valori, SELECT Cognome, Nome, Funzione
estremi inclusi. NOT Between valuta FROM Personale
la condizione opposta. WHERE Assunto BETWEEN 01/01/95
AND 31/12/99.
Operatore IN Elenco di tutti i dati dei dipendenti che
Controlla se un valore appartiene ad risiedono nelle provincie di Milano, Mantova,
un insieme specificato di valori. Anche Brescia e Como
IN può essere preceduto da NOT. SELECT *
SELECT Campo1, Campo2, …… FROM Personale
Campon WHERE Prov IN (‘MI’, ‘MN’, ‘BS’, ‘CO’);
FROM Tabella
WHERE Campox IN (elenco);
Operatore LIKE Elenco dei dipendenti aventi il cognome che
Confronta il valore di un attributo di inizia per ‘Ros’ e della relativa filiale
tipo carattere con un modello di SELECT Cognome, Filale
stringa che può contenere i caratteri FROM Personale
jolly (_ : un carattere qualsiasi; %: una WHERE Cognome LIKE ‘Ros%’;
stringa qualsiasi).
Like ‘xyz%’: la stringa inizia per xyz
Like ‘%xyz’: la stringa finisce per xyz
Like ‘%xyz%’: la stringa contiene xyz
Like ‘_xyz’: 4 caratteri di cui xyz di
fine.
Like senza caratteri jolly equivale a =.
Anche Like può essere preceduto da
NOT.
Operatore IS NULL Elenco dei dipendenti per i quali è indicata la
Tale predicato confronta il valore in provincia
una colonna con il valore Null. Questo SELECT Cognome, Nome
è il solo modo per controllare la FROM Personale
presenza del valore Null. Anch’esso WHERE Prov IS NOT NULL;
può contenere NOT.
Comandi per la sicurezza (DCL)
Comandi GRANT e REVOKE Per concedere il diritto di modifica sulla tabella
Concede i permessi, specificando il dei dipendenti agli utenti denominati User1 e
tipo di accesso, le tabelle sulle quali è User2
consentito l’accesso e l’elenco degli GRANT UPDATE
utenti ai quali è permesso di accedere. ON Personale
I permessi che possono essere TO User1, User2;
concessi (revocati) agli utenti sono ----------
indicati con le parole chiave che vanno Revoca dei permessi con annullamento dei
specificate dopo Grant o Revoke diritto di accesso del comando precedente
- ALTER (aggiungere/eliminare REVOKE UPDATE
colonne o modificare i tipi di dati) ON Personale
- DELETE (eliminare righe dalle TO User1, User2;
tabelle)
- INDEX (creare indici) ----------
- INSERT (inserire nuove righe nelle
tabelle) Concessione del diritto di modifica del livello e
- SELECT (per trovare dati nelle dello stipendio dei dipendenti all’utente User3.
tabelle) GRANT UPDATE (Livello, StipBase)
- UPDATE (cambiare i dati contenuti ON Personale
nelle tab.) TO User3;
- ALL (tutti i permessi precedenti).
I permessi con le opzioni Select e Update, nei
comandi Grant e Revoke, diventano +
restrittivi specificando tra parentesi e separati
da virgola, i nomi delle colonne che l’utente
può vedere o modificare.
Le VISTE
Il linguaggio SQL consente di decidere le modalità con le quali gli utenti possono
vedere le tabelle del database, creando una finestra, detta VIEW (vista), su alcuni o su
tutti i dati contenuti in 1 o + tabelle.
Comando CREATE VIEW e DROP Creazione di una vista di nome Impieg
VIEW contenente i dati degli Impiegati.
La limitazione della vista ad una visione CREATE VIEW Impieg
parziale della tabella consente di AS SELECT *
eliminare il rischio di modifiche FROM Personale
indesiderate su dati che non competono WHERE Funzione = ‘Impiegato’;
ad un determinato utente. La vista ----------
viene considerata quindi come se fosse Eliminazione della vista precedente.
una tabella e quindi le modifiche fatte DROP VIEW Impieg;
sulla vista si riflettono sulla tabella ----------
originale (finestre dinamiche). Le Concessione all’utente User3 al diritto di
viste che contengono risultati di accedere alla vista Impieg
funzioni di aggregazioni non sono GRANT SELECT
aggiornabili/modificabili. ON Impieg
Il comando Drop View consente TO User3;
l’eliminazione della vista.
Il creatore della vista, usando il
comando Grant, fornisce all’utente il
diritto di accesso ai dati attraverso
l’utilizzo della vista.
Quindi i sottoschemi e le autorizzazioni
per utenti diversi su un database
relazione possono essere definiti con
l’SQL usando in modo combinato i
comandi Create View e Grant.
Interrogazioni nidificate
All’interno di un comando Select è possibile inserire un altro comando Select
(interrogazione all’interno di un’altra interrogazione: subquery). Da qui Structured della
sigla SQL perché il linguaggio consente di costruire interrogazioni complesse e ben strutturate .
Alcuni esempi Elenco con cognome e nome dei dipendenti
Il comando Select nidificato restituisce il che hanno lo stipendio inferiore allo
valore calcolato del valor medio degli stipendio medio di tutti i dipendenti
stipendi; questo nr. viene usato poi SELECT Cognome, Nome
nell’interrogazione principale per il FROM Personale
confronto con i valori dell’attributo WHERE StipBase <
StipBase nel criterio di selezione delle (SELECT AVG(StipBase)
righe della tabella, scritto dopo Where. FROM Personale);
La condizione scritta dopo Where ----------
confronta il valore di un attributo con il Elenco dei dipendenti, elencati in ordine
risultato di un altro comando Select. Una alfabetico cognome, nome e descrizione
subquery può restituire un valore della filiale dove lavorano, per i quali lo
singolo, nessun valore oppure un stipendio risulta uguale al valore massimo
insieme di valori, ma deve comunque tra tutti gli stipendi dei dipendenti con la
avere una singola colonna o funzione di impiegato.
espressione accanto alla sua Select. SELECT Cognome, Nome, Descrizione
L’interrogazione si ottiene con la congiunzione FROM Personale, Dipendenza,
tra le 2 tabelle Personale e Dipendenza, WHERE Filiale = CodFil AND
realizzata attraverso l’attributo comune del
codice filiale; la condizione di selezione sulle
StipBase = (SELECT MAX(StipBase)
righe risultanti confronta lo stipendio di ogni FROM Personale
dipendente con il valore ottenuto da una WHERE Funzione =
sottointerrogazione che restituisce 1 nr., ‘Impiegato’)
ottenuto calcolando con la f. Max il valore ORDER BY Cognome, Nome;
massimo tra tutti i valori di StipBase.
Predicato ANY Elenco dei dipendenti che non sono impiegati
Indica che la subquery può restituire e che hanno lo stipendio superiore a quello
zero, oppure 1, oppure 1 insieme di di uno qualsiasi tra gli impiegati.
valori, e che la condizione di ricerca è SELECT Cognome, Nome, Funzione
vera se il confronto è vero per almeno 1 FROM Personale
dei valori restituiti. La condizione di WHERE Funzione <> ‘Impiegato’ AND
ricerca è falsa se la subquery restituisce StipBase > ANY (SELECT StipBase
1 insieme vuoto oppure se il confronto è FROM Personale
falso per ciascuno dei valori restituiti WHERE Funzione =
dalla subquery. ‘Impiegato’);
Predicato ALL Elenco di tutti di dipendenti che non sono
Indica che la subquery può restituire impiegati e che hanno lo stipendio superiore
zero, oppure 1, oppure 1 insieme di a quello di tutti gli impiegati.
valori, e che la condizione di ricerca è
vera se il confronto è vero per ciascuno Basta sostituire ALL a ANY
dei valori restituiti. La condizione di SELECT Cognome, Nome, Funzione
ricerca è falsa se il confronto è falso per FROM Personale
almeno 1 tra i valori restituiti dalla WHERE Funzione <> ‘Impiegato’ AND
subquery. StipBase > ALL (SELECT StipBase
Ovviamente l’interrogazione con ALL FROM Personale
restituisce 1 nr inferiore di righe rispetto WHERE Funzione =
a ANY. ‘Impiegato’);
Le clausole Any e All possono essere tralasciate
nelle espressioni di confronto se si è in grado di
stabilire che la subquery restituirà sicuramente
un solo valore. In questo caso la condizione di
ricerca è vera se è vero il confronto tra il valore
dell’attributo e il valore restituito dalla subquery.
Predicato IN Elenco con cognome e nome dei dipendenti
Serve a controllare se il valore di un che lavorano nelle filiali che hanno più di 10
attributo è compreso tra quelli restituiti dipendenti
dalla subquery. SELECT Cognome, Nome
È possibile utilizzare NOT IN per FROM Personale
estrarre solo le righe della tabella WHERE Filiale IN (SELECT Filiale
principale per le quali nessuna riga della FROM Personale
tabella ottenuta con la subquery GROUP BY Filiale
contiene un valore =. HAVING COUNT(*)
>10);
Le seguenti condizioni di ricerca sono
equivalenti: WHERE Attributo = ANY (SELECT ……..)
WHERE Attributo IN (SELECT ……..) WHERE Attributo <> ALL (SELECT……..)

WHERE Attributo NOT IN (SELECT
……..) 
Predicato EXISTS Elenco dei dipendenti con cognome e nome
Controlla se vengono restituite righe solo se esistono dipendenti di sesto livello
dall’esecuzione della subquery: la SELECT Cognome, Nome
condizione di ricerca è vera se la Select FROM Personale
nidificata produce 1 o + righe come WHERE EXISTS (SELECT *
risultato, è falsa se la subquery FROM Personale
restituisce un insieme vuoto. WHERE Livello = 6);
Tale predicato è il solo che non confronta un
valore con 1 o + altri valori. Le colonne utilizzate
nella subquery di una clausola Exists sono
irrilevanti: quindi per brevità si utilizza Select *
nella subquery. Exists può essere negato: Not
Exists.
Età di una persona
Mostra l’età (in anni) di una persona SELECT nome, datanas, CURDATE(),
dalla data corrente. CURDATE fornisce ( YEAR(CURDATE())-YEAR(datanas) )
“aaaa-mm-dd” e RIGHT(stringa, n) - (RIGHT(CURDATE(),5) <
estrae n caratteri partendo dalla parte RIGHT(datanas,5)) AS eta
destra della stringa. FROM clienti;
JOIN in ACCESS

Proprietario Assicurazione
Codice Nome Descrizione ID Nome Tariffa Classe
101 Marco Dir. Gen. ENI S.p.a. 101 Sara 200 A
102 Laura Segretaria Eni 102 Generali 105 AA
S.p.a.
103 Zurich 150 B
Veicolo
Codice Targa Descrizione
101 AX 541 Maserati
OP
102 BC 650 Lancia Ypsilon
PP

Predicato JOIN (2 tab) Elenco di tutti i proprietari con i rispettivi veicoli


Congiunzione tra due SELECT Proprietario.Descrizione, Veicolo.Descrizione
tabelle (INNER JOIN) e FROM Proprietario INNER JOIN Veicolo
proiezione su alcuni campi ON Proprietario.Codice=Veicolo.Codice;
congiungendo le due
tabelle tramite (ON)
l'uguaglianza
dell'attributo in comune
(Codice)
Predicato JOIN (3 o + Elenco di tutti i proprietari con i rispettivi veicoli e tariffa
tab) SELECT
Congiunzione tra tre Proprietario.Descrizione, Veicolo.Descrizione,
tabelle (INNER JOIN) e Assicurazione.Tariffa
proiezione su alcuni campi FROM (Proprietario INNER JOIN Veicolo
congiungendo le tre ON Proprietario.Codice=Veicolo.Codice) INNER JOIN
tabelle, prese a gruppi di Assicurazione ON Veicolo.Codice=Assicurazione.ID;
due, tramite (ON)
l'uguaglianza
dell'attributo in comune
delle prime due (Codice)e
poi tramite l'uguaglianza
dell'attributo in comune
della terza tabella (ID)

Data ultima modifica: 18/06/2011 10:07:00 O6/P6 Prof.ssa Elisabetta Bugli- Prof. G. 1
Calabrese - Prof. O. Pompizii
Data ultima modifica: 18/06/2011 10:07:00 O6/P6 Prof.ssa Elisabetta Bugli- Prof. G. 1
Calabrese - Prof. O. Pompizii
HTML
Elementi di base di un <html>
documento HTML: <head>
<title>Titolo della pagina</title>
</head>
<body>
<!-- qui si crea la pagina vera e propria -->
</body>
</html>
Tabella <TABLE width="50%" border="1">
PARAMETRO WIDTH <TR width="25%">
definisce la larghezza <th>Colonna1</th>
dell'oggetto in <th>Colonna2</th>
percentuale rispetto alla <th>Colonna3</th>
risoluzione dello schermo. <th>Colonna4</th>
</TR>
TAG TH <TR>
indica l'intestazione delle <td width="25%">dato01</td>
colonne (scritta <td>dato02</td>
COLONNA1 in grassetto) <td>dato03</td>
<td>dato04</td>
PARAMETRO BORDER </TR>
definisce la dimensione </TABLE>
del bordo della tabella.
<a href="MenuPrincipale.html">Ritorna al menù
principale </a>
Link
FORM: <form name="nomeForm" action="fileScript.php"
(contenitore di oggetti method="POST ">
quali: Text Box, <!-- qui si inseriscono gli elementi -->
Combo Box, </form>
Pulsanti, ... )

Data ultima modifica: 18/06/2011 10:07:00 O6/P6 Prof.ssa Elisabetta Bugli- Prof. G. 1
Calabrese - Prof. O. Pompizii
Elementi di un Form:
Text Box <INPUT type=“TEXT" name="Utente">
<INPUT type=“PASSWORD" name="PwdUtente">

Check Box <INPUT type=”CHECKBOX” name=”N”>Nuoto


<INPUT type=”CHECKBOX” name=”T”>Tennis

Radio Button <INPUT type=”RADIO” name="Nazione" value=”Italia”>


ITALIA
<INPUT type=”RADIO” name ="Nazione"
Combo Box (Selezione) value=”Francia”> FRANCIA

<SELECT name="NomeCombo">
<OPTION value="Citta1"
SELECTED>Roma</OPTION>
<OPTION value="Citta2">Rimini</OPTION>
Pulsanti <OPTION value="Citta3">Ravenna</OPTION>
</SELECT>

<INPUT type="SUBMIT" value="Invia">


<INPUT type="RESET" value="Annulla">

<INPUT type="BUTTON" name="B1" value="Calcola"


onClick="nomeProcedura">

Data ultima modifica: 18/06/2011 10:07:00 O6/P6 Prof.ssa Elisabetta Bugli- Prof. G. 2
Calabrese - Prof. O. Pompizii
Tipi di dati MySql
Numerici
B Tipo valore minimo Valore massimo
1 BIT [(M)]
1 TINYINT [(M)] [UNSIGNED] [ZEROFILL] -128 (0) +128 (255)
2 SMALLINT [(M)] [UNSIGNED] [ZEROFILL] -32768 (0) +32767 (65535)
3 MEDIUMINT[(M)] [UNSIGNED] [ZEROFILL] -8988608 (0) +8988607 (16777215)
4 INT [(M)] [UNSIGNED] [ZEROFILL] -2147483648 (0) +2147483647
8 BIGINT [(M)] [UNSIGNED] [ZEROFILL] -263 (0) +263 -1 (+264 -1)
4 FLOAT [(M,D)] [UNSIGNED] [ZEROFILL]
8 DOUBLE [(M,D)] [UNSIGNED] [ZEROFILL]
DECIMAL [(M[,D])] [UNSIGNED] [ZEROFILL]

Bit (si può usare anche Bool) è sinonimo di TINYINT(1): 0=FALSE, 1=TRUE.
L’opzione UNSIGNED specifica che il numero è senza segno (questo comporta
la possibilità di memorizzare solo numeri positivi ma si recupera il bit del
segno e quindi si possono memorizzare numeri più grandi), mentre l’opzione
ZEROFILL indica al server di memorizzare i numeri con degli zeri davanti nel
caso in cui la lunghezza sia inferiore a quella massima prevista.
I dati di tipo TINYINT, SMALLINT, MEDIUMINT, INT e BIGINT
rappresentano numeri interi composti rispettivamente da 1, 2, 3, 4 e 8 bytes. I
tipi FLOAT e DOUBLE rappresentano i numeri in virgola mobile. Il tipo
DECIMAL corrisponde ai numeri rappresentati nel formato virgola fissa (4 bit
ogni cifra), con M cifre totali di cui D decimali.
Esiste anche il tipo BOOL che corrisponde a TINYINT (0=falso, un valore
diverso da 0=vero).
Data e ora
3 DATE
8 DATETIME da '1000-01-01 00:00:00' a '9999-12-31 23:59:59'
4 TIMESTAMP[(M)]
3 TIME da ’-838:59:59’ a ’+838:59:59’
1 YEAR [(2|4)] da 70 a 69 o da 1970 a 2155

Stringhe
detta L la lunghezza della stringa Byte occupati
[NATIONAL] CHAR(M) [BINARY | ASCII | UNICODE] (M byte se ACII)
[NATIONAL] VARCHAR(M) [BINARY] 0<=M<=65535 (L+1 byte se L<255 o L+2)
BINARY(M) 0<=M<=255 (L+1 byte)
VARBINARY(M) 0<=M<=65535 (L+1 byte se L<255 o l*2)
TINYBLOB max 255 caratteri L+1
TINYTEXT max 255 caratteri L+1
BLOB [(M)] max 65535 char l+2
TEXT [(M)] max 65535 char l+2
MEDIUMBLOB max 16777215 char L+3
MEDIUMTEXT max 16777215 char L+3
LONGBLOB max 4GB L+4
LONGTEXT max 4GB Lè4
ENUM ('valore1','valore2',...) 1 o 2 bytes
SET ('valore1','valore2',...) 1,2,3,4 o 8 bytes
Il tipo CHAR è una stringa di lunghezza fissa (M) riempita con spazi a destra
al momento della memorizzazione. L’opzione NATIONAL indica che la stringa
deve usare il set di caratteri di default. L’attributo BINARY fa diventare case
sensitive. Il tipo VARCHAR è una stringa di lunghezza variabile. I tipi
BINARY e VARBINARY corrispondono a CHAR e VARCHAR, ma
memorizzano stringhe di byte invece che di caratteri. I tipi BLOB e TEXT

Data ultima modifica: 18/06/2011 10:07:00 O6/P6 Prof.ssa Elisabetta Bugli- Prof. G. 2
Calabrese - Prof. O. Pompizii
sono utilizzati rispettivamente per valori binari e di testo. Un tipo ENUM può
contenere uno solo dei valori elencati nella definizione (max 65535), oppure
NULL (in realtà contiene un numero di 1 o 2 byte). Un tipo SET, può
contenere 1 o più dei max 64 valori possibili.

Data ultima modifica: 18/06/2011 10:07:00 O6/P6 Prof.ssa Elisabetta Bugli- Prof. G. 2
Calabrese - Prof. O. Pompizii
Le principali funzioni incluse in MySQL
Le funzioni e, più in generale, le espressioni possono essere utilizzate per la
definizione di campi calcolati nelle query (dopo SELECT) oppure nelle clausole
where, having e anche group by, order by.
Funzioni matematiche
Con MySQL nei calcoli, oltre ai normali operatori +, - , *, / si possono utilizzare:
 % (resto della divisione intera), MOD (sempre resto della divisione intera), DIV (divisione
intera);
 le operazioni sui bit del linguaggio C: & (AND), | (or), ^ (XOR), ~ (inversione dei bit), <<
(scorrimento a sinistra dei bit), >> (scorrimento a destra)
Nome Descrizione Esempi
Calcola il valore assoluto di x select abs(2.5), abs(-37)
abs(x)
 2,5 37
ceiling( Restituisce il più piccolo intero >= x, select ceiling(2.3), ceiling(-1.2)
x) corrisponde all’arrotondamento per eccesso  3 -1
Restituisce il più grande intero <= x select floor(2.3), floor(-1.2)
floor(x)
(arrotondamento per difetto)  2 -2
x
Calcola e (dove e è la base dei logaritmi select exp(2), exp(-2)
exp(x)
naturali)  7.3890560989307
LN(x) Calcola il logaritmo naturale di x
log(x) oppure log(B,x) select log(2), log(10,100)
se richiamato con un solo parametro  0.693147180 2
log()
corrisponde a LN(x) altrimenti calcola il
logaritmo in base B di x
round(x) oppure round(x,D) select round(2.3),
con un parametro arrotnda il numero x round(2.6),round(2.5)
round() all’intero più vicino mentre con due parametri  2 3 3
restituisce il numero x con solo D cifre decimali select round(2.234,2) round(2.567,2)
arrotondandolo l’ultima cifra decimale.  2.23 2.57
pow(x,y calcola x elevato a y con x e y numeri qualsiasi select pow(2,4), pow(81, 0.5)
) (anche con la virgola)  16 9
calcola la radice quadrata di x select sqrt(81), sqrt(4)
sqrt(x)
 9 2
Funzioni per le stringhe di caratteri
Con MySQL l’operatore + converte le stringhe in numeri quindi per effettuare la concatenazione
di due o più stringhe di caratteri si deve usare la funzione CONCAT().
Nei confronti tra stringhe di caratteri non c’è differenza tra maiuscole e minuscole.
Le stringhe costanti possono essere racchiuse tra due virgolette doppie (es. “Prova”) o tra due
apostrofi (codice ASCII 39 es. ‘Prova’) mentre la virgoletta singola ` (codice ASCII 96) viene
utilizzata per delimitare i nomi dei campi e delle tabelle.
Nome Descrizione Esempi
concat(stringa1, stringa2 [, …]) select concat(‘Anna’,’Maria’);
concat(
crea una nuova stringa unendo tutte le stringhe  AnnaMaria
)
passate come parametri.
length(stringa) select length(‘Informatica’);
length(
restituisce la lunghezza in byte della stringa  11
)
fornita come parametro
left(stringa1,n) select left(“Informatica”,4);
left() restituisce n caratteri della stringa stringa1 a  Info
partire da sinistra
right(stringa1,n) select right(“Informatica”,4);
right() restituisce n caratteri della stringa stringa1 a  tica
partire da destra
instr() intrstr(stringa1,stringa2) select instr(‘corso di
cerca stringa2 all’interno di stringa1, se la informatica’,’Info’);
trova restituisce la posizione in cui è stata  10
trovata altrimenti zero. select instr(‘corso di

Data ultima modifica: 18/06/2011 10:07:00 O6/P6 Prof.ssa Elisabetta Bugli- Prof. G. 2
Calabrese - Prof. O. Pompizii
informatica’,’Infa’);
0
locate( locate(stringa2,stringa1)
) come instr() ma gli argomenti sono invertiti
lcase() lcase(stringa1) oppure lower(stringa1) select lcase(“PROva”);
lower() trasforma la stringa in minuscolo  prova
ucase() ucase(strina1) oppure upper(stringa1) selecr upper(“PROva”);
upper() trasforma la stringa in maiuscolo  PROVA
substr(stringa1,p,n) oppure substr(stringa1,p) select mid(‘Informatica’,3,2);
mid è un sinonimo di substr  fo
substr( Estrae n caratteri dalla stringa stringa1 a
) partire da quello in posizione p. Se ci sono solo select mid(“informatica”,5);
mid() due parametri estrare dalla stringa stringa1  matica
tutti i caratteri a partire da quello in posizione
p fino alla fine.
replace(stringa1, sub1, sub2) select replace(‘la casa di
cerca tutte le occorrenze della sottostringa Mario’,’Mario’,’Pia’);
replace
sub1 in stringa1 e la rimpiazza con sub2, in  la casa di Pia
()
questo caso la ricerca è case sensitive. select replace(“lascia A”,”a”,”o”);
 loscio A
lpad(stringa1, lun, str) select lpad(‘345’,6,’0’),
restituisce la stringa1 con esattamente lun lpad(‘CD’,7,’axy’);
lpad() caratteri tagliandola se è troppo lunga o  000345 axyaxCD
aggiungendo la stringa str a sinistra tante volte
se è troppo corta
come lpad ma la stringa string1 viene allungata select
rpad() a destra (aggiungendo la stringa str) se è lpad(‘45’,6,’0’),lpad(‘CD’,7,’axy’);
troppo corta  450000 CDaxyax
repeat( repeat(str, cont) select repeat(‘MySQL’,3);
) ripete la stringa str esattamente count volte  MySQLMySQLMySQL
trim(stringa1) select trim( ‘ ciao ‘);
elimina gli spazi iniziali e finali da stringa1  ‘ciao’
oppure trim(BOTH ! LEADING | TRAILING car
trim() FROM stringa1) select trim(leading ‘x’ from
elimina i caratteri car all’inizio (LEADING) ‘xxxciaoxx’);
oppure alla fine (TRAILING) o entrambi (BOTH)  ‘ciaoxx’
nella stringa stringa1

Funzioni data e ora


Una data può essere inserita utilizzando una stringa nel formato anno-mese-giorno, per
esempio ‘2011-04-10’ oppure ‘1970/3/21’, si può utilizzare il separatore che si preferisce
e si può inserire anche l’anno con due cifre sapendo che
 da 70 a 99 verrà trasformato in 1970 fino a 1999 es. ‘70/3/4’  1970-03-04
 da 00 a 69 verrà trasformato in 2000 fino a 2069 es. ’21-4-15’  2021-04-15
Le date valide vanno da ‘1000-01-01’ fino a ‘9999-12-31’
Un’ora viene inserita invece nel formato HH:MM:SS (ore minuti secondi) anche qui si
può utilizzare un separatore a piacere.
Si può operare con le date e le ore anche con espressioni aritmetiche del tipo:
‘2011-04-06’ + INTERVAL 50 day – INTERVAL 6 week
in alternativa all’uso delle funzioni date_add() e date_sub() con gli stessi effetti.
Nome Descrizione Esempi
curdate( curdate() da come risultato la data select curdate();
) corrente presa dall’orologio del sistema  2011-04-07
curtime( curtime() da come risultato l’ora corrente select curtime();
) presa dall’orologio del sistema  17:14:55
now() da come risultato la data e l’ora select now();
now()
corrente presa dall’orologio del sistema  2011-04-07 17:16:32
date_ad DATE_ADD(date,INTERVAL expr unit), select date_add(‘2011-4-2’,
Data ultima modifica: 18/06/2011 10:07:00 O6/P6 Prof.ssa Elisabetta Bugli- Prof. G. 2
Calabrese - Prof. O. Pompizii
DATE_SUB(date,INTERVAL expr unit) INTERVAL 2 month);
Date_ADD aggiunge un intervallo di tempo  2011-06-02
ad una date mentre date_sub serve per select date_add(‘2011-4-2’,
sottrarre un certo intervallo di tempo da INTERVAL 100 day);
d() una data. Il risultato è sempre una nuova  2011-07-11
date_sub data. select date_sub(‘2011-4-2’
() L’intervallo può essere espresso in giorni, INTERVAL 3 day);
settimane, mesi, anni, e anche ore, minuti,  2001-03-30
secondi scrivendo al posto di expr_unit:
DAY, WEEK, MONTH, YEAR, HOUR,
MINUTE, SECOND
datedif(data1,data2) select datediff('2011/04/05',
datediff(
fa la differenza tra due date, data1-data2, '2011/03/08');
)
il risultato è espresso in giorni  28
day(data1) month(data1) year(data1) select year(now());
day()
servono per estrarre rispettivamente il  2011
month()
giorno, il mese e l’anno da una data o da
year()
una dataora
hour(dataora1) minute(dataora1) select second(now());
hour()
second(dataora1)  15
minute()
servono per estrare ore minuti e secondi
second()
da una dataora (o solo ora)
dayOfWeek(data1) oppure select dayofweek('2011-04-10');
weekDay(data1)  1
dayOfW
restituisce il giorno della settimana select weekDay('2011-04-10');
eek
DayOfWeek() restituisce 1=Domenica,  6
WeekDa
2=lunedì .. 7=sabato
y
WeekDay restituisce 0=lunedì, 1=
martedì, … 6=domenica

Altre Funzioni
Nome Descrizione Esempi
if(condizione, espr1,espr2) se la condizione è select if(10>7,1,0)
vera da come risultato il risultato  1
dell’espressione espr1, altrimenti il risultato select count(if
if()
dell’espressione espr2 (sesso=’F’,1,NULL))
conta il numero delle
femmine (anche 0)
cast(espr AS tipo) oppure convert(espr,tipo)
Converte il risultato dell’espressione espr nel
cast()
tipo specificato che può essere: CHAR, DATE,
convert(
DATETIME, TIME, DECIMAL, SIGNED,
)
UNSIGNED, BINARY (stringa con l’attributo
binary)
password(stringa) select password(‘prova’);
Calcola con un algoritmo segreto uno stringa 
di 41 cifre esadecimale dipendenti dalla '*5A5DBAE1C258F3E8D037
stringa fornita come parametro. Non esiste F02A6B16BE6570821C5B'
passwor
l’algoritmo inverso, due stringhe diverse
d()
potrebbero dare lo stesso risultato ma la
probabilità e molto bassa. E’ il sistema
utilizzato da MySQL per crittografare le
password degli utenti.
sha() sha(str) oppure sha1(str) select sha(‘prova’);
Data ultima modifica: 18/06/2011 10:07:00 O6/P6 Prof.ssa Elisabetta Bugli- Prof. G. 2
Calabrese - Prof. O. Pompizii
produce una stringa di 40 cifre esadecimali ‘46c3d962f31452b970069
(160 bit) in output calcolate con l’algoritmo e96ba6d741b4fd276a5'
SHA1 a partire dalla stringa str di lunghezza
arbitraria. Può esser usato per crittografare
sha1() una stringa, per esempio una password e il
risultato è più sicuro che con la funzione
MD5(), non è disponibile la funzione inversa
ma si tratta di un algoritmo standard ben
conosciuto. SHA e SHA1 sono uguali.
md5(str) select MD5(‘prova’);
md5() come sha ma il risultato sono 128 bit (32 cifre '27c749230e8f93b76fa0a4
esad) b9dc3cc450'
encode(str,pass_str) decode(str,pass_str) select encode(‘Prova’,’123’);
encode( serve a crittografare e a decrittografare una  'b„ ó?'
) stringa di caratteri (str) utilizzando come select decode(‘'b„ ó?', '123’)
decode( chiave di crittografia la stringa pass_str. Il  ‘Prova’
) risultato è una stringa binaria della stessa
lunghezza della stringa da crittografare.

Data ultima modifica: 18/06/2011 10:07:00 O6/P6 Prof.ssa Elisabetta Bugli- Prof. G. 2
Calabrese - Prof. O. Pompizii
PHP
Funzioni per la gestione degli array
Un array in php può avere come indice un valore numerico o alfanumerico, in
quest’ultimo caso si dice associativo. In ogni caso possiamo immaginare l’array come
una tabella con due colonne: chiave e valore. La chiave è l’indice dell’array, ad ogni
chiave corrisponde un valore, ogni riga comprende una coppia chiave-valore.
Il motore PHP mantiene internamente per ogni array un puntatore alla posizione
corrente. E’ possibile accedere alla chiave e al valore della posizione corrente con le
funzioni key() e current(), si può spostare il puntatore in avanti con next(), indietro con
prev(), si può riportare all’inizio dell’array con reset() e alla fine con end()
Nome Descrizione Esempi
key(vettore) restituisce la chiave Visualizza tutti i campi di un
key()
(indice) della posizione corrente del vettore modulo inviato al server con il
curren current(vettore) restituisce il metodo post.
t() valore della posizione corrente del vettore reset($_POST);
next(vettore) sposta il for ($i=0;$i<count($_POST);
next() $i++)
puntatore corrente avanti di una posizione {echo key($_POST).' = '.
prev(vettore) sposta il current($_POST).' <br> ';
prev() puntatore corrente indietro di una next($_POST); }
posizione
end(vettore) sposta il puntatore
end()
corrente sull’ultima posizione del vettore
reset(vettore) sposta il
reset() puntatore corrente alla prima posizione del
vettore
count( count(vettore) fornisce il numero
) degli elementi del vettore
each(vettore) restituisce un list($chiave,$valore)=each(vett);
vettore di due elementi: chiave e valore // estrae la chiave e il valore
each() della posizione corrente e sposta la dell’elemento
posizione corrente in avanti // corrente del vettore associativo
vett
list(var1, var2, var3,….)=vettore <?php
copia gli elementi del vettore nelle variabili $vett=array('Primo','secondo','te
var1, var2, var3 ecc. Se il numero delle rzo');
list()
variabili è minore degli elementi del vettore list($a,$b)=$vett;
copia solo i primi elementi. // $a=Primo $b=secondo
Funziona con i vettori numerici
array(valore1, valore2, valore3, ….) $vett=array('Primo','secondo','te
restituisce un vettore con indice numerico rzo');
contenente tutti i valori forniti come //vett diventa un vettore
array()
parametri inizializzato con
// i tre elementi
‘Primo’,’secondo’,’terzo’

Funzioni MySQL
Nome Descrizione Esempi
mysql_connec mysql_connect([string_server[,string_no <?php
t() me_utente[, strig_password[bool $conn = mysql_connect("loc
nuova_conn]]]]) alhost", "utente_mysql", "pa
Apre una connessione ad un server ssword_mysql")
MySql.    or die("Connessione non ri
Restituisce un identificativo di uscita: " . mysql_error());
Data ultima modifica: 18/06/2011 10:07:00 O6/P6 Prof.ssa Elisabetta Bugli- Prof. G. 2
Calabrese - Prof. O. Pompizii
connessione in caso di successo o FALSE  print ("Connesso con succe
in caso di errore. sso");
Se si apre due volte la stessa  mysql_close($conn);
connessione viene restituito lo stesso ?>
identificativo a meno che non si mette
TRUE al parametro nuova_conn
mysql_close($conn) mysql_close($conn);
Chiude la connessione al server relativa
all’identificativo di connessione
mysql_close() specificato.
La connessione viene anche
automaticamente chiusa al termine dello
script.
mysql_select_db(string nome_database mysql_select_db("aziende")
[,$conn]) or
Imposta il database attivo fra quelli gestiti die (“Impossibile aprire il
mysql_select_ dal server database: “. mysql_error());
db() MySql. Restituisce TRUE in caso di successo
e FALSE
in caso di fallimento. Se non si specifica la
connessione viene utilizzata l’ultima aperta.
mysql_query(string query[, $conn]) $sql= “Select * form
Invia una query al database. Se si aziende where cod=’RN’”;
omette la connessione viene presa if (!
l’ultima aperta.. Se la query è una Select ($ris=mysql_query($sql))) {
(o una SHOW, EXPLAIN, Describe) echo "Errore nel comando:
mysql_query()
fornisce come risultato un identificativo <br /> $sql <br />";
di risorsa in caso di successo, per gli echo mysql_error();
altri tipi di query restituisce TRUE in exit();
caso di successo, in caso di insuccesso }
restituisce sempre FALSE.
si utilizza dopo aver eseguito una query $sql=”Insert into ….”;
INSERT INTO e restituisce il numero mysql_query($sql));
mysql_insert_
generato automaticamente per $codice=mysql_insert_id();
id()
l’eventuale campo auto_increment del
database
mysql_fetch_array ( resource ris) $ris=mysql_query($sql);
restituisce un array sia numerico che $riga=mysql_fetch_array($ri
associativo contenete una riga della s);
tabella ris che deve essere il risultato
mysql_fetch_a dell’esecuzione di una query (Select).
rray() Ogni volta che viene eseguito prende la
riga successiva nella tabella. Se non ci
sono più righe restituisce il valore
FALSE. Si può tornare indietro o saltare
delle righe utilizzando mysql_data_seek.
mysql_num_rows ( resource ris ) $sql= “Select * form
restituisce il numero di righe della aziende where cod=’RN’”;
mysql_num_r tabella risultato in seguito $ris=mysql_query($sql);
ows all’esecuzione di un comando sql $num=mysql_num_rows(ris)
() ;
SELECT con mysql_query
echo “Numero di aziende di
Rimini = $num”;
mysql_affecte mysql_affected_rows ( [$conn])
d_rows() Restituisce il numero di righe
Data ultima modifica: 18/06/2011 10:07:00 O6/P6 Prof.ssa Elisabetta Bugli- Prof. G. 2
Calabrese - Prof. O. Pompizii
coinvolte dall’esecuzione di un
comando SQL come DELETE,
INSERT, UPDATE. Il parametro
facoltativo $conn è l’identificativo di
connessione, se non specificato si
considera l’ultima aperta.
mysql_data_seek ( resource ris, int
numriga )
Sposta il puntatore interno alla riga
di una tabella ottenuta come risultato
di una SELECT con mysql_query().La
successiva chiamata a
mysql_data_s
mysql_fetch_array() dovrebbe
eek
restituire questa riga.
Il numero numriga deve essere
compreso tra 0 e mysql_num_rows
-1. Restituisce TRUE se lo
spostamento riesce e FALSE
altrimenti.
addslashes ( string sql )
restituisce la stessa stringa passata
come parametro con in più il
carattere backslash “\” aggiunto
addslashes() prima dei caratteri che richiedono il
quoting nelle stringhe sql ovvero
prima dei caratteri ‘, “, \ e NULL.
Serve per preparare la query prima
di eseguirla.
stripslashes ( string str )
restituisce la stessa stringa passata
come parametro ma elimina i
stripslashes()
caratteri backslash “\”
precedentemente aggiunti con
funzioni tipo addslashes.
$nomevariabi Dichiarazione variabili $nomehost = "marco";
le
Riempimento tabella HTML
Riempiment <TABLE WIDTH="80%" BORDER="1">
o di una <TR>
tabella <TH WIDTH="25%">Cognome</TH>
HTML dal <TH WIDTH="25%">Nome</TH>
risultato di <TH WIDTH="25%">Residenza</TH>
una query
<TH WIDTH="25%">Telefono</TH>
applicata ad
un DB </TR>
MySQL, <TR>
utilizzando il <?php
ciclo WHILE. .......
$risultati=mysql_query($sql);
while( ($record = mysql_fetch_array($risultati) )
{

Data ultima modifica: 18/06/2011 10:07:00 O6/P6 Prof.ssa Elisabetta Bugli- Prof. G. 2
Calabrese - Prof. O. Pompizii
//stampo tabella
echo "<TD>" . $record["Cognome"] . "</TD>";
echo "<TD>" . $record[1] . "</TD>";
echo "<TD>" . $record["Residenza "] . "</TD>";
echo "<TD>" . $record[3] . "</TD>";
}
........
?>

Gestione delle sessioni


Nome Descrizione Esempi
session_start() session_start();
session_sta
riprende una sessione esistente o avvia una
rt()
nuova sessione
session_unset() //chiude la sessione
session_uns
cancella tutte le variabili di sessione. Si può session_unset();
et()
fare anche con: $_SESSION=array(); session_destroy();
session_destroy() vedi sopra
session_des
distrugge e chiude la sessione. Il prossimo
troy
accesso apre una nuova sessione

Altre funzioni
Nome Descrizione Esempi
isset($variabile) if (isset($codice))
isset() restituisce vero se la variabile è stata inizializzata $codice++ else
$codice=1;
date ( string formato [, int timestamp] ) echo date("Y-m-d
restituisce una stringa contenente la data (ed H:i:s");
eventualmente ora) formattata secondo il  2011-06-04
formato specificato. Se non si fornisce il secondo 17:23:48
parametro che rappresenta la data e l’ora nel
formato timestamp di unix, verrà visualizzata la
data di sistema.
Il primo parametro è una stringa contenente
caratteri speciali che indicano come costruire la
stringa contenente la data e/o ora. I principali
caratteri speciali sono:
date()
d giorno del mese con due cifre
m mese dell’anno con due cifre
y anno con due cifre
Y anno con 4 cifre
h ore nel formato a 12 ore da “00” a “12”
H ore nel formato a 24 ore da “00” a “23”
i minuti da “00” a “59”
s secondi da “00” a “59”
w giorno della settimana da “0” domenica a
“6” sabato
z giorno dell’anno da “0” a “365”
mktim mktime ( int ora, int minuti, int secondi, int echo(“Y-m-
e() mese, int giorno, int anno [, int is_dst] ) d”,mktime(0,0,
restituisce un numero intero corrispondente al 0,6,5,2011))
 2011-06-05
Data ultima modifica: 18/06/2011 10:07:00 O6/P6 Prof.ssa Elisabetta Bugli- Prof. G. 3
Calabrese - Prof. O. Pompizii
valore timestamp di unix per la data e ora
specificati come parametri
l’ultimo parametro facoltativo indica se applicare
o meno l’ora legale (is_dst=1 per l’ora legale, 0
ora solare e -1 in automatico)

Istruzioni PHP
Nome Descrizione Esempi
include $nomefile vars.php
Serve per includere nel punto dove è inserita <?php
l’istruzione il file con codice php o html avente $colore = 'verde';
$frutto = 'mela';
come nome quello specificato dal parametro ?>
$nomefile che può essere una stringa costante.
includ
L’unica differenza tra include e require è che nel test.php
e
primo caso se il file non c’è lo script prosegue, <?php $a='Una';
requir
mentre nel secondo caso viene interrotto. include 'vars.php';
e echo "$a $frutto $color
Il codice php nei file da includere deve essere
sempre racchiuso tra <?php e ?>. e";
 // Una mela verde
Il file verrà cercato nelle directory indicate nel
?>
parametro include_path del file di configurazione
php.ini.

Data ultima modifica: 18/06/2011 10:07:00 O6/P6 Prof.ssa Elisabetta Bugli- Prof. G. 3
Calabrese - Prof. O. Pompizii