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
CREATE [UNIQUE]* INDEX
nomeIndice
ON nomeTabella (Attributi1,
Attrib2..);
* se non si vogliono valori duplicati
Cancellazione di una Tabella
DROP TABLE nomeTabella;
Cancellazione di un Indice
DROP INDEX nomeIndice ON
nomeTabella;
Rinominare una tabella
ALTER TABLE nomeVecchio
RENAME nomeNuovo;
Rinominare un campo
ALTER TABLE nomeTabella
CHANGE nomeCampoVecchio
nomeCampoNuovo Tipo;
Manipolazione dei dati (DML)
Operazione sui DATI
D Inserimento di un nuovo
M Record
INSERT INTO nomeTabella
L
(Campo1, Campo2, ……..
Campon)
VALUES (‘Dato1’, ‘Dato2’,
………, Daton);
Cancellazione di un Record
DELETE FROM nomeTabella
WHERE
[campoChiave=’ValoreChiave’];
Condizion
Modifica di un Campo
UPDATE nomeTabella
SET campo=’dato’
WHERE
[campoChiave=’ValoreChiave’];
CONDIZIONE
Creazione indice Ipers
CREATE UNIQUE INDEX Ipers
ON Personale (Cognome, Nome);
Cancellazione tabella Personale
DROP TABLE Personale;
Cancellazione indice Ipers
DROP INDEX Ipers ON Personale;
Rinominare la tabella Personale in
Dipendenti
ALTER TABLE ‘Personale’ RENAME
‘Dipendenti’;
Rinominare il campo Stipendio in StipBase
ALTER TABLE Personale
CHANGE Stipendio StipBase Real;
Inserimento di un nuovo dipendente
INSERT INTO Personale
(Matricola, Cognome, Nome, Livello)
VALUES (‘AB541’, ‘Rossi’, ‘Mario’,
‘Impiegato’);
Cancellazione record per cui la matricola è
AQ123
DELETE FROM Personale
WHERE matricola=’AQ123’;
---------
Cancellazione dei record per cui lo stipendio è
inferiore a 750
DELETE FROM Personale
WHERE stipendio < 750;
Cambiare il livello del dipendente con
matricola AA345
UPDATE Personale
SET Livello = 6
WHERE Matricola = ‘AA345’;
----------
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
FROM, separate dalla virgola e nella
clausola WHERE l’uguaglianza degli
attributi in comune.
Si utilizza la notazione punto per >
chiarezza:
 NomeTabella.NomeCampo
Self-join: congiunzione della tabella
con se stessa (ad es. si vuole
aggiungere un nuovo campo che
contiene valori di altri campi). Per
risolverlo si usa l’alias per il nome
della tabella, si definiscono cioè 2
nomi diversi (con AS) per la stessa
tabella
SELECT *
FROM Personale, Dipendenza
WHERE Filiale = CodFiliale
* con il segno = si chiama equi-join che in
Access si chiama inner-join
----------
Elenco per ciascun dipendente, del proprio
dirigente
SELECT Tab1.Cognome, Tab1.Nome,
Tab2.Cognome
FROM Personale AS Tab1, Personale As
Tab2
WHERE Tab1.Dirigente = Tab2.Matricola;

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

e Proiezione insieme
Clausola INTO
Consente di memorizzare il risultato dai dipendenti
dell’operazione in una tabella
SELECT * INTO NuovaTabella
FROM VecchiaTabella
WHERE Condizione
Comando INSERT INTO
Consente di aggiungere nuovi record dipendenti provenienti dalla tabella
provenienti da un’altra tabella
INSERT INTO VecchiaTabella
SELECT *
FROM NuovaTabella;
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’;
Creazione della tabella dei Dirigenti a partire
SELECT * INTO Manager
FROM Personale
WHERE Funzione = ‘Dirigente’;
Aggiunta nella tabella Personale di nuovi
NuoviAssunti
INSERT INTO Personale
SELECT *
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
Consente di ottenere i risultati
dell’interrogazione ordinati secondo i
valori di 1 o + colonne tra quelle
elencate nella Select. L’ordinamento è
crescente (ASC) per default quindi è
necessario specificarlo solo per il
decrescente (DESC).
SELECT Campo1, Campo2,…..
Campon
FROM Personale
ORDER BY Campo1, Campon;
Per gli ordinamenti complessi occorre
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
Con le f. di aggregazione (Sum, Count)
è possibile estendere la struttura del
comando Select con l’aggiunta di
Group By. Si crea quindi una riga
per ogni raggruppamento.
Se la Select non contiene 1 f. di
aggregazione i valori di
raggruppamento non vengono prodotti
in output. Tutti gli attributi che
compaiono accanto alla Select devono
essere inclusi nel Group By oppure
devono essere argomenti di 1 f. di
aggregazione.
Clausola HAVING
La Select con raggruppamento può
essere ampliata con Having: essa
sottopone al controllo di 1 o +
condizioni i gruppi creati con Group
By. La condizione dopo Having
normalmente controlla il valore
restituito dalle f. di aggregazione
(Count, Sum, Avg, ecc.). In genere,
quindi, Having viene usata insieme a
Group By: dopo che Group By ha
formato i raggruppamenti di righe,
Having serve a visualizzare le righe
che soddisfano alle condizioni scritte
accanto a Having. Se la Select
contiene la clausola Where, i valori
vengono raggruppati dopo aver
Elenco alfabetico dei dipendenti
SELECT Cognome, Nome, Nascita
FROM Personale
ORDER BY Cognome, Nome; *
* l’ordinamento è su 2 campi: a parità di
cognome i dipendenti vengono ordinati per
nome.
----------
Elenco dei dipendenti in ordine decrescente di
stipendio
SELECT Cognome, StipBase
FROM Personale
ORDER BY StipBase DESC, Cognome;
Elenco delle funzioni dei dipendenti con la
somma degli stipendi e il numero dei
dipendenti appartenenti alle diverse funzioni.
SELECT Funzione, SUM(StipBase), COUNT(*)
FROM Personale
GROUP BY Funzione;
----------
Elenco dei livelli esistenti tra i dipendenti che
svolgono la f. di Impiegato con il nr. di
dipendenti per ciascun livello.
SELECT Livello, COUNT(Livello) AS Conteggio
FROM Personale
WHERE Funzione = ‘Impiegato’
GROUP BY Livello;
Lista delle funzioni dei dipendenti con lo
stipendio medio per ciascuna funzione, dopo
aver raggruppato i dipendenti per funzione,
purché i dipendenti con quella funzione siano
+ di 2.
SELECT Funzione, AVG(StipBase)
FROM Personale
GROUP BY Funzione
HAVING COUNT(*) > 2;
----------
Elenco delle filiali con + di 10 impiegati
SELECT Filiale, COUNT(Filiale) AS Conteggio
FROM Personale
WHERE Funzione = ‘Impiegato’
GROUP BY Filiale
HAVING COUNT(*) > 10;
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
Il comando Select nidificato restituisce il
valore calcolato del valor medio degli
stipendi; questo nr. viene usato poi
nell’interrogazione principale per il
confronto con i valori dell’attributo
StipBase nel criterio di selezione delle
righe della tabella, scritto dopo Where.
La condizione scritta dopo Where
confronta il valore di un attributo con il
risultato di un altro comando Select. Una
subquery può restituire un valore
singolo, nessun valore oppure un
insieme di valori, ma deve comunque
avere una singola colonna o
espressione accanto alla sua Select.
L’interrogazione si ottiene con la congiunzione
tra le 2 tabelle Personale e Dipendenza,
realizzata attraverso l’attributo comune del
codice filiale; la condizione di selezione sulle
righe risultanti confronta lo stipendio di ogni
dipendente con il valore ottenuto da una
sottointerrogazione che restituisce 1 nr.,
ottenuto calcolando con la f. Max il valore
massimo tra tutti i valori di StipBase.
Predicato ANY
Indica che la subquery può restituire
zero, oppure 1, oppure 1 insieme di
valori, e che la condizione di ricerca è
vera se il confronto è vero per almeno 1
dei valori restituiti. La condizione di
ricerca è falsa se la subquery restituisce
1 insieme vuoto oppure se il confronto è
falso per ciascuno dei valori restituiti
dalla subquery.
Predicato ALL
Indica che la subquery può restituire
zero, oppure 1, oppure 1 insieme di
valori, e che la condizione di ricerca è
vera se il confronto è vero per ciascuno
dei valori restituiti. La condizione di
ricerca è falsa se il confronto è falso per
almeno 1 tra i valori restituiti dalla
subquery.
Ovviamente l’interrogazione con ALL
restituisce 1 nr inferiore di righe rispetto
a ANY.
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.
Elenco con cognome e nome dei dipendenti
che hanno lo stipendio inferiore allo
stipendio medio di tutti i dipendenti
SELECT Cognome, Nome
FROM Personale
WHERE StipBase <
(SELECT AVG(StipBase)
FROM Personale);
----------
Elenco dei dipendenti, elencati in ordine
alfabetico cognome, nome e descrizione
della filiale dove lavorano, per i quali lo
stipendio risulta uguale al valore massimo
tra tutti gli stipendi dei dipendenti con la
funzione di impiegato.
SELECT Cognome, Nome, Descrizione
FROM Personale, Dipendenza,
WHERE Filiale = CodFil AND
StipBase = (SELECT MAX(StipBase)
FROM Personale
WHERE Funzione =
‘Impiegato’)
ORDER BY Cognome, Nome;
Elenco dei dipendenti che non sono impiegati
e che hanno lo stipendio superiore a quello
di uno qualsiasi tra gli impiegati.
SELECT Cognome, Nome, Funzione
FROM Personale
WHERE Funzione <> ‘Impiegato’ AND
StipBase > ANY (SELECT StipBase
FROM Personale
WHERE Funzione =
‘Impiegato’);
Elenco di tutti di dipendenti che non sono
impiegati e che hanno lo stipendio superiore
a quello di tutti gli impiegati.
Basta sostituire ALL a ANY
SELECT Cognome, Nome, Funzione
FROM Personale
WHERE Funzione <> ‘Impiegato’ AND
StipBase > ALL (SELECT StipBase
FROM Personale
WHERE Funzione =
‘Impiegato’);
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