4T - 2 Modulo

(1)

Pagina 1 di 1

Brescianet

Sito didattico - Prof. Sechi Marco

http://lnx.brescianet.com/ScuolaForum2018/

4T - 2° Modulo

http://lnx.brescianet.com/ScuolaForum2018/viewtopic.php?f=3&t=17

4T - 2° Modulo

da e01692

appunti estemporanei scritti dal docente durante la lezione in classe

12/1/2019: 4T - 2° Modulo

da e01692

SQL structured query language

usato per interrogare ed aggiornare gli archivi SQL => a cosa serve

filtro sulle colonne

ricerche (filtro sulle righe) statistiche

aggiunte, eliminiazioni, modifiche di record creazione, modifica struttura delle tabelle

+ criteri sulla stessa riga nel disegnatore grafico delle

query corrisponde all'AND (ed anche) - se la condizione viene messa in oppure allora il filtro multiplo è connesso con l'operatore OR

SQL è case insensitive QuERY DI SELEZIONE

(estraggono i dati da un archivio) SELECT [Nome Campi separati dalla,]

FROM [Nomi tabelle dove ho i dati]

SELECT => definisce i campi da usare FROM => definisce le tabelle da usare

[] => da usarsi per i campi il cui nome ha spazi AS => rinomina il campo

18/1/2019: 4T - 2° Modulo

da e01692

SELECT [Nome Campi separati dalla,]

ORDER BY [Nome Campi separati dalla (desc,asc),]

ASC => ordinamenti crescenti (predefinito) DESC => ordinamenti decrescenti

Inviato: 12/01/2019, 8:00

Inviato: 18/01/2019, 10:59

(2)

Nelle qry i nomi che non corrispondono a campi vengono trattati come delle variabili. Pertanto il db chiede di valorizzarle e

poi userà nell'output dell'esecuzione della qry quel valore

SELECT[ragione sociale],[Dimmi che giorno è oggi che lo visualizzo] FROM Clienti order by idcliente SELECT [Nome Campi separati dalla,]

WHERE condizioni legate da OR o AND

ORDER BY [Nome Campi separati dalla (desc,asc),]

condizione => qualsiasi cosa che restituisce vero o falso

La query mostra le righe dove le condizioni dopo il where risultano vere SELECT * FROM CLIENTI

è equivalente a

SELECT * FROM CLIENTI WHERE TRUE

Condizione1 OR CONDIZIONE2 AND CONDIZIONE3 è equivalente a:

Condizione1 OR (CONDIZIONE2 AND CONDIZIONE3) perchè AND ha precedenza sull'or.

1+3*5

è equivalente a:

1+(3*5) ma non a:

(1+3)*5 -1+7

4O: rivedere esempio 7 4O - 17/1/2019

operatori di confronto => > < <= >= <> =

sono usati per costruire le condizioni semplici (che sappiamo restituiscono solo vero o falso) esempio

SELECT * FROM Clienti WHERE prov="bs"

operatori logici => OR, AND e NOT => usati per costruire condizioni complesse perchè AND ha precedenza sull'or.

NOT ha precedenza su tutto

Se analizzo i dati estratti da una qry vedo che l'or corrisponde all'unione dei sottoinsiemi che soddisfano le condizioni

elementari mentre l'and all'intersezione.

CondizioneA OR CondizioneB = Insieme(A) unione Insieme(b)

CondizioneA AND CondizioneB = Insieme(A) intersezione Insieme(b)

La differenza tra insiemi Insieme(A) meno Insieme(b) => CondizioneA AND NOT CondizioneB Tutte le costanti di testo devono essere evidenziate con " oppure ' - Esempio

SELECT[ragione sociale] FROM Clienti where Prov="bs"

oppure

SELECT[ragione sociale] FROM Clienti where Prov='bs'

(3)

le costanti temporali vanno racchiuse tra # => #01/18/2019# => si osservi il ribaltamento MM/GG Come rispondere ai quesiti dell'interrogazione/scritto

Esercizio 1 Costruire una query che consideri tutti i clienti di Brescia o di Bergamo e che hanno una data di registrazione

compresa tra il 2 giugno e il 31 dicembre 2001 SOLUZIONE

Iniziate con scrivere la sintassi generica di un comando di selezione SELECT

FROM WHERE ORDER BY

SELECT * <=non ho detto nulla su quali campi visualizzare FROM Clienti <= dice che voglio i clienti

WHERE (prov="BS" or prov="BG") AND (datarag<=#12/31/2001# and datarag>=#6/2/2001#

ORDER BY <= elimino questa direttiva : non ho richiesta di ordinamenti nella costruizione della clausola WHERE uso una visione di tipo insiemistico clienti di bresce UNIONE clienti di Bergamo => OR

Intervallo interno => AND

le 2 condizioni precedenti devono essere contemporaneamente soddisfatte => AND

SELECT [ragione sociale]

FROM clienti

WHERE fatturato<50 or fatturato>150 ORDER BY prov

SELECT * FROM Clienti [ragione sociale] like "A*" =>clienti che iniziano per A

SELECT * FROM Clienti [ragione sociale] like "*A*" =>clienti che contengono la lettera A SELECT * FROM Clienti [ragione sociale] like "*A" =>clienti che finiscono per A

Clienti bresciani o bergamaschi che iniziano entrambi per A SELECT * FROM CLIENTI

WHERE ([Ragione Sociale] like 'A*') AND ( (PROV='BS') OR (PROV='BG') )

Clienti bresciani che iniziano entrambi per A oppure tutti i bergamaschi SELECT * FROM CLIENTI

WHERE ([Ragione Sociale] like 'A*') AND (PROV='BS') OR (PROV='BG')

Il risultato diverso segue dalla diversa precedenza degli operatori AND e OR

25/1/2019 - 4T - 2° Modulo

da e01692

riprendere da SELECT * FROM Clienti

WHERE ([Ragione Sociale] like [dammi la lettera iniziale] & "*");

not a and b equivale a (not a) And b

Inviato: 25/01/2019, 11:02

(4)

1+2 => 3

"1" & "2" = "12"

SELECT * FROM Clienti WHERE [Ragione Sociale] like [dammi la lettera iniziale] & "*"

SELECT * FROM Clienti WHERE [Ragione Sociale] like "*" & [dammi la lettera contenuta] & "*"

qUERY CON CONCATENAZIONE

SELECT [ragione sociale] & " (" & prov & ")" FROM Clienti

SELECT AVG(FATTURATO) AS [MEDIA FATTURATO] FROM CLIENTI SELECT MAX(FATTURATO) AS [massimo FATTURATO] FROM CLIENTI SELECT min(FATTURATO) AS [mINIMO FATTURATO] FROM CLIENTI

deviazione standard => misura la media delle distanze dalla media dei valori => + alta + la varianza =>

maggiori oscillazioni

sui valori medi => maggiore inaffidabilità

4O - 19/1/2019

GROUP BY Elenco campi separati dalla, => elimina i duplicati (visualizzando una sola istanza) delle n-uple corrispondenti ai

campi scritti dopo la direttiva Le 2 query sono identiche:

SELECT Classe, Count(*) AS [Numero studenti]

FROM Studenti

WHERE Classe like "*T"

GROUP BY Classe HAVING (Count(*)>28) ORDER BY Classe;

e

SELECT Classe, Count(*) AS [Numero studenti]

FROM Studenti GROUP BY Classe HAVING (Count(*)>28) AND Classe like "*T"

ORDER BY Classe;

La 2° in realtà va evitata poichè molto lenta

Se uso solo HAVING il raggruppamento viene fatto sull'intero insieme (il group by è una delle operazioni + pesanti per un DB).

Se prima applico una direttiva WHERE riduco il set di record da raggruppare ottenendo risposte + veloci.

HAVING => usato se devo impostare filtri sulle funzioni statistiche WHERE => usato per implementare filtri sui campi

FUNZIONI PER I COMANDI SQL

ASC => restituisce il codice ascii del 1° char del campo passato come argomento SELECT asc(prov) AS [codice ascii prima lettera], prov from clienti

(5)

chr(65) => "A"

chr(Asc("A"))="A" ==> che chr è la funzione inversa di asc (restituisce il carattere corrispondente al codice ascii passato

come argomento)

DOMANDA DI ESEMPIO: Sintassi e semantica di LEFT Sintassi LEFT(stringa,N)

Semantica => estrae dal primo argomento che è una sequenza di char i primi N CHAR

DOMANDA : fornire il comando che estrae gli studenti che non hanno una matricola corretta (suppongo che quella corretta sia

lunga 6 char)

SELECT * from studenti where len(matricola)<>6

DOMANDA DI ESEMPIO: Sintassi e semantica di MID Sintassi LEFT(stringa,i,N)

Semantica => estrae dal primo argomento che è una sequenza di char partendo dall'i-esima posizione N CHAR.

Se il 3° argomento

è omesso da quel punto i-esimo in poi.

Nominativo="Sechi Marco"

left(Nominativo,instr(Nominativo," ")-1) => estrae il cognome

instr(Nominativo," ") => posizione dello spazio => 6 quindi la formula diventa:

left(Nominativo,6-1) = >

left(Nominativo,5) => "Sechi"

Nominativo1="Rosamunda Genoveffa"

left(Nominativo,instr(Nominativo," ")-1)

mid(Nominativo,instr(Nominativo," ")+1) => estrae il nome

DOMANDA => separare in 2 colonne distinte il cognome dal nome supponendo che le 2 componenti siano nel campo nominativo e non

esistono cognomi o nomi composti da + parole SELECT Nominativo,

Left(Nominativo,Instr(Nominativo," ")-1) AS COGNOME, Mid(Nominativo, Instr(Nominativo," ")+1) AS NOME FROM Studenti

1

domanda elencare senza duplicati la forma giuridica dei miei clienti Se la forma giuridica fosse sempre di 3 char => questa è corretta

SELECT RIGHT([ragione sociale],3) from clienti group by RIGHT([ragione sociale],3)

altrimenti userò instrrev che restituisce la posizione dell'ultima occorrenza del 2° argomento nel primo

(6)

SELECT mid([ragione sociale],instrrev([ragione sociale]," ")+1) from clienti group by mid([ragione sociale],instrrev([ragione

sociale]," ")+1)

4O 24/1/2019

fatto trim, lcase e ucase riprendere da space

26/1/2019 - 4T - 2° Modulo

da e01692

"12" < "9" => ordinamento lessicografico incompatibile con quello numerico

"0012" > "0009" => => ordinamento lessicografico compatibile con quello numerico matricola="9812"

STRING(5-len(Matricola),"0") & Matricola => "09812" => aggiunge un numero variabile di 0 iniziali fino ad arrivare a 5 cifre

VEdremo che è equivalente a format(12,"00000") STRING(N," ") = SPACE(N)

REPLACE("SONO ANDATO IN CLASSE ALLA PRIMA ORA"," ","") restituisce la stessa stringa senza spazi

SONOANDATOINCLASSEALLAPRIMAORA

REPLACE("SONO ANDATO IN CLASSE ALLA PRIMA ORA","CLASSE","AULA") sostituisce CLASSE CON AULA

1+2 => 3

cstr(1) + cstr(2) => "12" (se dico cstr(1) indico ad access che il dato va gestito come se fosse una stringa per cui il + da

operatore algebrico di somma diventa operatore di concatenazione

DOmanda => estrarre tutte le valutazioni con una componente decimale (non interi!) SELECT * FROM VOTI WHERE Voto<>Fix(Voto)

Fix => usata per determinare la presenza di valori non interi

cdate("1 febbraio 2019") => converte una stringa (che può avere un significato temporale) nella corrispondente rappresentazione interna per le date

Le funzioni di conversione Cdate, cstr, cdbl, clng servono per indicare ad access quale sia la reale semantica dei valori che

intendo trattare => operatori e ordinamento risultino adeguati ai ns scopi

Inviato: 26/01/2019, 8:01

(7)

ESEMPI DI USO DI FORMAT

SELECT Clienti.DataRag, Format([datarag],"dddd") AS [giorno della settimana]

FROM Clienti;

format(#12/02/2005 01.02.03#,"dddd, d mmmm yyyy \o\r\e hh.nn.ss") equivalente a

format(#12/02/2005 01.02.03#,"dddd, d mmmm yyyy ""ore"" hh.nn.ss")

Quindi la sequenza "" in una stringa viene interpretata come il carattere " e non come delimitatore di una costante di tipo

stringa

la sequenza """" rappresenta la stringa " poichè gli " estremi sono i delimitatori di stringa mentre i 2 " interni sono il "

Supponiamo di avere un campo genere con 2 per le femmine e 1 per i maschi. Con iif rendo + leggigile l'output SELECT *, iif(genere="1","Maschio","Femmina") FROM Studenti

isNull(argomento) => restituisce vero se l'argomento è nullo (mai valorizzato)

NZ(Argomento,ValoreSeNullo) equivale a

iif(isNull(Argomento),ValoreSeNullo,Argomento)

Domanda: Incrementare di 1 tutti i voti (immagino che abbia dato al massimo 9 e che il campo voto possa contenere anche dei

simboli non numerici esempio + (esercitazione ok) - (esercitazione non fatta) * (esercitazione errata) A (penalty), M (nota di

merito))

SELECT Voto+1 FROM Interrogazioni WHERE Isnumeric(voto)

Estrai i mesi di scatto da un campo testuale dataScatto che rappresenta il periodo dove ho effettuato lo scatto (ma può

contenere anche frasi del tipo Pasqua 2019 che per access non ha un'accezione cronologica) SELECT Format(DataScatto,"mmmm") AS MESEScatto FROM Foto WHERE IsDate(DataScatto)

2/2/2019 -: 4T - 2° Modulo

da e01692

Con le query multi tabellari valuto chi ha/non ha una proprietà multipla implementata in una tabella slave correlata.

Limiti delle query monotabellari applicate ad una tabella slave

1) non visualizzano il campo significativo poichè la tabella slave possiede il riferimento al campo chiave della tabella

master

2) non visualizzano i record della tabella master che non posseggono la proprietà multipla registrata nella

Inviato: 02/02/2019, 8:54

(8)

tabella slave

DIRECT JOIN

SELECT prodotti.IdProdotto, DescrProdotto, qta FROM prodotti, RigheFatture

where prodotti.IdProdotto=RigheFatture.IdProdotto

4O 2/2/ 2019 - 2 DOmande sull'esercitazione 3 (sabato prossimo)

DIRECT JOIN => usata per valutare chi possiede una certa proprietà fissata nella tabella slave Elenco dei prodotti venduti

SELECT prodotti.IdProdotto, DescrProdotto FROM prodotti, RigheFatture

where prodotti.IdProdotto=RigheFatture.IdProdotto GROUP BY prodotti.IdProdotto, DescrProdotto

8/2/2019 - 4T - 2° Modulo

da e01692

--- 4F domanda fatta

DOMANDA: Maschi e femmine in totale su una sola riga

SELECT sum(iif(genere="maschio",1,0)) as NrMaschi, sum(iif(genere="femmine",1,0)) as NrFemmine FROM Studenti

--- 4O 7/2/ 2019 (fare esempio 10)

select nominativo

from alunni left join voti on alunni.id=voti.idstud where voti.id is null group by

having order by

DOMANDA: Fatturato per cliente (che ha fatto almeno un acquisto) nel 2019 SELECT RagioneSociale, SUM(Importo) AS Fatturato

FROM Clienti, TestateFatture

WHERE Clienti.IDCliente=TestateFatture.idCliente AND Year(DataFattura)=2019 GROUP BY RagioneSociale

DOMANDA: nr di fatture per cliente compreso chi non ha acquistato

Questa risposta è errata (conteggiando le righe clienti che non hanno mai acquistato appaiono con NrFatt=1 SELECT Clienti.RagioneSociale, count(*) as nrfatt

FROM Clienti LEFT JOIN TestateFatture

ON Clienti.IdCliente = TestateFatture.idCliente GROUP BY Clienti.RagioneSociale;

Soluzione corretta

SELECT Clienti.RagioneSociale, sum(iif(isnull(idfattura),0,1)) as nrfatt FROM Clienti LEFT JOIN TestateFatture

ON Clienti.IdCliente = TestateFatture.idCliente GROUP BY Clienti.RagioneSociale;

Inviato: 08/02/2019, 11:01

(9)

DOMANDA: nr di fatture per cliente escluso chi non ha acquistato SELECT Clienti.RagioneSociale, count(*) as nrfatt

FROM Clienti, TestateFatture

WHERE Clienti.IdCliente = TestateFatture.idCliente GROUP BY Clienti.RagioneSociale;

DOMANDA: Elenco in chiaro dei prestiti dei libri con NomeUtente, NomeLibro e Dataprestito SELECT NomeUtente, NomeLibro, DataPrestito

FROM Utenti, Libri, Prestiti

WHERE Utenti.id=prestito.idutente AND Libro.id=prestito.idlibro

Relazione N-N

Utenti(id) 1->N (idUtente)Prestiti(idlibro) N<-Libri(id)

9/2/2019 - 4T - 2° Modulo

da e01692

RECORD DELLA TABELLA MASTER CHE NON HANNO RECORD COLLEGATI NELLA TABELLA SLAVE SELECT TabellaMaster.Campi

FROM TabellaMaster LEFT JOIN TabellaSlave

ON TabellaMaster.CampoChiave=TabellaSlave.ChiaveEsterna WHERE TabellaSlave.ChiaveEsterna is NULL

RECORD DELLA TABELLA MASTER CHE HANNO RECORD COLLEGATI NELLA TABELLA SLAVE SELECT TabellaMaster.Campi

FROM TabellaMaster, TabellaSlave

WHERE TabellaMaster.CampoChiave=TabellaSlave.ChiaveEsterna GROUP BY TabellaMaster.Campi

DIRECT JOIN

TUTTI I RECORD DI A CHE HANNO UN RECORD IN B LEFT JOIN

TUTTI I RECORD DI A E SOLO I RECORD COLLEGATI AD A IN B NO JOIN

OGNI RECORD DI A VIENE COMBINATO CON TUTTI I RECORD DI B

Quindi se in A ho N record e in B ne ho M ottengo con una Query di questo tipo. Ovvero tutte le possibili combinazioni di

record tra A e B. Avere a disposizione tutte le possibili combinazioni tra A e B mi permette di analizzare in modo incrociato

i dati alla ricerca di possibili relazioni tra le 2 tabelle SELECT * FROM TabellaA, TabellaB

Mostrate importazioni

ESERCITAZIONE 4 (Parte vocabolario)

Nr parole che iniziano per una determinata lettera e questo per ogni lettera dell'alfabeto SELECT LEFT(Italiana,1), count(*) AS Nr FROM Vocabolario

WHERE (ASC(LEFT(Italiana,1)) <=ASC("Z") AND ASC(LEFT(Italiana,1)) >=ASC("A") ) OR (ASC(LEFT(Italiana,1)) <=ASC("z") AND ASC(LEFT(Italiana,1)) >=ASC("a") )

GROUP BY LEFT(Italiana,1) ORDER BY LEFT(Italiana,1)

Inviato: 09/02/2019, 8:03

(10)

22/2/2019 - 4T - 2° Modulo

da e01692

SELECT ucase(left(italiana,1)), count(*) FROM Vocabolario

WHERE Ucase(left(italiana,1))>="A" AND Ucase(left(italiana,1))<="Z"

GROUP BY Ucase(left(italiana,1)) ORDER BY Ucase(left(italiana,1))

la E' appare ancora per cui per eliminarla devo scrivere SELECT ucase(left(italiana,1)) as iniziale, count(*) from vocabolario

where asc(ucase(left(italiana,1))) <=asc("Z") and asc(ucase(left(italiana,1))) >=asc("A") group by ucase(left(italiana,1))

ORDER BY Ucase(left(italiana,1))

4O 9/2/2019

FILE DI INTERSCAMBIO: formato portabile (leggibile da qualsiasi applicazione) usato per travasare dati da un sistema (esempio un sistema informativo aziendale) in un altro sistema (solitamente usato per le analisi statistiche).

tab-text => vedere http://www.brescianet.com/appunti/db/im ... ormati.pdf slide 6 4F 14/2/2019

Traduttore da ita => fra,uk

SELECT francese, inglese from vocabolario where italiana=[parola italica da tradurre]

Nr di char totali presenti nel vocabolario SELECT sum(len(italiana)) from vocabolario;

Nr di char totali presenti nel vocabolario senza spazi

SELECT sum(len(replace(italiana, " ", ""))) from vocabolario;

Distribuzione nr parole che iniziano e finiscono per la stessa lettera e questo per ogni lettera

SELECT Left(italiana,1) AS lettera, count(*) as nr FROM VOCABOLARIO

WHERE (((Left([italiana],1))=Right([Italiana],1))) group by Left(italiana,1)

Distribuzione per lunghezza

SELECT Len(italiana), count(*) as nr FROM VOCABOLARIO

group by Len(italiana) order by Len(italiana)

Distribuzione per lunghezza (non devo distinguere oltre il 25) RISPOSTA ERRATA => usa l'ordinamento lessicografico

SELECT iif(Len(italiana)>25,">25",Len(italiana) ), count(*) as nr FROM VOCABOLARIO

Inviato: 22/02/2019, 11:01

(11)

group by iif(Len(italiana)>25,">25",Len(italiana) ) order by iif(Len(italiana)>25,">25",Len(italiana) ) corretta

SELECT iif(Len(italiana)>25,">25",Len(italiana) ), count(*) as nr FROM VOCABOLARIO

group by iif(Len(italiana)>25,">25",Len(italiana) ), iif(Len(italiana)>25,26,Len(italiana) )

order by iif(Len(italiana)>25,26,Len(italiana) ) RISOLVERE:

h) Costruire il comando SQL che restituisce quante volte il carattere "a" si presenta nel vocabolario italiano (utilizzare la funzione VBA Replace se uso office2000 o superiore) Suggerimento => lunghezza(parola)-lunghezza(parolasenzaA) => nr di "a" nella parola

spiegato Formazione del Brescia del 3 novembre 1998 4F - 21/2/2019

Massimo numero di giorni di presenza nella stessa squadra select top 1 Nomesquadra, sum(alladata-dalladata) as nrgg from formazioni

Group by NomeSquadra, idcalciatore ORDER BY sum(alladata-dalladata) desc 4O - 14/2/2019

23/2/2019: 4T - 2° Modulo

da e01692

QUERY DI CREAZIONE TABELLA DA SELEZIONE SELECT CAMPI

INTO NomeNuovaTabella FROM...

Il risultato non è una visualizzazione dei dati estratti ma la creazione di una nuova tabella con all'interno i dati estratti.

Questo tipo di query è usata per creare dei dati intermedi su cui far appoggiare successive query in una analisi statistica complessa di un fenomeno registrato all'interno del DB.

Divido un problema complesso in tante sottoquery una in sequenza con l'altra

QUERY DI ACCODAMENTO

INSERT INTO NomeTabella (elenco campi) SELECT (elenco campi)

FROM ... (normalissima query di selezione)

Questa query invece di mostrare a video i dati estratti li accoda alla tabella indicata dopo la direttiva INTO.

Una QUERY DI CREAZIONE TABELLA DA SELEZIONE è equivalente ad una QUERY DI CREAZIONE TABELLA + UNA QUERY DI ACCODAMENTO

ESEMPIO:

Inviato: 23/02/2019, 7:59

(12)

---

QUERY DI CREAZIONE TABELLA DA SELEZIONE ==>

SELECT UCase(Left([Italiana],1)) AS Lettera INTO Alfabeto FROM Vocabolario

WHERE (((Asc(UCase(Left([Italiana],1))))<=Asc("Z") And (Asc(UCase(Left([Italiana],1))))>=Asc("A"))) GROUP BY UCase(Left([Italiana],1));

QUERY DI CREAZIONE TABELLA + UNA QUERY DI ACCODAMENTO Create table Alfabeto (Lettera TEXT(1))

INSERT INTO Alfabeto ( Lettera )

SELECT UCase(Left([Italiana],1)) AS Lettera FROM Vocabolario

---

Query di inserimento record singolo

DOMANDA1 => inserisci il tuo nominativo, data di nascita e eta nella tabella studenti.

La tabella studenti ha un campo chiave id di tipo contatore INSERT INTO Studenti (nominativo, natoil, eta)

VALUES ("Rossi Mario", #12/31/2000#,19)

La tabella studenti ha un campo chiave id di tipo intero lungo INSERT INTO Studenti (id, nominativo, natoil, eta)

VALUES (199, "Rossi Mario", #12/31/2000#,19)

1/3/2019: 4T - 2° Modulo

da e01692

QUERY DI CREAZIONE TABELLA DA SELEZIONE SELECT CAMPI

INTO NomeNuovaTabella FROM...

Il risultato non è una visualizzazione dei dati estratti ma la creazione di una nuova tabella con all'interno i dati estratti.

Questo tipo di query è usata per creare dei dati intermedi su cui far appoggiare successive query in una analisi statistica complessa di un fenomeno registrato all'interno del DB. Divido un problema complesso in tante sottoquery una in sequenza con l'altra

QUERY DI ACCODAMENTO

INSERT INTO NomeTabella (elenco campi) SELECT (elenco campi)

FROM ... (normalissima query di selezione)

Questa query invece di mostrare a video i dati estratti li accoda alla tabella indicata dopo la direttiva INTO.

Una QUERY DI CREAZIONE TABELLA DA SELEZIONE è equivalente ad una QUERY DI CREAZIONE TABELLA + UNA QUERY DI ACCODAMENTO

ESEMPIO:

---

Inviato: 01/03/2019, 10:58

(13)

QUERY DI CREAZIONE TABELLA DA SELEZIONE ==>

SELECT UCase(Left([Italiana],1)) AS Lettera INTO Alfabeto FROM Vocabolario

QUERY DI CREAZIONE TABELLA + UNA QUERY DI ACCODAMENTO Create table Alfabeto (Lettera TEXT(1))

INSERT INTO Alfabeto ( Lettera )

SELECT UCase(Left([Italiana],1)) AS Lettera FROM Vocabolario

---

Query di inserimento record singolo

La tabella studenti ha un campo chiave id di tipo contatore INSERT INTO Studenti (nominativo, natoil, eta)

VALUES ("Rossi Mario", #12/31/2000#,19)

La tabella studenti ha un campo chiave id di tipo intero lungo INSERT INTO Studenti (id, nominativo, natoil, eta)

VALUES (199, "Rossi Mario", #12/31/2000#,19)

QUERY VISTA DURANTE LA LEZIONE SELECT Italiana

from vocabolario

where instr(Italiana,"A")>0 equivalente a:

SELECT Italiana from vocabolario

where Italiana like "*A*"

4T - 23/2/2019 riprendere dalle query di eliminazione

CREATE INDEX => comando sql che crea un indice SAPERE di questo comando il significato di WITH IGNORE NULL (perchè è utile: spiegato) WITH DISALLOW NULL (simile al contraint not null) UNIQUE (NON RICHIESTA - vista già nelle create table) WITH PRIMARY (NON RICHIESTA - vista già nelle create table) DOMANDA: Cancellare gli studenti che si sono ritirati

DELETE Studenti WHERE Ritirati=true 4F 23/2/2019

DOMANDA => manda in 5T gli studenti modello di 4T che hanno superato l'anno scolastico UPDATE Studenti

SET Classe="5T"

WHERE Classe="4T"

AND Promosso=true

(14)

DOMANDA => aumenta del 10% il prezzo di listino dei casalinghi UPDATE Listino

SET Prezzo=Prezzo*1,1

WHERE Tipologia="Casalinghi"

4O - 23/2/2019 Query di unione

QUERYSelezione1 UNION [ALL] QUERYSelezione2 ... UNION [ALL] QUERYSelezioneN [] => indicano che è opzionale

con UNION ALL tutti i record delle # tabelle coinvolte saranno visualizzati anche se presenti in + istanze.

senza ALL i record duplicati nelle # tabelle coinvolte verranno visualizzati in una sola istanza. Quindi è + lenta come query perchè prevede delle ricerche (dei duplicati!)

QUERYSelezione1 UNION QUERYSelezione2 ... UNION QUERYSelezioneN DOMANDA: elenco degli studenti che non sono mai stati interrogati SELECT * FROM STUDENTI LEFT JOIN Interrogazioni ON

Studenti.id=Interrogazioni.idstudente where Interrogazioni.idstudente is null

SELECT * FROM Studenti id NOT IN (SELECT idStudenti FROM INTERROGAZIONI) SELECT * FROM Studenti id <>ALL (SELECT idStudenti FROM INTERROGAZIONI)

DOMANDA: elenco degli studenti che sono stati interrogati SELECT Nominativo FROM STUDENTI , Interrogazioni WHERE Studenti.id=Interrogazioni.idstudente

GROUP BY Nominativo

Con le sottoquery (vanno usate solo su mia esplicita richiesta nel quesito) SELECT * FROM Studenti id IN (SELECT idStudenti FROM INTERROGAZIONI) SELECT * FROM Studenti id =ANY (SELECT idStudenti FROM INTERROGAZIONI)

le query fulltext sono tipiche dei motori di ricerca - effettuano la selezione in modo trasversale su + campi della tabella senza che vi sia una esplicita clausola where per ogni campo dove cercare.

4F 26/3/2019 fare db server

server => macchina che eroga un servizio (esempio un server WEB)

client => macchina che usufruisce di un servizio messo a disposizione da un server

Nei DB server manca completamente la sezione che mi consente di creare maschere di input o report (demandata ai client). Di solito i client dei db server sono pagine WEB (si pensi al registro della ns scuola).

Mentre access ha i pannelli Tabelle (definizione struttura) - Query (estrazione dati) - forms (maschere semplicate per l'utente per l'alimentazione degli archivi) - Report (presentazione umanamente leggibile dei dati) - moduli (programmazione) nei DB Server avremo solo i primi 2 + una programmazione basata su SQL (Stored procedure)

DOMANDA => dimmi 3 DB Server : MYSQL (gratuito - acquisito anch'esso dalla oracle) MS SQL Server (a pagamento della microsoft) e ORACLE (DB + potente)

(15)

2/3/2019 - 4T - 2° Modulo

da e01692

formato file => come registra l'informazione in un file un prg

I files di interscambio devono essere scritti in un formato portabile.

IMPORTAZIONE => lettura di formati non nativi

formati nativi => modalità di registrazione predefinita (equivalente della lingua madre per un uomo). I formati nativi non vengono mai importati ma letti da un'applicazione.

formato aperto => caratteristiche di registrazione delle info ben documentate ed accessibili a chiunque - solitamente sono portabili (è facile costruire un modulo di importazione) formato chiuso => le modalità di registrazione delle info è ignota e viene tenuta segreta.

leggibile solo da parte di prg costruiti da chi l'ha inventato. un formato chiuso non è portabile.

formato proprietario (può essere chiuso o aperto) : vincolato da brevetti che ne limitano l'utilizzo. Solitamente è richiesto il pagamento di un fee per il suo utilizzo.

file testuali => file contenenti sequenza di char ascii - leggibile con notepad file binari => tutto ciò che non è testuale (char ascii). Non usa la codifica ascii ma

sequenze di byte (esempio un file binario potrebbe essere una sequenza di numeri codificati in floating point o in rappresentazione posizionale in base 2)

FILE DELIMITED => file testuali dove ho un separatore per i campi e un separatore per i record.

Bene dalla slide 5 => fino alla 11

TAB-TEXT (delimited) => campi separati dal tab e record dall'invio (CRLF => ascii 13 + 10) DOMANDA => costruire un file tab-text contenente 2 record e 3 campi di vs fantasia con intestazioni

Matricola->Nominativo->Classe<-| (invio) 1->Rossi Mario->4T<-|

2->Verdi Rosa->4F<-|

CSV (delimited) => campi separati dal virgola (o e record dall'invio (CRLF => ascii 13 + 10)

DOMANDA => costruire un file csv contenente 2 record e 3 campi di vs fantasia con intestazioni

Matricola,Nominativo,Voto<-| (invio) 1,"Rossi Mario",9<-|

2,"Verdi Rosa",10<-|

oppure

Inviato: 02/03/2019, 8:02

(16)

Tutti gli orari sono UTC Pagina 1 di 1

Matricola;Nominativo;Voto<-| (invio) 1;"Rossi Mario";9<-|

2;"Verdi Rosa";10<-|

il " è usato per indicare i campi testuali e per evitare errate interpretazioni della virgola o del ;

esempio:

Nominativo,Indirizzo,telefono<-|

"Marco Rosi","via non saprei,12","022932293"<-|

"Maria Ughi","Piazza Tila, 123","027899893"<-|

DOMANDA => costruire un file fixed format contenente 2 record e 3 campi di vs fantasia fornendo anche il tracciato - senza intestazioni

TRACCIATO =>

dal carattere 1 al 3 => matricola dal carattere 4 al 15 => nominativo dal carattere 16 al 20 => classe 0---1---2---3

123456789012345678901234567890 1Rossi Mario 4Tsa <-|

11Verdi Ugo 4FLin<-|

L'elevata diffusione dei files XLS e ACCDB fa si che nonostante siano formati binari e proprietari vengano comunque utilizzati come formati di interscambio

odbc => spiegato (sorta di driver per DB che traduce comandi dell'applicazione client (front end app) in comandi specifici dell'applicazione server (solitamente un db server))

XML => formato di interscambio testuale molto diffuso. Si basa sulle modalità simili viste per HTML ma i tag sono di fantasia. Il vantaggio di questo formato è la possibilità di definire una semantica (significato) dei dati e anche una gerarchia.

DOMANDA => costruire un file XML contenente 2 record e 3 campi di vs fantasia

<NOMINATIVO>Rossi mario</NOMINATIVO>

<ESITO>Promosso</ESITO>

</STUDENTE>

<ESITO>Bocciato</ESITO>

</STUDENTE>

</STUDENTI>