A volte può essere necessario combinare i record di una tabella o query con record di una o più tabelle in un unico risultato. Questa è la funzione di una query di unione in Access.
Per comprendere appieno le query di unione, è innanzitutto necessario conoscere la progettazione di query di selezione di base in Access. Per altre informazioni sulla progettazione di query di selezione, vedere Creare una query di selezione semplice.
Esaminare un esempio di query di unione funzionante
Se non è mai stata creata una query di unione, può essere utile analizzare prima un esempio funzionante nel modello Northwind di Access. È possibile cercare il modello di esempio Northwind nella pagina introduttiva di Access selezionando Nuovo file>. È anche possibile scaricare una copia direttamente dal modello di esempio Northwind.
Dopo che Access ha aperto il database Northwind, chiudere la finestra di dialogo di accesso visualizzata e quindi espandere il riquadro di spostamento. Selezionare la parte superiore del riquadro di spostamento e quindi selezionare Tipo di oggetto per organizzare tutti gli oggetti di database per tipo. Espandere quindi il gruppo Query per visualizzare una query denominata Transazioni prodotto.
Le query di unione sono facili da distinguere dagli altri oggetti di query perché hanno una speciale icona che somiglia a due cerchi interconnessi che rappresenta l'unione di due set in un set unico:
A differenza delle normali query di selezione e azione, le tabelle non sono correlate in una query di unione. Questo significa che non è possibile usare Progettazione query grafiche di Access per creare o modificare query di unione. Se si apre una query di unione dal riquadro di spostamento, Access la apre e visualizza i risultati in visualizzazione Foglio dati. In Visualizzazioni nella scheda Home si noti che la visualizzazione Struttura non è disponibile quando si usano query di unione. È possibile passare solo dalla visualizzazione Foglio dati alla visualizzazione SQL e dall'altra.
Per continuare lo studio di questo esempio di query di unione, fare clic suVisualizzazione SQLVisualizzazioni>Home> per visualizzare la SQL sintassi che lo definisce. In questa illustrazione è stata aggiunta una spaziatura aggiuntiva in SQL modo da poter vedere facilmente le varie parti che compongono una query di unione.
Esaminiamo in dettaglio la SQL sintassi di questa query di unione dal database Northwind:
SELECT [Product ID], [Order Date], [Company Name], [Transaction], [Quantity]
FROM [Product Orders]
UNION
SELECT [Product ID], [Creation Date], [Company Name], [Transaction], [Quantity]
FROM [Product Purchases]
ORDER BY [Order Date] DESC;
La prima e la terza parte dell'istruzione SQL sono essenzialmente due query di selezione. Queste query recuperano due diversi set di record, uno dalla tabella Ordini prodotti e l'altro dalla tabella Acquisti prodotti.
La seconda parte di questa SQL istruzione è la UNION parola chiave, che indica ad Access di combinare questi due set di record.
L'ultima parte di questa SQL istruzione determina l'ordine dei record combinati usando un'istruzione ORDER BY . In questo esempio, Access ordina tutti i record in base al campo Data ordine in ordine decrescente.
Nota
Le query di unione sono sempre di sola lettura in Access. Non si può modificare alcun valore nella visualizzazione Foglio dati.
Creare una query di unione creando e combinando le query di selezione
Anche se è possibile creare una query di unione scrivendo la SQL sintassi direttamente nella visualizzazione SQL, potrebbe risultare più semplice crearla in parti con query di selezione. È possibile quindi copiare e incollare le parti SQL in una query di unione combinata.
Se si preferisce guardare un esempio invece di leggere la procedura, vedere la sezione successiva Guardare un esempio di creazione di una query di unione.
- Nel gruppo Query della scheda Crea fare clic su Struttura query.
- Fare doppio clic sulla tabella che contiene i campi da includere. La tabella viene aggiunta alla finestra di struttura della query.
- Nella finestra di struttura della query fare doppio clic su ognuno dei campi che si desidera includere. Mentre si selezionano i campi, assicurarsi di aggiungere lo stesso numero di campi, nello stesso ordine, di quelli aggiunti alle altre query di selezione. Prestare attenzione ai tipi di dati dei campi e verificare che siano compatibili con i tipi di dati dei campi nella stessa posizione delle altre query da combinare. Ad esempio, se per la prima query di selezione si utilizzano cinque campi, il primo dei quali contiene dati di tipo data/ora, assicurarsi che tutte le altre query di selezione da combinare contengano cinque campi e che i dati nel primo di essi siano di tipo data/ora e così via.
- È possibile aggiungere facoltativamente criteri ai campi digitando le espressioni appropriate nella riga Criteri della griglia dei campi.
- Dopo avere aggiunto i campi e i criteri dei campi, eseguire la query di selezione ed esaminarne l'output. Nel gruppo Risultati della scheda Struttura fare clic su Esegui.
- Passare alla visualizzazione Struttura della query.
- Salvare la query di selezione e lasciarla aperta.
- Ripetere questa procedura per ognuna delle query di selezione che si desidera combinare.
Dopo aver creato le query di selezione, è il momento di combinarle. In questo passaggio si crea la query di unione copiando e incollando le SQL istruzioni.
- Nel gruppo Query della scheda Crea fare clic su Struttura query.
- Nel gruppo Query della scheda Struttura fare clic su Unione. Access nasconde la finestra di struttura della query e mostra la scheda dell'oggetto Visualizzazione SQL . A questo punto, la scheda è vuota.
- Fare clic sulla scheda della prima query di selezione che si desidera combinare nella query di unione.
- Nella scheda Home fare clic su Visualizza>visualizzazione SQL.
- Copiare l'istruzione
SQLper la query di selezione. Fare clic sulla scheda della query di unione che si è iniziato a creare in precedenza. - Incollare l'istruzione
SQLper la query di selezione nella scheda dell'oggetto Visualizzazione SQL della query di unione. - Eliminare il punto e virgola (
;) alla fine dell'istruzione della query di selezioneSQL. - Premere INVIO per spostare il cursore verso il basso di una riga e quindi digitare
UNIONsulla nuova riga. - Fare clic sulla scheda della successiva query di selezione che si desidera combinare nella query di unione.
- Ripetere i passaggi da 5 a 10 finché non sono state copiate e incollate tutte le istruzioni per le
SQLquery di selezione nella finestra Visualizzazione SQL della query di unione. Non eliminare il punto e virgola o digitare nulla dopo l'istruzioneSQLper l'ultima query di selezione. - Nel gruppo Risultati della scheda Struttura fare clic su Esegui.
I risultati della query di unione verranno visualizzati nella visualizzazione Foglio dati.
Guardare un esempio di creazione di una query di unione
Ecco un esempio che è possibile ricreare nel database di esempio Northwind. Questa query di unione raccoglie i nomi delle persone dalla tabella Clienti e li combina con i nomi delle persone della tabella Fornitori. Per proseguire, usare la procedura nella copia del database di esempio Northwind.
Ecco i passaggi necessari per compilare questo esempio:
Creare due query di selezione, denominate Query1 e Query2 usando come origini dati, rispettivamente, le tabelle Clienti e Fornitori. Usare i campi Nome e Cognome come valori visualizzati.
Creare una nuova query denominata Query3, inizialmente senza alcuna origine dati e quindi scegliere il comando Unione nella scheda Struttura per trasformare questa query in una query di unione.
Copiare e incollare le istruzioni SQL da Query1 e Query2 a Query3. Assicurarsi di rimuovere il punto e virgola aggiuntivo e aggiungere la
UNIONparola chiave. È quindi possibile verificare i risultati nella visualizzazione Foglio dati.Aggiungere una clausola di ordinamento a una delle query e quindi incollare l'istruzione
ORDER BYnella query di unione in visualizzazione SQL. In Query3, la query di unione, quando l'ordinamento sta per essere aggiunto, vengono rimossi prima i punti e virgola e poi il nome della tabella dai nomi dei campi.L'ultimo
SQLche combina e ordina i nomi per questo esempio di query di unione è il seguente:SELECT Customers.Company, Customers.[Last Name], Customers.[First Name] FROM Customers UNION SELECT Suppliers.Company, Suppliers.[Last Name], Suppliers.[First Name] FROM Suppliers ORDER BY [Last Name], [First Name];
Se si ha molta familiarità con la sintassi di scrittura SQL , è possibile scrivere un'istruzione personalizzata SQL per la query di unione direttamente in visualizzazione SQL. Tuttavia, può risultare utile seguire l'approccio di copiare e incollare la sintassi SQL da altri oggetti di query. Ogni query può essere molto più complessa dei semplici esempio di query di selezione riportati qui. È opportuno creare e testare ogni query con attenzione prima di combinarle nella query di unione. Se la query di unione non viene eseguita, è possibile modificare singolarmente le query finché non viene eseguita, quindi ricreare la query di unione con la sintassi corretta.
Esaminare le sezioni rimanenti di questo articolo per altri suggerimenti e consigli sull'uso delle query di unione.
Combinare tre o più tabelle o query in una query di unione
Nell'esempio della sezione precedente che usa il database Northwind, i dati provenienti solo da due tabelle vengono combinati. Tuttavia, è possibile combinare tre o più tabelle in modo molto semplice in una query di unione. Ad esempio, sulla base dell'esempio precedente, è consigliabile includere anche i nomi dei dipendenti nell'output della query. È possibile eseguire l'attività aggiungendo una terza query e combinando l'istruzione SQL precedente con una parola chiave UNION supplementare come questa:
SELECT Customers.Company, Customers.[Last Name], Customers.[First Name]
FROM Customers
UNION
SELECT Suppliers.Company, Suppliers.[Last Name], Suppliers.[First Name]
FROM Suppliers
UNION
SELECT Employees.Company, Employees.[Last Name], Employees.[First Name]
FROM Employees
ORDER BY [Last Name], [First Name];
Quando si visualizza il risultato nella visualizzazione Foglio dati, tutti i dipendenti verranno elencati con il nome della società di esempio, che probabilmente non è molto utile. Se si vuole che tale campo mostri se una persona è un dipendente interno, un fornitore o un cliente, è possibile includere un valore fisso al posto del nome della società. Ecco l'aspetto:SQL
SELECT "Customer" As Employment, Customers.[Last Name], Customers.[First Name]
FROM Customers
UNION
SELECT "Supplier" As Employment, Suppliers.[Last Name], Suppliers.[First Name]
FROM Suppliers
UNION
SELECT "In-house" As Employment, Employees.[Last Name], Employees.[First Name]
FROM Employees
ORDER BY [Last Name], [First Name];
Ecco come verrà visualizzato il risultato nella visualizzazione Foglio dati. Access mostra questi cinque record di esempio:
| Lavoro | Cognome | Nome |
|---|---|---|
| Interno | Leonetti | Adriana |
| Interno | Bruno | Filippa |
| Fornitore | Iadanza | Gerolamo |
| Cliente | Romani | Raffaele |
| Cliente | Esposito | Quarantino |
È possibile ridurre ulteriormente la query perché Access legge i nomi dei campi di output solo dalla prima query in una query di unione. Qui, l'output dalla seconda e dalla terza sezione della query viene rimosso:
SELECT "Customer" As Employment, [Last Name], [First Name]
FROM Customers
UNION
SELECT "Supplier", [Last Name], [First Name]
FROM Suppliers
UNION
SELECT "In-house", [Last Name], [First Name]
FROM Employees
ORDER BY [Last Name], [First Name];
Applicazione di filtri nelle query di unione
In una query di unione di Access l'ordinamento è consentito una sola volta, ma è possibile filtrare ogni query singolarmente. Sulla base della query di unione della sezione precedente, ecco un esempio che filtra ogni query aggiungendo una WHERE clausola.
SELECT "Customer" As Employment, Customers.[Last Name], Customers.[First Name]
FROM Customers
WHERE [State/Province] = "UT"
UNION
SELECT "Supplier", [Last Name], [First Name]
FROM Suppliers
WHERE [Job Title] = "Sales Manager"
UNION
SELECT "In-house", Employees.[Last Name], Employees.[First Name]
FROM Employees
WHERE City = "Seattle"
ORDER BY [Last Name], [First Name];
Passare alla visualizzazione Foglio dati per visualizzare risultati simili al seguente:
| Lavoro | Cognome | Nome |
|---|---|---|
| Fornitore | Milani | Martina |
| Interno | Leonetti | Adriana |
| Cliente | Romani | Benito |
| Interno | Hellung-Larsen | Anne |
| Fornitore | Baresi | Rebecca |
| Cliente | Sabbatini | Benigno |
| Fornitore | Longo | Gerardino |
| Fornitore | Lombardi | Pietro |
| Interno | Barese | Carmelo |
| Fornitore | Siciliano | Fabiola |
| Interno | Capon | Cataldo |
Combinare i tipi di dati
Se le query da unire sono molto diverse, potrebbe verificarsi una situazione in cui un campo di output deve combinare dati di tipi di dati diversi. In questo caso, la query di unione spesso restituirà i risultati come tipo di dati di testo perché questo tipo di dati può contenere sia testo che numeri.
Per comprendere il funzionamento, verrà usata la query di unione Transazioni prodotto nel database di esempio Northwind. Aprire il database di esempio e quindi aprire la query Transazioni prodotto nella visualizzazione Foglio dati. Gli ultimi dieci record dovrebbero essere simili a questo output:
| ID prodotto | Data ordine | Nome società | Transazione | Quantità |
|---|---|---|---|---|
| 77 | 22/01/2006 | Fornitore B | Acquisto | 60 |
| 80 | 22/01/2006 | Fornitore D | Acquisto | 75 |
| 81 | 22/01/2006 | Fornitore A | Acquisto | 125 |
| 81 | 22/01/2006 | Fornitore A | Acquisto | 200 |
| 7 | 20/01/2006 | Società D | Vendita | 10 |
| 51 | 20/01/2006 | Società D | Vendita | 10 |
| 80 | 20/01/2006 | Società D | Vendita | 10 |
| 34 | 15/01/2006 | Società AA | Vendita | 100 |
| 80 | 15/01/2006 | Società AA | Vendita | 30 |
Si supponga di voler dividere il campo Quantità in due campi: Acquista e Vendi. Si supponga anche di voler ottenere un valore zero fisso per il campo senza valore. Ecco l'aspetto della SQL query di unione:
SELECT [Product ID], [Order Date], [Company Name], [Transaction], 0 As Buy, [Quantity] As Sell
FROM [Product Orders]
UNION
SELECT [Product ID], [Creation Date], [Company Name], [Transaction], [Quantity] As Buy, 0 As Sell
FROM [Product Purchases]
ORDER BY [Order Date] DESC;
Se si passa alla visualizzazione Foglio dati, verranno visualizzati gli ultime dieci record che ora sono visualizzati come segue:
| ID prodotto | Data ordine | Nome società | Transazione | Acquisto | Vendita |
|---|---|---|---|---|---|
| 74 | 22/01/2006 | Fornitore B | Acquisto | 20 | 0 |
| 77 | 22/01/2006 | Fornitore B | Acquisto | 60 | 0 |
| 80 | 22/01/2006 | Fornitore D | Acquisto | 75 | 0 |
| 81 | 22/01/2006 | Fornitore A | Acquisto | 125 | 0 |
| 81 | 22/01/2006 | Fornitore A | Acquisto | 200 | 0 |
| 7 | 20/01/2006 | Società D | Vendita | 0 | 10 |
| 51 | 20/01/2006 | Società D | Vendita | 0 | 10 |
| 80 | 20/01/2006 | Società D | Vendita | 0 | 10 |
| 34 | 15/01/2006 | Società AA | Vendita | 0 | 100 |
| 80 | 15/01/2006 | Società AA | Vendita | 0 | 30 |
Proseguendo con questo esempio, cosa fare se si vuole che i campi con valori zero siano vuoti? È possibile modificare l'impostazione SQL in modo che non visualizzi niente invece di zero aggiungendo la Null parola chiave, come illustrato di seguito:
SELECT [Product ID], [Order Date], [Company Name], [Transaction], Null As Buy, [Quantity] As Sell
FROM [Product Orders]
UNION
SELECT [Product ID], [Creation Date], [Company Name], [Transaction], [Quantity] As Buy, Null As Sell
FROM [Product Purchases]
ORDER BY [Order Date] DESC;
Tuttavia, come si può osservare passando alla visualizzazione Foglio dati, viene restituito un risultato imprevisto. Nella colonna Acquisto sono deselezionati tutti i campi:
| ID prodotto | Data ordine | Nome società | Transazione | Acquisto | Vendita |
|---|---|---|---|---|---|
| 74 | 22/01/2006 | Fornitore B | Acquisto | ||
| 77 | 22/01/2006 | Fornitore B | Acquisto | ||
| 80 | 22/01/2006 | Fornitore D | Acquisto | ||
| 81 | 22/01/2006 | Fornitore A | Acquisto | ||
| 81 | 22/01/2006 | Fornitore A | Acquisto | ||
| 7 | 20/01/2006 | Società D | Vendita | 10 | |
| 51 | 20/01/2006 | Società D | Vendita | 10 | |
| 80 | 20/01/2006 | Società D | Vendita | 10 | |
| 34 | 15/01/2006 | Società AA | Vendita | 100 | |
| 80 | 15/01/2006 | Società AA | Vendita | 30 |
Il motivo per cui accade è che Access determina i tipi di dati dei campi dalla prima query. In questo esempio Null non è un numero.
Cosa succede se si prova a inserire una stringa vuota per il valore vuoto dei campi? Il SQL valore per questo tentativo potrebbe essere simile al seguente:
SELECT [Product ID], [Order Date], [Company Name], [Transaction], "" As Buy, [Quantity] As Sell
FROM [Product Orders]
UNION
SELECT [Product ID], [Creation Date], [Company Name], [Transaction], [Quantity] As Buy, "" As Sell
FROM [Product Purchases]
ORDER BY [Order Date] DESC;
Quando si passa alla visualizzazione Foglio dati, Access recupera i valori di acquisto, ma convertiti in valori di testo. È possibile stabilire che sono valori di testo perché sono allineati a sinistra nella visualizzazione Foglio dati. Una stringa vuota nella prima query non è un numero, ecco perché vengono visualizzati questi risultati. Si noterà che anche i valori Vendita vengono convertiti in testo perché i record di acquisto contengono una stringa vuota.
| ID prodotto | Data ordine | Nome società | Transazione | Acquisto | Vendita |
|---|---|---|---|---|---|
| 74 | 22/01/2006 | Fornitore B | Acquisto | 20 | |
| 77 | 22/01/2006 | Fornitore B | Acquisto | 60 | |
| 80 | 22/01/2006 | Fornitore D | Acquisto | 75 | |
| 81 | 22/01/2006 | Fornitore A | Acquisto | 125 | |
| 81 | 22/01/2006 | Fornitore A | Acquisto | 200 | |
| 7 | 20/01/2006 | Società D | Vendita | 10 | |
| 51 | 20/01/2006 | Società D | Vendita | 10 | |
| 80 | 20/01/2006 | Società D | Vendita | 10 | |
| 34 | 15/01/2006 | Società AA | Vendita | 100 | |
| 80 | 15/01/2006 | Società AA | Vendita | 30 |
Quindi, come si risolve il problema?
Una soluzione consiste nel forzare la query a prevedere che il valore del campo sia un numero. È possibile farlo con questa espressione:
IIf(False, 0, Null)
La condizione da controllare, , Falsenon è mai True, quindi l'espressione restituisce Nullsempre . Tuttavia, Access valuta comunque entrambe le opzioni di output e considera l'output come numerico o Null.
Ecco come usare l'espressione in questo esempio:
SELECT [Product ID], [Order Date], [Company Name], [Transaction], IIf(False, 0, Null) As Buy, [Quantity] As Sell
FROM [Product Orders]
UNION
SELECT [Product ID], [Creation Date], [Company Name], [Transaction], [Quantity] As Buy, Null As Sell
FROM [Product Purchases]
ORDER BY [Order Date] DESC;
Non è necessario modificare la seconda query.
Se si passa alla visualizzazione Foglio dati, comparirà un risultato desiderato:
| ID prodotto | Data ordine | Nome società | Transazione | Acquisto | Vendita |
|---|---|---|---|---|---|
| 74 | 22/01/2006 | Fornitore B | Acquisto | 20 | |
| 77 | 22/01/2006 | Fornitore B | Acquisto | 60 | |
| 80 | 22/01/2006 | Fornitore D | Acquisto | 75 | |
| 81 | 22/01/2006 | Fornitore A | Acquisto | 125 | |
| 81 | 22/01/2006 | Fornitore A | Acquisto | 200 | |
| 7 | 20/01/2006 | Società D | Vendita | 10 | |
| 51 | 20/01/2006 | Società D | Vendita | 10 | |
| 80 | 20/01/2006 | Società D | Vendita | 10 | |
| 34 | 15/01/2006 | Società AA | Vendita | 100 | |
| 80 | 15/01/2006 | Società AA | Vendita | 30 |
Un metodo alternativo per ottenere lo stesso risultato consiste nell'anteporre un'ulteriore query alle query nella query di unione:
SELECT
0 As [Product ID], Date() As [Order Date],
"" As [Company Name], "" As [Transaction],
0 As Buy, 0 As Sell
FROM [Product Orders]
WHERE False
Per ogni campo, Access restituisce i valori fissi del tipo di dati definito. Naturalmente, non si vuole che l'output di questa query interferisca con i risultati, quindi il trucco consiste nell'includere una clausola WHERE su False:
WHERE False
Questo è un piccolo trucco. Poiché la condizione è sempre falsa, la query non restituisce nulla. La combinazione di questa istruzione con l'istruzione SQL esistente produce un'istruzione completa:
SELECT
0 As [Product ID], Date() As [Order Date],
"" As [Company Name], "" As [Transaction],
0 As Buy, 0 As Sell
FROM [Product Orders]
WHERE False
UNION
SELECT [Product ID], [Order Date], [Company Name], [Transaction], Null As Buy, [Quantity] As Sell
FROM [Product Orders]
UNION
SELECT [Product ID], [Creation Date], [Company Name], [Transaction], [Quantity] As Buy, Null As Sell
FROM [Product Purchases]
ORDER BY [Order Date] DESC;
Nota
In questo esempio la query combinata nel database Northwind restituisce 100 record, mentre le due singole query restituiscono 58 e 43 record per un totale di 101 record. Questa differenza si verifica perché due record non sono univoci. Vedere Utilizzo di record distinti nelle query di unione con UNION ALL per informazioni su come risolvere questo scenario usando UNION ALL.
Aggiungere i totali in una query di unione
Un uso speciale per una query di unione consiste nel combinare un set di record con un record che contiene la somma di uno o più campi.
Ecco un altro esempio che si può creare nel database di esempio Northwind per illustrare come ottenere un totale in una query di unione.
Creare una nuova query semplice per visualizzare l'acquisto di birre (ID prodotto = 34 nel database Northwind) usando la sintassi SQL seguente:
SELECT [Purchase Order Details].[Date Received], [Purchase Order Details].Quantity FROM [Purchase Order Details] WHERE ((([Purchase Order Details].[Product ID])=34)) ORDER BY [Purchase Order Details].[Date Received];Passare alla visualizzazione Foglio dati in cui dovrebbero essere mostrati quattro acquisti:
Data di ricezione Quantità 22/01/2006 100 22/01/2006 60 04/04/2006 50 05/04/2006 300 Per ottenere il totale, creare una query di aggregazione semplice con l'istruzione SQL seguente:
SELECT Max([Date Received]), Sum([Quantity]) AS SumOfQuantity FROM [Purchase Order Details] WHERE ((([Purchase Order Details].[Product ID])=34))Passare alla visualizzazione Foglio dati in cui dovrebbe essere mostrato un solo record:
MaxOfDate Received SumOfQuantity 05/04/2006 510 Combinare queste due query in una query di unione per aggiungere il record con la quantità totale di record di acquisto:
SELECT [Purchase Order Details].[Date Received], [Purchase Order Details].Quantity FROM [Purchase Order Details] WHERE ((([Purchase Order Details].[Product ID])=34)) UNION SELECT Max([Date Received]), Sum([Quantity]) AS SumOfQuantity FROM [Purchase Order Details] WHERE ((([Purchase Order Details].[Product ID])=34)) ORDER BY [Purchase Order Details].[Date Received];Passare alla visualizzazione Foglio dati in cui dovrebbero essere mostrati quattro acquisti e la somma di ciascuno, seguita da un record che contiene il totale della quantità:
Data di ricezione Quantità 22/01/2006 60 22/01/2006 100 04/04/2006 50 05/04/2006 300 05/04/2006 510
Questo illustra le nozioni di base sull'aggiunta dei totali a una query di unione. È anche possibile includere valori fissi in entrambe le query, ad esempio "Dettaglio" e "Totale", per separare visivamente il record totale dagli altri record. Per rivedere, usare i valori fissi nella sezione Combinare tre o più tabelle o query in una query di unione.
Usare record distinti nelle query di unione con UNION ALL
Per impostazione predefinita, le query di unione in Access includono solo record distinti. Ma cosa succede se si vogliono includere tutti i record? Può essere utile esaminare un altro esempio.
Nella sezione precedente è stato illustrato come creare un totale in una query di unione. Modificare la query SQL di unione per includere Product ID = 48:
SELECT [Purchase Order Details].[Date Received], [Purchase Order Details].Quantity
FROM [Purchase Order Details]
WHERE ((([Purchase Order Details].[Product ID])=48))
UNION
SELECT Max([Date Received]), Sum([Quantity]) AS SumOfQuantity
FROM [Purchase Order Details]
WHERE ((([Purchase Order Details].[Product ID])=48))
ORDER BY [Purchase Order Details].[Date Received];
Passare alla visualizzazione Foglio dati in cui dovrebbe essere mostrato un risultato fuorviante.
| Data di ricezione | Quantità |
|---|---|
| 22/01/2006 | 100 |
| 22/01/2006 | 200 |
Naturalmente, un record non restituisce il doppio della quantità totale.
Questo risultato viene visualizzato perché, in un giorno, la stessa quantità di cioccolatini è stata venduta due volte, come registrato nella tabella Dettagli ordine di acquisto. Ecco un risultato della query di selezione semplice che mostra entrambi i record nel database di esempio Northwind:
| ID Ordine di acquisto | Prodotto | Quantity |
|---|---|---|
| 100 | Northwind Traders Chocolate | 100 |
| 92 | Northwind Traders Chocolate | 100 |
Nella query di unione annotata in precedenza è possibile vedere che il campo ID ordine di acquisto non è incluso e che i due campi non costituiscono due record distinti.
Se si vogliono includere tutti i record, usare UNION ALL invece di UNION in SQL. Questa operazione influisce molto probabilmente sull'ordinamento dei risultati, quindi è consigliabile includere anche una ORDER BY clausola per determinare l'ordinamento. Ecco l'elemento modificato SQL in base all'esempio precedente:
SELECT [Purchase Order Details].[Date Received], Null As [Total], [Purchase Order Details].Quantity
FROM [Purchase Order Details]
WHERE ((([Purchase Order Details].[Product ID])=48))
UNION ALL
SELECT Max([Date Received]), "Total" As [Total], Sum([Quantity]) AS SumOfQuantity
FROM [Purchase Order Details]
WHERE ((([Purchase Order Details].[Product ID])=48))
ORDER BY [Total];
Passare alla visualizzazione Foglio dati in cui dovrebbero essere mostrati tutti i dettagli e un totale come ultimo record:
| Data di ricezione | Totale | Quantità |
|---|---|---|
| 22/01/2006 | 100 | |
| 22/01/2006 | 100 | |
| 22/01/2006 | Totale | 200 |
Usare una query di unione per filtrare i record in una maschera con un controllo casella combinata
Un uso comune per una query di unione consiste nel fungere da origine record per un controllo casella combinata in una maschera. È possibile usare questa casella combinata per selezionare un valore per filtrare i record della maschera. Ad esempio, filtrare i record dei dipendenti in base alla città.
Per vedere come funziona, ecco un altro esempio che si può creare nel database di esempio Northwind per illustrare questo scenario.
Creare una query di selezione semplice usando questa
SQLsintassi:SELECT Employees.City, Employees.City AS Filter FROM Employees;Passare alla visualizzazione Foglio dati in cui dovrebbero essere mostrati i risultati seguenti:
Città Filtro Milano Roma Palermo Palermo Torino Torino Ravenna Ravenna Milano Milano Torino Torino Milano Milano Torino Torino Milano Milano Osservando i risultati, potrebbero mancare diversi valori. Espandere la query, tuttavia, e trasformarla in una query di unione usando:
SQLSELECT Employees.City, Employees.City AS Filter FROM Employees UNION SELECT "<All>", "*" AS Filter FROM Employees ORDER BY City;Passare alla visualizzazione Foglio dati in cui dovrebbero essere mostrati i risultati seguenti:
Città Filtro <Tutto> * Palermo Palermo Ravenna Ravenna Torino Torino Milano Milano Access esegue un'unione dei nove record, mostrati in precedenza, con i valori dei campi <fissi Tutti> e "*". Poiché questa clausola di unione non contiene
UNION ALL, Access restituisce solo record distinti. Ciò significa che ogni città viene restituita una sola volta con valori fissi identici.Dopo aver completato una query di unione che visualizza una sola volta ogni nome di città, insieme all'opzione che seleziona in modo efficace tutte le città, è possibile usare questa query come origine record per una casella combinata in una maschera. Usando questo esempio come modello, è possibile creare un controllo casella combinata in una maschera, impostare questa query come origine record, impostare la proprietà Larghezza colonne della colonna Filtro su 0 (zero) per nasconderla visivamente e quindi impostare la proprietà Colonna associata su 1 per indicare l'indice della seconda colonna.
FilterNella proprietà della maschera stessa è quindi possibile aggiungere codice simile al seguente per attivare un filtro di maschera usando il valore selezionato nel controllo casella combinata:Me.Filter = "[City] Like '" & Me![FilterComboBoxName].Value & "'" Me.FilterOn = TrueL'utente del modulo può quindi filtrare i record del modulo in base a un nome di città specifico oppure selezionare <Tutti> per elencare tutti i record per tutte le città.
Inizio pagina