Inserimento, cancellazione, aggiornamento dei record nel database. Come inviare una query a un database utilizzando VBA Access Creazione di query SQL negli omonimi Access
Lavoro di laboratorio n. 1
SQL: ESTRATTO DATI - comandoSELEZIONARE
Obiettivo del lavoro:
- acquisire familiarità con le istruzioni SQL;
- imparare come creare semplici query SQL in Access utilizzando il comando SELECT;
· utilizzo degli operatori IN, BETWEEN, LIKE, IS NULL.
Esercizio№1. Creare una query per selezionare in modalità SQL tutti i valori dei campi FIRST NAME e LAST NAME dalla tabella STUDENTS.
SELEZIONA NOME, COGNOME
DAGLI STUDENTI;
Esercizio№2 . Creare una query per selezionare in modalità SQL tutte le colonne della tabella STUDENTS.
SELEZIONARE *
DAGLI STUDENTI;
Compito n.3. Creare una query per selezionare in modalità SQL i nomi delle città in cui vivono gli studenti, le cui informazioni si trovano nella tabella DATI PERSONALI.
SELEZIONA CITTÀ DISTINTA
DA [DATI PERSONALI];
Compito n. 4. Creare una query di selezione in modalità SQL che recuperi i nomi di tutti gli studenti con il cognome Ivanov, le cui informazioni si trovano nella tabella STUDENTS.
SELEZIONA COGNOME, NOME
DA STUDENTI
DOVE COGNOME="Ivanov";
Compito n.5. Creare una query di selezione in modalità SQL per ottenere il nome e il cognome degli studenti che studiano nel gruppo UIT-22 in una forma di istruzione economica.
SELEZIONA COGNOME, NOME
DA STUDENTI
WHERE GRUPPO="UIT-22" AND BUDGET=true;
Compito n. 6. Creare una query in modalità SQL. per un campione della tabella ESAMI, informazioni sugli studenti che hanno solo i voti 4 e 5.
SELEZIONARE *
DA [MODIFICAESAMI]
DOVEGRADOIN(4,5);
Compito n.7. Crea una modalità zanpoc e SQL per selezionare le informazioni sugli studenti che hanno un voto di esame pari a 3 nella materia IOSU.
SELEZIONARE *
DA [MODIFICAESAMI]
DOVEARTICOLO=" IOSU"EGRADONon In (4,5);
Compito n. 8. Creare una query in modalità SQL per selezionare i record per gli elementi le cui ore sono comprese tra 100 e 130.
SELEZIONARE *
DAELEMENTI
DOVEOROLOGIOTRA 100 E 130;
Compito n. 9. Creare una query in modalità SQL per selezionare dalla tabella STUDENTS informazioni sugli studenti i cui cognomi iniziano, ad esempio, con la lettera “C”.
SELEZIONARE *
DASTUDENTI
DOVECOGNOMECOME"CON*";
Conclusione: Durante lavoro di laboratorio ho conosciuto le istruzioni SQL, ho imparato come creare semplici query SQL in Access utilizzando il comando SELECT utilizzando gli operatori IN, BETWEEN, LIKE.
Questa lezione è dedicata a query SQL al database su Accesso VBA. Vedremo come vengono eseguite le query INSERT, UPDATE, DELETE nel database in VBA e impareremo anche come ottenere un valore specifico da una query SELECT.
Coloro che programmano Accesso VBA mentre si lavora con il database Server SQL, molto spesso si trovano ad affrontare un compito così semplice e necessario come inviare una query SQL a un database, sia essa INSERT, UPDATE o una semplice query SQL SELECT. E poiché siamo programmatori alle prime armi, dovremmo essere in grado di farlo, quindi oggi faremo proprio questo.
Abbiamo già toccato l'argomento come ottenere dati da un server SQL, dove abbiamo scritto codice in VBA per ottenere questi dati, ad esempio, nell'articolo sul caricamento dei dati in un file di testo da MSSql 2008, oppure ne abbiamo parlato anche in poco nel materiale Caricamento di dati da Access a un modello Word ed Excel. ma in un modo o nell'altro, lo abbiamo esaminato superficialmente e oggi propongo di parlarne un po' più in dettaglio.
Nota! Tutti gli esempi seguenti vengono considerati utilizzando il progetto ADP Access 2003 e il database MSSql 2008. Se non sai cos'è un progetto ADP, lo abbiamo esaminato nel materiale Come creare e configurare un progetto Access ADP
Dati di origine per esempi
Diciamo di avere una tabella test_table, che conterrà i numeri e i nomi dei mesi dell'anno (le query vengono eseguite utilizzando Studio Direzionale)
CREA TABELLA. (NON NULL, (50) NULL) IN VIAGGIO
Come ho già detto, utilizzeremo un progetto ADP configurato per funzionare con MS SQL 2008, in cui ho creato un modulo di prova e aggiunto un pulsante di avvio con una firma "Correre", di cui avremo bisogno per testare il nostro codice, ovvero Scriveremo tutto il codice nel gestore eventi " Premere il pulsante».
Interrogazioni al database INSERT, UPDATE, DELETE in VBA
Per non ritardare troppo, iniziamo subito, diciamo che dobbiamo aggiungere una riga alla nostra tabella di test ( codice commentato)/
Private Sub start_Click() "Dichiara una variabile per memorizzare la stringa della query Dim sql_query As String "Scrivi la query di cui abbiamo bisogno sql_query = "INSERT INTO test_table (id, name_mon) VALUES ("6", "June")" "Execute it DoCmd.RunSQL sql_query End Sub
In questo caso, la query viene eseguita utilizzando i parametri di connessione al database correnti. Possiamo verificare se i dati sono stati aggiunti o meno.
Come puoi vedere i dati sono stati inseriti.
Per eliminare una riga scriviamo il seguente codice.
Private Sub start_Click() "Dichiara una variabile per memorizzare la stringa di query Dim sql_query As String "Scrivi una query di eliminazione al suo interno sql_query = "DELETE test_table WHERE id = 6" "Esegui DoCmd.RunSQL sql_query End Sub
Se controlliamo, vedremo che la riga desiderata è stata cancellata.
Per aggiornare i dati, scrivere nella variabile sql_query richiesta di aggiornamento, spero che il significato sia chiaro.
SELECT query su un database in VBA
Qui le cose sono un po' più interessanti che con altri costrutti SQL.
Innanzitutto, diciamo che dobbiamo ottenere tutti i dati dalla tabella e, ad esempio, li elaboreremo e li visualizzeremo in un messaggio e tu, ovviamente, puoi usarli per altri scopi, per questo scriviamo quanto segue codice
Private Sub start_Click() "Dichiara variabili "Per un insieme di record dal database Dim RS As ADODB.Recordset "Stringa di query Dim sql_query As String "Stringa per visualizzare i dati di riepilogo in un messaggio Dim str As String "Crea un nuovo oggetto per i record set RS = New ADODB .Recordset "Query line sql_query = "SELECT id, name_mon FROM test_table" "Esegui la query utilizzando le impostazioni di connessione del progetto corrente RS.open sql_query, CurrentProject.Connection, adOpenDynamic, adLockOptimistic "Esegui il ciclo dei record While Not ( RS.EOF) "Compila la variabile per visualizzare il messaggio str = str & RS.Fields("id") & "-" & RS.Fields("name_mon") & vbnewline "vai al record successivo RS.MoveNext Wend " Visualizza il messaggio msgbox str End Sub
Qui stiamo già utilizzando i loop VBA Access per scorrere tutti i valori nel nostro recordset.
Ma molto spesso è necessario ottenere non tutti i valori da una serie di record, ma solo uno, ad esempio il nome del mese tramite il suo codice. E per fare questo, è piuttosto costoso usare un ciclo, quindi possiamo semplicemente scrivere una query che restituirà solo un valore e accedervi, ad esempio, otterremo il nome del mese usando il codice 5
Private Sub start_Click() "Dichiara variabili" Per un insieme di record dal database Dim RS As ADODB.Recordset "Stringa di query Dim sql_query As String "Stringa per visualizzare il valore finale Dim str As String "Crea un nuovo oggetto per il set di record RS = Nuovo ADODB.Recordset "Query line sql_query = "SELECT name_mon FROM test_table WHERE id = 5" "Esegui la query utilizzando le impostazioni di connessione del progetto corrente RS.open sql_query, CurrentProject.Connection, adOpenDynamic, adLockOptimistic "Ottieni il nostro valore str = RS. Campi(0) msgbox str End Sub
Per universalità, qui abbiamo già affrontato non il nome della cella, ma il suo indice, ad es. 0, e questo è il primo valore in Set di record, alla fine abbiamo ottenuto il valore "Maggio".
Come puoi vedere, tutto è abbastanza semplice. Se hai spesso bisogno di ottenere un valore specifico dal database ( come nell'ultimo esempio), quindi consiglio di inviare tutto il codice in una funzione separata (Come scrivere una funzione in VBA Access 2003) con un parametro di input, ad esempio il codice del mese ( se consideriamo il nostro esempio) e semplicemente, dove è necessario visualizzare questo valore, chiamiamo la funzione che ci serve con il parametro richiesto e il gioco è fatto, così facendo ridurremo notevolmente il codice VBA e miglioreremo la percezione del nostro programma.
È tutto per oggi. Buona fortuna!
Descrizione del progetto educativo "Shop"Schema di collegamento della tabella
Descrizione delle tabelle
m_category: categorie di prodotti
m_reddito - entrata merci
m_outcome: consumo di beni
m_product - directory, descrizioni dei prodotti
m_fornitore - directory; informazioni sui fornitori
m_unità - directory; unità
Per testare praticamente gli esempi forniti in questo materiale formativo, è necessario disporre del seguente software:
accesso Microsoft 2003 o più recente.
Interrogazione SQL in MS Access. Inizio
Per vedere il contenuto della tabella, fare doppio clic sul nome della tabella nel pannello di sinistra:
Per passare alla modalità di modifica dei campi della tabella, fare clic su pannello superiore seleziona la modalità Progettazione:
Per visualizzare il risultato di una query SQL, fare doppio clic sul nome della query nel riquadro di sinistra:
Per passare alla modalità di modifica della query SQL, seleziona la modalità SQL nel pannello superiore:
Interrogazione SQL. Esempi in MS Access. SELEZIONARE: 1-10
In una query SQL, l'istruzione SELECT viene utilizzata per selezionare dalle tabelle del database.Interrogazione SQL Q001. Esempio di query SQL per ottenere solo i campi obbligatori nella sequenza desiderata:
SELEZIONA dt, product_id, importo
DA m_reddito;
Interrogazione SQL Q002. In questa query SQL di esempio, il carattere asterisco (*) viene utilizzato per elencare tutte le colonne della tabella m_product, in altre parole, per ottenere tutti i campi della relazione m_product:
SELEZIONARE *
DA m_prodotto;
RichiestaSQLQ003. L'istruzione DISTINCT viene utilizzata per eliminare voci duplicate e ottenere più voci univoche:
SELEZIONA ID_prodotto DISTINTO
DA m_reddito;
Interrogazione SQL Q004. L'istruzione ORDER BY viene utilizzata per ordinare (ordinare) i record in base ai valori di un campo specifico. Il nome del campo è specificato dopo l'istruzione ORDER BY:
SELEZIONARE *
DA m_reddito
ORDINA PER prezzo;
Interrogazione SQL Q005. L'istruzione ASC viene utilizzata come complemento all'istruzione ORDER BY e serve a specificare l'ordinamento crescente. L'istruzione DESC viene utilizzata in aggiunta all'istruzione ORDER BY e viene utilizzata per specificare l'ordinamento discendente. Nel caso in cui non siano specificati né ASC né DESC si presuppone la presenza di ASC (default):
SELEZIONARE *
DA m_reddito
ORDINA PER dt DESC , prezzo;
Interrogazione SQL Q006. Per selezionare i record necessari dalla tabella vengono utilizzate varie espressioni logiche che esprimono la condizione di selezione. L'espressione booleana appare dopo l'istruzione WHERE. Un esempio di come ottenere tutti i record dalla tabella m_income per cui il valore dell'importo è maggiore di 200:
SELEZIONARE *
DA m_reddito
DOVE importo>200;
Interrogazione SQL Q007. Per espressione condizioni difficili utilizzare gli operatori logici AND (congiunzione), OR (disgiunzione) e NOT (negazione logica). Un esempio per ottenere dalla tabella m_outcome tutti i record per i quali il valore dell'importo è 20 e il valore del prezzo è maggiore o uguale a 10:
Prezzo
DA m_risultato
DOVE importo=20 E prezzo>=10;
Interrogazione SQLQ008. Per unire i dati di due o più tabelle, utilizzare le istruzioni INNER JOIN, LEFT JOIN, RIGHT JOIN. L'esempio seguente recupera i campi dt, product_id, amount, price dalla tabella m_income e il campo title dalla tabella m_product. Il record della tabella m_income viene unito al record della tabella m_product quando il valore di m_income.product_id è uguale al valore di m_product.id:
ON m_reddito.prodotto_id=m_prodotto.id;
Interrogazione SQL Q009. Ci sono due cose da notare in questa query SQL: 1) il testo che stai cercando è racchiuso virgolette singole("); 2) la data è fornita nel formato #Mese/Giorno/Anno#, che è vero per MS Access. In altri sistemi, il formato per scrivere la data potrebbe essere diverso. Un esempio di visualizzazione delle informazioni sulla ricevuta di latte il 12 giugno 2011. Si prega di notare il formato della data #6/12/2011#:
SELEZIONA dt, product_id, titolo, importo, prezzo
FROM m_reddito INNER JOIN m_prodotto
DOVE titolo="Latte" And dt=#6/12/2011#; !}
Interrogazione SQL Q010. L'istruzione BETWEEN viene utilizzata per verificare se un valore appartiene a un determinato intervallo. Una query SQL di esempio che visualizza informazioni sui prodotti ricevuti tra il 1° giugno e il 30 giugno 2011:
SELEZIONARE *
FROM m_reddito INNER JOIN m_prodotto
ON m_reddito.product_id=m_prodotto.id
DOVE dt TRA il #01/06/2011# E il #30/06/2011#;
Interrogazione SQL. Esempi in MS Access. SELEZIONE: 11-20
Una query SQL può essere annidata all'interno di un'altra. Una sottoquery non è altro che una query all'interno di un'altra query. In genere, nella clausola WHERE viene utilizzata una sottoquery. Ma esistono altri modi per utilizzare le sottoquery.Domanda Q011. Vengono visualizzate le informazioni sui prodotti dalla tabella m_product, i cui codici si trovano anche nella tabella m_income:
SELEZIONARE *
DA m_prodotto
DOVE id IN (SELECT product_id FROM m_income);
Domanda Q012. Viene visualizzato un elenco di prodotti dalla tabella m_product, i cui codici non sono presenti nella tabella m_outcome:
SELEZIONARE *
DA m_prodotto
DOVE id NOT IN (SELECT product_id FROM m_outcome);
Richiedi Q013. Questa query SQL visualizza un elenco univoco di codici e nomi di prodotto presenti nella tabella m_income ma non nella tabella m_outcome:
SELEZIONA ID_prodotto DISTINTO, titolo
FROM m_reddito INNER JOIN m_prodotto
ON m_reddito.product_id=m_prodotto.id
DOVE product_id NOT IN (SELECT product_id FROM m_outcome);
Domanda Q014. Un elenco univoco di categorie i cui nomi iniziano con la lettera M viene visualizzato dalla tabella m_category:
SELEZIONA titolo DISTINTO
DA m_prodotto
DOVE titolo COME "M*";
Domanda Q015. Un esempio di esecuzione di operazioni aritmetiche sui campi in una query e di ridenominazione dei campi in una query (alias). In questo esempio viene calcolata la spesa = quantità*prezzo e il profitto per ogni voce di spesa di un articolo, presupponendo che il profitto sia pari al 7% delle vendite:
importo*prezzo/100*7 profitto AS
DA m_esito;
Domanda Q016. Analizzando e semplificando le operazioni aritmetiche, puoi aumentare la velocità di esecuzione delle query:
SELECT dt, product_id, importo, prezzo, importo*prezzo AS somma_esito,
somma_esito*0,07 Profitto AS
DA m_esito;
Richiedi Q017.È possibile utilizzare l'istruzione INNER JOIN per unire dati da più tabelle. Nell'esempio seguente, a seconda del valore di ctgry_id, ogni voce nella tabella m_income viene abbinata al nome della categoria della tabella m_category a cui appartiene il prodotto:
SELECT c.titolo, b.titolo, dt, importo, prezzo, importo*prezzo AS somma_reddito
FROM (m_reddito AS a INNER JOIN m_prodotto AS b ON a.product_id=b.id)
INNER JOIN m_category AS c ON b.ctgry_id=c.id
ORDINA PER c.titolo, b.titolo;
Richiedi Q018. Funzioni come SUM - somma, COUNT - quantità, AVG - media aritmetica, MAX - valore massimo, MIN - valore minimo sono chiamate funzioni aggregate. Accettano molti valori e dopo averli elaborati restituiscono un unico valore. Un esempio di calcolo della somma del prodotto dei campi importo e prezzo utilizzando la funzione aggregata SOMMA:
SELECT SUM(importo*prezzo) AS Somma_Totale
DA m_reddito;
Domanda Q019. Un esempio di utilizzo di diverse funzioni aggregate:
SELECT Somma(importo) AS Importo_Somma, AVG(importo) AS Importo_AVG,
MAX(importo) Importo AS_Max, Min(importo) Importo AS_Min,
Conteggio (*) AS Total_Number
DA m_reddito;
Richiedi Q020. In questo esempio, l'importo di tutte le merci con codice 1, capitalizzato nel giugno 2011, viene calcolato:
SELECT Somma(importo*prezzo) AS somma_reddito
DA m_reddito
DOVE product_id=1 E dt TRA #6/1/2011# E #6/30/2011#;.
Domanda Q021. La seguente query SQL calcola l'importo delle vendite degli articoli con codice 4 o 6:
SELEZIONA Somma(importo*prezzo) come somma_risultato
DA m_risultato
DOVE id_prodotto=4 O id_prodotto=6;
Domanda Q022. Si calcola la quantità di merce con codice 4 o 6 venduta il 12 giugno 2011:
SELECT Somma(importo*prezzo) AS somma_risultato
DA m_risultato
DOVE (id_prodotto=4 O id_prodotto=6) E dt=#6/12/2011#;
Domanda Q023. Il compito è questo. Calcolare l'importo totale dei beni nella categoria "Prodotti da forno" che sono stati capitalizzati.
Per risolvere questo problema è necessario operare con tre tabelle: m_income, m_product e m_category, perché:
- la quantità e il prezzo dei beni capitalizzati sono memorizzati nella tabella m_income;
- il codice categoria di ciascun prodotto è memorizzato nella tabella m_product;
- il nome della categoria del titolo è memorizzato nella tabella m_category.
Per risolvere questo problema utilizzeremo il seguente algoritmo:
- determinazione del codice categoria "Prodotti da forno" dalla tabella m_category utilizzando una subquery;
- collegare le tabelle m_income e m_product per determinare la categoria di ciascun prodotto acquistato;
- calcolo dell'importo dello scontrino (= quantità*prezzo) per le merci il cui codice di categoria è uguale al codice definito dalla subquery di cui sopra.
SELEZIONARE
DA m_prodotto AS a INTERNO JOIN m_reddito AS b SU a.id=b.product_id
WHERE ctgry_id = (SELECT id FROM m_category WHERE title="Prodotti da forno"); !}
Domanda Q024. Risolveremo il problema del calcolo dell'importo totale dei beni capitalizzati nella categoria "Prodotti da forno" utilizzando il seguente algoritmo:
- per ogni voce nella tabella m_income, a seconda del valore del suo product_id, dalla tabella m_category, corrisponde al nome della categoria;
- selezionare i record la cui categoria è “Prodotti da forno”;
- calcolare l'importo dello scontrino = quantità*prezzo.
FROM (m_prodotto AS a INNER JOIN m_reddito AS b ON a.id=b.product_id)
DOVE c.title="Prodotti da forno";
!}
Domanda Q025. Questo esempio calcola quanti articoli di merce sono stati consumati:
SELECT COUNT(id_prodotto) AS cnt_prodotto
FROM (SELECT DISTINCT id_prodotto FROM m_risultato) AS t;
Interroga Q026. L'istruzione GROUP BY viene utilizzata per raggruppare i record. In genere, i record vengono raggruppati in base al valore di uno o più campi e a ciascun gruppo vengono applicate alcune operazioni di aggregazione. Ad esempio, la query seguente genera un report sulla vendita di merci. Cioè, viene generata una tabella contenente i nomi delle merci e l'importo per il quale sono state vendute:
SELECT titolo, SUM(importo*prezzo) AS somma_risultato
FROM m_prodotto AS a INTERNO JOIN m_risultato AS b
ON a.id=b.product_id
GRUPPO PER titolo;
Domanda Q027. Rapporto sulle vendite per categoria. Viene cioè generata una tabella che contiene i nomi delle categorie di prodotti, l'importo totale per il quale sono stati venduti i prodotti di queste categorie e l'importo medio delle vendite. La funzione ROUND viene utilizzata per arrotondare il valore medio al centesimo più vicino (la seconda cifra dopo il separatore decimale):
SELECT c.titolo, SUM(importo*prezzo) AS somma_risultato,
ROUND(AVG(importo*prezzo),2) AS somma_risultato_avg
FROM (m_prodotto AS a INNER JOIN m_risultato AS b ON a.id=b.product_id)
INNER JOIN m_category AS c ON a.ctgry_id=c.id
GRUPPO PER c.titolo;
Domanda Q028. Per ciascun prodotto viene calcolato il numero totale e medio delle sue entrate e vengono visualizzate informazioni sui prodotti le cui entrate totali sono almeno 500:
SELECT id_prodotto, SUM(importo) AS somma_importo,
Round(Avg(importo),2) Importo AS_avg
DA m_reddito
GRUPPO PER ID_prodotto
HAV Somma(importo)>=500;
Domanda Q029. Questa query calcola per ciascun prodotto l'importo e la media degli incassi effettuati nel secondo trimestre del 2011. Se l'importo totale dell'entrata prodotto è almeno 1000, verranno visualizzate le informazioni su questo prodotto:
SELECT titolo, SUM(importo*prezzo) AS somma_reddito
FROM m_reddito a INNER JOIN m_prodotto b ON a.product_id=b.id
DOVE dt TRA il #4/1/2011# E il #6/30/2011#
GRUPPO PER titolo
HAVING SUM(importo*prezzo)>=1000;
Interroga Q030. In alcuni casi, è necessario abbinare ogni record di una tabella con ogni record di un'altra tabella; che prende il nome di prodotto cartesiano. La tabella risultante da tale connessione è chiamata tabella di Cartesio. Ad esempio, se una tabella A ha 100 record e la tabella B ha 15 record, la tabella cartesiana sarà composta da 100*15=150 record. La seguente query unisce ogni record nella tabella m_income con ogni record nella tabella m_outcome:
DA m_reddito, m_risultato;
Domanda Q031. Un esempio di raggruppamento di record in base a due campi. La seguente query SQL calcola per ciascun fornitore l'importo e la quantità di merci da lui ricevute:
SUM(importo*prezzo) AS somma_reddito
Domanda Q032. Un esempio di raggruppamento di record in base a due campi. La seguente query calcola per ciascun fornitore l'importo e la quantità dei suoi prodotti venduti da noi:
SELECT id_fornitore, id_prodotto, SUM(importo) AS somma_importo,
GRUPPO PER ID_fornitore, ID_prodotto;
Domanda Q033. In questo esempio, le due query precedenti (q031 e q032) vengono utilizzate come sottoquery. I risultati di queste query utilizzando il metodo LEFT JOIN vengono combinati in un unico report. La query seguente visualizza un report sulla quantità e sull'importo dei prodotti ricevuti e venduti per ciascun fornitore. Tieni presente che se alcuni prodotti sono già stati ricevuti, ma non sono stati ancora venduti, la cella result_sum per questa voce sarà vuota. che questa query è solo un esempio dell'utilizzo di query relativamente complesse come sottoquery. Le prestazioni di questa query SQL con una grande quantità di dati sono discutibili:
SELEZIONARE *
DA
SUM(importo*prezzo) AS somma_reddito
ON a.product_id=b.id GRUPPO PER fornitore_id, prodotto_id) AS a
SINISTRA UNISCITI
(SELECT ID_fornitore, ID_prodotto, SUM(importo) AS somma_importo,
SUM(importo*prezzo) AS somma_risultato
FROM m_risultato AS a INTERNO JOIN m_prodotto AS b
ON a.product_id=b.id GRUPPO PER fornitore_id, prodotto_id) AS b
ON (a.product_id=b.product_id) E (a.supplier_id=b.supplier_id);
Domanda Q034. In questo esempio, le due query precedenti (q031 e q032) vengono utilizzate come sottoquery. I risultati di queste query utilizzando il metodo RIGTH JOIN vengono combinati in un unico report. La seguente query visualizza un report sull'importo dei pagamenti di ciascun cliente in base ai sistemi di pagamento utilizzati e all'importo degli investimenti effettuati. La query seguente visualizza un report sulla quantità e sull'importo dei prodotti ricevuti e venduti per ciascun fornitore. Tieni presente che se qualche prodotto è già stato venduto, ma non è ancora arrivato, la cella revenue_sum per questa voce sarà vuota. La presenza di tali celle vuote è indice di un errore nella contabilità delle vendite, poiché prima di una vendita è necessario che arrivi il prodotto corrispondente:
SELEZIONARE *
DA
(SELECT ID_fornitore, ID_prodotto, SUM(importo) AS somma_importo,
SUM(importo*prezzo) AS somma_reddito
DA m_reddito AS a INTERNO JOIN m_prodotto AS b ON a.product_id=b.id
GRUPPO PER ID_fornitore, ID_prodotto) AS a
ISCRIVITI GIUSTO
(SELECT ID_fornitore, ID_prodotto, SUM(importo) AS somma_importo,
SUM(importo*prezzo) AS somma_risultato
FROM m_risultato AS a INTERNO JOIN m_prodotto AS b ON a.product_id=b.id
GRUPPO PER ID_fornitore, ID_prodotto) AS b
ON (a.supplier_id=b.supplier_id) E (a.product_id=b.product_id);
Domanda Q035. Viene visualizzato un report che mostra l'importo delle entrate e delle spese per prodotto. Per fare ciò, viene creato un elenco di prodotti secondo le tabelle m_income e m_outcome, quindi per ciascun prodotto di questo elenco la somma delle sue entrate viene calcolata secondo la tabella m_income e l'importo delle sue spese secondo la tabella m_outcome:
SELECT id_prodotto, SUM(importo_in) AS importo_reddito,
SUM(importo_out) AS importo_risultato
DA
(SELEZIONA ID_prodotto, importo AS importo_in, 0 AS importo_out
DA m_reddito
UNIONE TUTTI
SELEZIONA ID_prodotto, 0 AS importo_in, importo AS importo_out
DA m_risultato) AS t
GRUPPO PER id_prodotto;
Domanda Q036. La funzione EXISTS restituisce TRUE se l'insieme che le viene passato contiene elementi. La funzione EXISTS restituisce FALSE se l'insieme che le viene passato è vuoto, ovvero non contiene elementi. La seguente query visualizza i codici prodotto contenuti nelle tabelle m_income e m_outcome:
SELEZIONA ID_prodotto DISTINTO
DA m_reddito COME a
DOVE ESISTE(SELECT product_id FROM m_outcome AS b
Domanda Q037. Vengono visualizzati i codici prodotto contenuti nelle tabelle m_income e m_outcome:
SELEZIONA ID_prodotto DISTINTO
DA m_reddito COME a
DOVE product_id IN (SELEZIONA product_id FROM m_outcome)
Domanda Q038. Vengono visualizzati i codici prodotto contenuti nella tabella m_income, ma non contenuti nella tabella m_outcome:
SELEZIONA ID_prodotto DISTINTO
DA m_reddito COME a
DOVE NON ESISTE(SELECT product_id FROM m_outcome AS b
DOVE b.id_prodotto=a.id_prodotto);
Domanda Q039. Viene visualizzato un elenco di prodotti con l'importo massimo di vendita. L'algoritmo è il seguente. Per ciascun prodotto viene calcolato l'importo delle sue vendite. Quindi, viene determinato il massimo di questi importi. Quindi, per ciascun prodotto, viene ricalcolata la somma delle sue vendite e vengono visualizzati il codice e la somma delle vendite dei beni la cui somma delle vendite è pari al massimo:
SELECT id_prodotto, SUM(importo*prezzo) AS somma_importo
DA m_risultato
GRUPPO PER ID_prodotto
HAVING SUM(importo*prezzo) = (SELECT MAX(s_importo)
FROM (SELECT SUM(importo*prezzo) AS s_importo FROM m_risultato GRUPPO BY id_prodotto));
Domanda Q040. Parola riservata IIF ( operatore condizionale) viene utilizzato per valutare un'espressione booleana ed eseguire un'azione a seconda del risultato (VERO o FALSO). Nell'esempio seguente, la consegna dell'articolo è considerata "piccola" se la quantità è inferiore a 500. Altrimenti, ovvero la quantità in entrata è maggiore o uguale a 500, la consegna è considerata "grande":
SELEZIONA dt, product_id, importo,
IIF(importo DA m_reddito;
Interrogazione SQL Q041. Nel caso in cui l'operatore IIF venga utilizzato più volte, è più conveniente sostituirlo con l'operatore SWITCH. L'operatore SWITCH (operatore di selezione multipla) viene utilizzato per valutare un'espressione logica ed eseguire un'azione in base al risultato. Nell'esempio seguente il lotto consegnato è considerato “piccolo” se la quantità di merce contenuta nel lotto è inferiore a 500. Altrimenti, cioè se la quantità di merce è maggiore o uguale a 500, il lotto è considerato “grande”. ":
SELEZIONA dt, product_id, importo,
SWITCH(importo =500,"grande") contrassegno AS
DA m_reddito;
Domanda Q042. Nella richiesta successiva, se la quantità di merci nel lotto ricevuto è inferiore a 300, il lotto viene considerato “piccolo”. Altrimenti, ovvero se l'importo della condizione SELECT dt, product_id, amount,
IIF(importo IIF(importo DA m_reddito;
Interrogazione SQL Q043. Nella richiesta successiva, se la quantità di merci nel lotto ricevuto è inferiore a 300, il lotto viene considerato “piccolo”. Altrimenti, ovvero se l'importo della condizione SELECT dt, product_id, amount,
SWITCH(importo importo importo>=1000,"grande") AS mark
DA m_reddito;
Interrogazione SQL Q044. Nella query seguente, le vendite sono divise in tre gruppi: piccole (fino a 150), medie (da 150 a 300), grandi (300 o più). Successivamente, viene calcolato l'importo totale per ciascun gruppo:
SELECT Categoria, SUM(somma_risultato) AS Ctgry_Totale
DA (SELECT importo*prezzo AS somma_risultato,
IIf(importo*prezzo IIf(importo*prezzo FROM m_risultato) AS t
GRUPPO PER Categoria;
Interrogazione SQL Q045. La funzione DateAdd viene utilizzata per aggiungere giorni, mesi o anni a una determinata data e ottenere una nuova data. Prossima richiesta:
1) aggiunge 30 giorni alla data dal campo dt e visualizza la nuova data nel campo dt_plus_30d;
2) aggiunge 1 mese alla data dal campo dt e visualizza la nuova data nel campo dt_plus_1m:
SELECT dt, dateadd("d",30,dt) AS dt_plus_30d, dateadd("m",1,dt) AS dt_plus_1m
DA m_reddito;
Interrogazione SQL Q046. La funzione DateDiff è progettata per calcolare la differenza tra due date in unità diverse (giorni, mesi o anni). La seguente query calcola la differenza tra la data nel campo dt e la data corrente in giorni, mesi e anni:
SELECT dt, DateDiff("d",dt,Date()) AS last_day,
DateDiff("m",dt,Date()) AS ultimi_mesi,
DateDiff("aaaa",dt,Data()) AS ultimi_anni
DA m_reddito;
Interrogazione SQL Q047. Il numero di giorni dalla data di ricevimento della merce (tabella m_income) alla data corrente viene calcolato utilizzando la funzione DateDiff e viene confrontata la data di scadenza (tabella m_product):
DateDiff("d",dt,Date()) AS ultimi_giorni
FROM m_reddito AS a INTERNO JOIN m_prodotto AS b
ON a.id_prodotto=b.id;
Interrogazione SQL Q048. Si calcola il numero di giorni dalla data di ricevimento della merce alla data corrente, poi si controlla se tale quantità supera la data di scadenza:
SELEZIONA a.id, product_id, dt, lifedays,
DateDiff("d",dt,Date()) AS last_days, IIf(last_days>lifedays,"Yes","No") AS date_expire
FROM m_reddito a INNER JOIN m_prodotto b
ON a.id_prodotto=b.id;
Interrogazione SQL Q049. Viene calcolato il numero di mesi dalla data di ricevimento della merce alla data attuale. La colonna mese_ultimo1 calcola il numero assoluto di mesi, la colonna mese_ultimo2 calcola il numero di mesi interi:
SELECT dt, DateDiff("m",dt,Date()) AS mese_ultimo1,
DateDiff("m",dt,Date())-iif(giorno(dt)>giorno(date()),1,0) AS mese_ultimo2
DA m_reddito;
Interrogazione SQL Q050. Viene visualizzato un rapporto trimestrale sulla quantità e sull'importo dei beni acquistati per il 2011:
SELECT kvartal, SUM(somma_risultato) AS Totale
DA (SELECT importo*prezzo AS somma_risultato, mese(gg) AS m,
INTERRUTTORE(m =10,4) COME kvartal
DA m_reddito DOVE anno(dt)=2011) AS t
GRUPPO PER trimestre;
Domanda Q051. La seguente query aiuta a scoprire se gli utenti sono stati in grado di inserire nel sistema informazioni sul consumo di beni in un importo superiore alla quantità di beni ricevuti:
SELECT id_prodotto, SUM(somma_in) AS somma_reddito, SUM(somma_uscita) AS somma_risultato
FROM (SELECT product_id, amount*price come in_sum, 0 come out_sum
da m_reddito
UNIONE TUTTI
SELEZIONA product_id, 0 come in_sum, importo*prezzo come out_sum
da m_risultato) AS t
GRUPPO PER ID_prodotto
HAVING SUM(somma_in)
Domanda Q052. La numerazione delle righe restituite da una query viene implementata in diversi modi. Ad esempio, puoi rinumerare le righe di un report preparato in MS Access utilizzando lo stesso MS Access. Puoi anche rinumerare utilizzando linguaggi di programmazione, ad esempio VBA o PHP. Tuttavia, a volte è necessario farlo nella query SQL stessa. Pertanto, la seguente query numererà le righe della tabella m_income in base all'ordine crescente dei valori del campo ID:
SELECT COUNT(*) come N, b.id, b.product_id, b.amount, b.price
FROM m_reddito a INNER JOIN m_reddito b ON a.id GRUPPO PER b.id, b.product_id, b.importo, b.prezzo;
Domanda Q053. Vengono visualizzati i primi cinque prodotti tra i prodotti in base all'importo delle vendite. I primi cinque record vengono stampati utilizzando l'istruzione TOP:
SELEZIONA TOP 5, product_id, sum(amount*price) AS summa
DA m_risultato
GRUPPO PER ID_prodotto
ORDINA PER somma(importo*prezzo) DESC;
Domanda Q054. Vengono visualizzati i primi cinque prodotti tra i prodotti in base all'importo delle vendite e di conseguenza le righe vengono numerate:
SELECT COUNT(*) AS N, b.product_id, b.summa
DA
DA m_risultato GRUPPO PER id_prodotto) AS a
UNIONE INTERNA
(SELECT product_id, sum(amount*price) AS somma,
summa*10000000+id_prodotto ID AS
DA m_risultato GRUPPO PER id_prodotto) AS b
ON a.id>=b.id
GRUPPO PER b.id_prodotto, b.summa
AVERE COUNT(*)ORDINA PER COUNT(*);
Domanda Q055. La seguente query SQL mostra l'utilizzo delle funzioni matematiche COS, SIN, TAN, SQRT, ^ e ABS in MS Access SQL:
SELECT (select count(*) from m_income) come N, 3.1415926 come pi, k,
2*pi*(k-1)/N come x, COS(x) come COS_, SIN(x) come SIN_, TAN(x) come TAN_,
SQR(x) come SQRT_, x^3 come "x^3", ABS(x) come ABS_
DA (SELEZIONA CONTEGGIO (*) COME k
FROM m_reddito AS a INTERNO JOIN m_reddito AS b ON a.idGROUP BY b.id) t;
Interrogazione SQL. Esempi in MS Access. AGGIORNAMENTO: 1-10
Domanda U001. La seguente query di modifica SQL aumenta del 10% i prezzi delle merci con codice 3 nella tabella m_income:AGGIORNA m_reddito SET prezzo = prezzo*1.1
DOVE id_prodotto=3;
Richiedi U002. La seguente query di aggiornamento SQL aumenta di 22 unità la quantità di tutti i prodotti nella tabella m_income i cui nomi iniziano con la parola "Oil":
AGGIORNA m_reddito SET importo = importo+22
WHERE product_id IN (SELECT id FROM m_product WHERE titolo LIKE "Olio*");
Richiedi U003. La seguente query SQL per una modifica nella tabella m_outcome riduce del 2% i prezzi di tutti i beni prodotti da Sladkoe LLC:
AGGIORNA m_risultato SET prezzo = prezzo*0,98
DOVE product_id IN
(SELEZIONA a.id DA m_prodotto a INNER JOIN m_fornitore b
ON a.supplier_id=b.id DOVE b.title="LLC"Сладкое"");. !}
Inserimento, cancellazione, aggiornamento di record in un database
Il metodo ExecuteReader() recupera un oggetto lettore dati che consente di visualizzare i risultati dell'istruzione SQL Select utilizzando un flusso di informazioni di sola lettura. Tuttavia, se è necessario eseguire istruzioni SQL che modificano la tabella dati, è necessario chiamare il metodo EseguiNonQuery() di questo oggetto squadre. Questo singolo metodo è progettato per eseguire inserimenti, modifiche ed eliminazioni, a seconda del formato del testo del comando.
Concetto nonquery indica un'istruzione SQL che non restituisce un set di risultati. Quindi, Seleziona le dichiarazioni sono query, ma le istruzioni Insert, Update ed Elimina non lo sono. Di conseguenza, il metodo ExecuteNonQuery() restituisce un int contenente il numero di righe interessate da queste istruzioni, anziché un nuovo set di record.
Per mostrare come modificare il contenuto di un database esistente utilizzando solo la query ExecuteNonQuery(), il passaggio successivo consiste nel creare la propria libreria di accesso ai dati che incapsula il processo del database AutoLot.
In un ambiente di produzione reale, la logica ADO.NET sarà quasi certamente isolata in un assembly .NET .dll per un semplice motivo: il riutilizzo del codice! Questo non è stato fatto negli articoli precedenti per non distrarti dai compiti da svolgere. Ma sarebbe una perdita di tempo sviluppare la stessa logica di connessione, la stessa logica di lettura dei dati e la stessa logica di esecuzione dei comandi per ogni applicazione che deve funzionare con il database AutoLot.
Isolando la logica di accesso ai dati in una libreria di codici .NET, diverse applicazioni con qualsiasi interfaccia utente (in stile console, desktop, Web e così via) possono accedere alla libreria esistente, anche indipendentemente dalla lingua. E se sviluppi una libreria di accesso ai dati in C#, altri programmatori .NET saranno in grado di crearne una propria interfacce utente in qualsiasi linguaggio (ad esempio, VB o C++/CLI).
La nostra libreria di accesso ai dati (AutoLotDAL.dll) conterrà un singolo spazio dei nomi (AutoLotConnectedLayer) che interagirà con il database AutoLot utilizzando i tipi connessi ADO.NET.
Inizia creando un nuovo progetto di libreria di classi C# denominato AutoLotDAL (abbreviazione di "AutoLot Data Access Layer"), quindi modifica il nome del file di codice C# originale in AutoLotConnDAL.cs.
Quindi rinominare l'ambito dello spazio dei nomi in AutoLotConnectedLayer e modificare il nome della classe originale in InventoryDAL, perché questa classe definirà vari membri progettati per interagire con la tabella Inventory del database AutoLot. Infine, importa i seguenti spazi dei nomi .NET:
Utilizzo del sistema; utilizzando System.Collections.Generic; utilizzando System.Text; utilizzando System.Data; utilizzando System.Data.SqlClient; spazio dei nomi AutoLotConnectedLayer (classe pubblica InventoryDAL ())
Aggiunta della logica di connessione
Il nostro primo compito è definire metodi che consentano al processo chiamante di connettersi e disconnettersi dall'origine dati utilizzando una stringa di connessione valida. Poiché l'assembly AutoLotDAL.dll sarà codificato per utilizzare i tipi di classe System.Data.SqlClient, definire una variabile SqlConnection privata che verrà allocata quando viene creato l'oggetto InventoryDAL.
Inoltre, definisci un metodo OpenConnection() e poi un altro CloseConnection() che interagirà con questa variabile:
Classe pubblica InventoryDAL ( private SqlConnection connect = null; public void OpenConnection(string ConnectionString) ( connect = new SqlConnection(connectionString); connect.Open(); ) public void CloseConnection() ( connect.Close(); ) )
Per brevità, il tipo InventoryDAL non controllerà tutte le possibili eccezioni e non genererà eccezioni personalizzate quando si verificano varie situazioni (ad esempio, quando la stringa di connessione non ha un formato corretto). Tuttavia, se stessi creando una libreria di accesso ai dati di produzione, probabilmente dovresti utilizzare tecniche strutturate di gestione delle eccezioni per tenere conto di eventuali anomalie che potrebbero verificarsi in fase di esecuzione.
Aggiunta della logica di inserimento
Inserire Nuovo arrivato alla tabella Inventory si riduce alla formattazione dell'istruzione SQL Inserire(a seconda dell'input dell'utente) e chiamando il metodo ExecuteNonQuery() utilizzando l'oggetto comando. Per fare ciò, aggiungi un metodo pubblico InsertAuto() alla classe InventoryDAL che accetta quattro parametri che corrispondono alle quattro colonne della tabella Inventory (CarID, Color, Make e PetName). Sulla base di questi argomenti, genera una riga per aggiungere una nuova voce. Infine, esegui l'istruzione SQL utilizzando l'oggetto SqlConnection:
Public void InsertAuto(int id, string color, string make, string petName) ( // Istruzione SQL string sql = string.Format("Inserisci nell'inventario" + "(CarID, Make, Color, PetName) Values(@CarId, @Make, @Color, @PetName)"); using (SqlCommand cmd = new SqlCommand(sql, this.connect)) ( // Aggiungi parametri cmd.Parameters.AddWithValue("@CarId", id); cmd.Parameters.AddWithValue("@Make", make); cmd. Parametri.AddWithValue("@Color", colore); cmd.Parameters.AddWithValue("@PetName", petName); cmd.ExecuteNonQuery(); ) )
La definizione di classi che rappresentano i record in un database relazionale è un modo comune per creare una libreria di accesso ai dati. Infatti, ADO.NET Entity Framework genera automaticamente classi fortemente tipizzate che consentono di interagire con i dati del database. A proposito, il livello autonomo di ADO.NET genera oggetti DataSet fortemente tipizzati per rappresentare i dati di una determinata tabella in un database relazionale.
La creazione di un'istruzione SQL utilizzando la concatenazione di stringhe può rappresentare un rischio per la sicurezza (si pensi agli attacchi di inserimento SQL). È meglio creare il testo del comando utilizzando una query con parametri, che verrà descritta più avanti.
Aggiunta della logica di eliminazione
Rimozione registrazione esistente non più difficile dell'inserimento di un nuovo record. A differenza del codice InsertAuto(), verrà mostrata un'importante area try/catch che gestisce la possibile situazione in cui viene effettuato un tentativo di rimuovere un'auto che qualcuno ha già ordinato dalla tabella Clienti. Aggiungi il seguente metodo alla classe InventoryDAL:
Public void DeleteCar(int id) ( string sql = string.Format("Elimina dall'inventario dove CarID = "(0)"", id); utilizzando (SqlCommand cmd = new SqlCommand(sql, this.connect)) ( try ( cmd.ExecuteNonQuery(); ) catch (SqlException ex) ( Errore di eccezione = new Exception("Siamo spiacenti, questa macchina è in ordine arretrato!", ex); lancia errore; ) ) )
Aggiunta di una logica di cambiamento
Quando si tratta di aggiornare un record esistente nella tabella Inventario, sorge immediatamente la domanda ovvia: cosa può essere consentito di modificare esattamente il processo di chiamata: il colore dell'auto, il nome descrittivo, il modello o tutti e tre? Un modo per massimizzare la flessibilità è definire un metodo che accetta un parametro di tipo stringa, che può contenere qualsiasi istruzione SQL, ma questo è a dir poco rischioso.
Idealmente, è meglio disporre di un insieme di metodi che consentano al processo chiamante di modificare i record diversi modi. Tuttavia, per la nostra semplice libreria di accesso ai dati, definiremo un singolo metodo che consente al processo chiamante di modificare il nome descrittivo dell'auto specificata:
Public void UpdateCarPetName(int id, string newpetName) ( string sql = string.Format("Aggiorna Inventory Set PetName = "(0)" Where CarID = "(1)"", newpetName, id); utilizzando (SqlCommand cmd = new SqlCommand(sql, this.connect)) ( cmd.ExecuteNonQuery(); ) )
Aggiunta della logica di campionamento
Ora dobbiamo aggiungere un metodo per selezionare i record. Come mostrato in precedenza, l'oggetto lettore dati di uno specifico fornitore di dati consente di selezionare i record utilizzando un cursore di sola lettura. Chiamando il metodo Read() è possibile elaborare ciascun record uno alla volta. È tutto fantastico, ma ora dobbiamo capire come restituire questi record al livello dell'applicazione chiamante.
Un approccio potrebbe essere quello di recuperare i dati utilizzando il metodo Read() e quindi popolare e restituire un array multidimensionale (o un altro oggetto come il generico List
Un altro modo consiste nel restituire un oggetto System.Data.DataTable, che in realtà appartiene al livello ADO.NET autonomo. DataTable è una classe che rappresenta un blocco tabellare di dati (come un foglio di carta o un foglio di calcolo).
La classe DataTable contiene i dati come raccolta di righe e colonne. Queste raccolte possono essere popolate a livello di codice, ma il tipo DataTable dispone di un metodo Load() che può popolarle automaticamente utilizzando un oggetto lettore dati! Ecco un esempio in cui i dati della tabella Inventory vengono restituiti come DataTable:
Public DataTable GetAllInventoryAsDataTable() ( DataTable inv = new DataTable(); string sql = "Seleziona * Dall'inventario"; utilizzando (SqlCommand cmd = new SqlCommand(sql, this.connect)) ( SqlDataReader dr = cmd.ExecuteReader(); inv .Load(dr); dr.Close(); ) return inv; )
Lavorare con oggetti comando parametrizzati
Finora, nella logica di inserimento, aggiornamento ed eliminazione per il tipo InventoryDAL, abbiamo utilizzato valori letterali stringa hardcoded per ogni query SQL. Probabilmente sei a conoscenza dell'esistenza di query con parametri, che ti consentono di trattare i parametri SQL come oggetti anziché semplicemente come parti di testo.
Lavorare con le query SQL in un modo più orientato agli oggetti non solo aiuta a ridurre gli errori di battitura (con proprietà fortemente tipizzate), ma le query con parametri sono in genere molto più veloci delle query con stringhe letterali perché vengono analizzate solo una volta (anziché ogni volta), come accade quando la proprietà CommandText è impostata su una stringa SQL). Inoltre, le query parametrizzate proteggono dagli attacchi SQL injection (un noto problema di sicurezza dell'accesso ai dati).
Per supportare query con parametri, gli oggetti comando ADO.NET mantengono una raccolta di singoli oggetti parametro. Per impostazione predefinita, questa raccolta è vuota, ma puoi aggiungere un numero qualsiasi di oggetti parametro corrispondenti parametri segnaposto in una query SQL. Se è necessario associare un parametro di query SQL con un membro della raccolta di parametri di qualche oggetto comando, far precedere il parametro SQL con il simbolo @ (almeno quando si lavora con Microsoft server SQL, sebbene non tutti i DBMS supportino questa designazione).
Impostazione dei parametri utilizzando il tipo DbParameter
Prima di iniziare a creare query con parametri, acquisire familiarità con il tipo DbParameter (la classe base per gli oggetti parametro del provider). Questa classe dispone di una serie di proprietà che consentono di specificare il nome, la dimensione e il tipo del parametro, nonché altre caratteristiche, come la direzione di visualizzazione del parametro. Di seguito sono riportate alcune proprietà importanti del tipo DbParameter:
DbTypeOttiene o imposta il tipo di dati da un parametro, rappresentato come tipo CLR
DirezioneRestituisce o imposta il tipo di parametro: solo input, solo output, input e output o parametro per restituire un valore
IsNullableRestituisce o imposta se un parametro può accettare valori vuoti
NomeParametroOttiene o imposta il nome DbParameter
MisurareProblemi o installazioni taglia massima dati per il parametro (utile solo per dati di testo)
ValoreRestituisce o imposta il valore di un parametro
Per dimostrare come popolare una raccolta di oggetti comando con oggetti compatibili con DBParameter, riscriviamo il metodo InsertAuto() in modo che utilizzi oggetti parametro (tutti gli altri metodi possono essere rifatti in modo simile, ma il presente esempio sarà sufficiente per noi):
Public void InsertAuto(int id, string color, string make, string petName) ( // Istruzione SQL string sql = string.Format("Inserisci nell'inventario" + "(CarID, Make, Color, PetName) Values("(0) ","(1)","(2)","(3)")", id, make, color, petName); // Comando parametrizzato utilizzando (SqlCommand cmd = new SqlCommand(sql, this.connect)) ( SqlParameter param = new SqlParameter(); param.ParameterName = "@CarID"; param.Value = id; param.SqlDbType = SqlDbType.Int; cmd.Parameters.Add(param); param = new SqlParameter(); param. ParamName = "@Make"; param.Value = make; param.SqlDbType = SqlDbType.Char; param.Size = 10; cmd.Parameters.Add(param); param = new SqlParameter(); param.ParameterName = "@Color "; param.Value = colore; param.SqlDbType = SqlDbType.Char; param.Size = 10; cmd.Parameters.Add(param); param = new SqlParameter(); param.ParameterName = "@PetName"; param.Value = petName; param.SqlDbType = SqlDbType.Char; param.Size = 10; cmd.Parameters.Add(param); cmd.ExecuteNonQuery(); ) )
Tieni presente che la query SQL qui contiene anche quattro caratteri segnaposto, ciascuno preceduto da un simbolo @. Utilizzando la proprietà ParametroName sul tipo SqlParameter, è possibile descrivere ciascuno di questi segnaposto e specificare varie informazioni (valore, tipo di dati, dimensione e così via) in modo fortemente tipizzato. Dopo che tutti gli oggetti parametro sono stati preparati, vengono aggiunti alla raccolta di oggetti comando utilizzando la chiamata Add().
Qui vengono utilizzate varie proprietà per progettare oggetti parametro. Tuttavia, tieni presente che gli oggetti parametro supportano una serie di costruttori sovraccarichi che consentono di impostare i valori di varie proprietà (il che si traduce in una base di codice più compatta). Tieni inoltre presente che Visual Studio 2010 dispone di vari progettisti grafici che genereranno automaticamente gran parte di questo noioso codice di manipolazione dei parametri per te.
La creazione di una query con parametri spesso comporta la produzione di più codice, ma il risultato è un modo più pratico per ottimizzare a livello di codice le istruzioni SQL, nonché prestazioni migliori. Questa tecnica può essere utilizzata per qualsiasi query SQL, sebbene le query con parametri siano particolarmente utili se è necessario eseguire procedure memorizzate.
Regole parentesi quadre sta per [parte facoltativa] di un costrutto. Una barra verticale indica una scelta tra le opzioni (var1|var2). I puntini di sospensione indicano la possibile ripetizione più volte: 1 volta, 2 volte [, …]
Istruzione SELEZIONATA
Indica al motore di database di Microsoft Access di restituire le informazioni dal database come un insieme di record.
Sintassi
SELEZIONARE [ predicato] { * | tavolo.* | [tavolo.]campo1
[, [tavolo.]campo2 [, ...]]}
DA espressione_tabella [, ...]
L'istruzione SELECT include i seguenti elementi.
Elemento | Descrizione |
Predicato | Uno dei seguenti predicati: ALL, DISTINCT, DISTINCTROW o TOP. I predicati vengono utilizzati per limitare il numero di record restituiti. Se non viene fornito alcun predicato, il valore predefinito è ALL. |
Indica che tutti i campi sono selezionati dalla tabella o dalle tabelle specificate |
|
Tavolo | Il nome della tabella dai cui campi vengono selezionati i record |
campo1, campo2 | I nomi dei campi contenenti i dati da recuperare. Se vengono specificati più campi, i dati verranno recuperati nell'ordine in cui sono elencati i nomi |
soprannome1, soprannome2 | Nomi utilizzati come intestazioni di colonna anziché nomi di colonna originali tavoli |
espressione_tabella | Uno o più nomi di tabella contenenti i dati da recuperare. |
database_esterno | Il nome del database contenente le tabelle specificate nel componente espressione_tabella se non sono nel database corrente |
Appunti
Per eseguire questa operazione, il motore di database di Microsoft Access esegue la ricerca nelle tabelle specificate, recupera le colonne desiderate, seleziona le righe che soddisfano le condizioni specificate e ordina o raggruppa le righe risultanti nell'ordine specificato.
Le istruzioni SELECT non modificano i dati del database.
L'istruzione SELECT è solitamente la prima parola dell'istruzione SQL (istruzione SQL (stringa). Espressione che definisce comando SQL, come SELECT, UPDATE o DELETE e includendo clausole come WHERE o ORDER BY. Le istruzioni/stringhe SQL sono comunemente utilizzate nelle query e nelle funzioni statistiche.) La maggior parte delle istruzioni SQL sono istruzioni SELECT o istruzioni SELECT...INTO.
La sintassi minima per un'istruzione SELECT è la seguente:
SELEZIONARE campi DA tavolo
È possibile utilizzare un asterisco (*) per selezionare tutti i campi in una tabella. Nell'esempio seguente vengono selezionati tutti i campi nella tabella Employees.
SELEZIONA * DA Dipendenti;
Se il nome del campo è incluso in più tabelle nella clausola FROM, anteporlo con il nome della tabella e l'istruzione «.» (punto). Nell'esempio seguente il campo "Reparto" è presente nelle tabelle "Dipendenti" e "Supervisori". L'istruzione SQL seleziona i reparti dalla tabella Dipendenti e i nomi dei supervisori dalla tabella Supervisori.
SELEZIONA Dipendenti. Dipartimento, capi. Nome del dirigente DA Dipendenti INNER JOIN Dirigenti DOVE Dipendenti. Dipartimento = Dirigenti. Dipartimento;
Quando si crea un oggetto RecordSet, il nome del campo della tabella viene utilizzato dal motore di database di Microsoft Access come nome dell'oggetto "Campo" nell'oggetto Set di record. Se il nome del campo deve essere modificato o non è fornito dall'espressione che genera il campo, utilizzare una parola riservata (Parola riservata. Una parola che è un elemento di un linguaggio, come Visual Basic. Le parole riservate includono nomi di istruzioni, funzioni integrate e tipi di dati, metodi, operatori e oggetti.) AS. L'esempio seguente mostra come viene utilizzata l'intestazione "Day" per denominare l'oggetto restituito Campo nell'oggetto ricevuto Set di record.
SELEZIONA Compleanno COME Giorno DA Dipendenti;
Quando si lavora con funzioni o query aggregate che restituiscono nomi di oggetti ambigui o identici Campo, dovresti utilizzare la clausola AS per creare un nome oggetto diverso Campo. Nell'esempio seguente, l'oggetto restituito Campo nell'oggetto ricevuto Set di record prende il nome di "Censimento".
SELECT COUNT(EmployeeCode) AS Censimento FROM Dipendenti;
Quando si lavora con un'istruzione SELECT, è possibile utilizzare clausole aggiuntive per limitare e organizzare ulteriormente i dati recuperati. Per ulteriori informazioni, consulta l'argomento della guida relativo all'offerta che stai utilizzando.
clausola FROM
Specifica le tabelle e le query che contengono i campi elencati nell'istruzione SELECT.
Sintassi
SELEZIONARE field_list
DA espressione_tabella
Un'istruzione SELECT contenente una clausola FROM include i seguenti elementi:
Elemento | Descrizione |
field_list | |
espressione_tabella | Un'espressione che definisce una o più tabelle: origini dati. L'espressione può essere un nome di tabella, un nome di query memorizzata o un'espressione di risultato costruita utilizzando un operatore INNER JOIN, LEFT JOIN o RIGHT JOIN |
database_esterno | Il percorso completo del database esterno contenente tutte le tabelle specificate in espressione_tabella |
Appunti
È richiesta la presenza di una clausola FROM dopo un'istruzione SELECT.
L'ordine in cui sono elencate le tabelle espressione_tabella non importa.
Utilizzo di tabelle collegate (Tabella collegata. Una tabella salvata in un file che non fa parte del database aperto ma è accessibile da Microsoft Access. L'utente può aggiungere, eliminare e modificare i record nella tabella collegata, ma non può modificarne la struttura .) invece della clausola IN, puoi rendere il processo di recupero dei dati da un database esterno più semplice ed efficiente.
L'esempio seguente mostra come recuperare i dati dalla tabella Employees.
SELEZIONARE Cognome, Nome
DA Dipendenti;
Indica i record selezionati per le query SQL ( linguaggio SQL(Structured Query Language). Un linguaggio di programmazione di query e database strutturato ampiamente utilizzato per l'accesso, l'interrogazione, l'aggiornamento e la gestione dei dati nei DBMS relazionali.
Sintassi
SELEZIONARE ]]
DA tavolo
L'istruzione SELECT contenente questi predicati include i seguenti componenti:
Componente | Descrizione |
Implicito se non sono inclusi predicati. Il motore di database di Microsoft Access seleziona tutti i record che soddisfano le condizioni di un'istruzione SQL (istruzione SQL (stringa). Un'espressione che definisce un comando SQL, come SELECT, UPDATE o DELETE, e include clausole, come WHERE o ORDER BY .Le istruzioni/stringhe SQL vengono generalmente utilizzate nelle query e nelle funzioni statistiche). I due esempi identici seguenti mostrano come restituire tutti i record dalla tabella Employees. DA Dipendenti ORDINA PER CodiceImpiegato; DA Dipendenti ORDINA PER CodiceImpiegato; |
|
Esclude i record che contengono dati duplicati nei campi selezionati. Nei risultati della query vengono inclusi solo i valori univoci di ciascuno dei campi elencati nell'istruzione SELECT. Ad esempio, alcuni dipendenti elencati nella tabella Dipendenti potrebbero avere lo stesso cognome. Se due record contengono il cognome "Ivanov" nel campo Cognome, la seguente istruzione SQL restituisce solo un record contenente il cognome "Ivanov". SELEZIONA Cognome DISTINTO Se il componente DISTINCT viene omesso, la query restituisce entrambi i record con il cognome "Ivanov". Se la clausola SELECT contiene più campi, la combinazione di tutti i valori dei campi viene inclusa nei risultati della query solo se è univoca per quel record. I risultati di una query che utilizza il componente DISTINCT non vengono aggiornati per riflettere le modifiche successive apportate da altri utenti. |
|
Esclude i dati dai record che vengono ripetuti nella loro interezza anziché contenere singoli campi con gli stessi dati. Supponiamo che sia stata creata una query che collega le tabelle “Clienti” e “Ordini” utilizzando il campo “Codice Cliente”. La tabella Clienti non contiene campi ID cliente duplicati, ma esistono nella tabella Ordini perché ogni cliente può avere più ordini. La seguente istruzione SQL mostra come utilizzare il componente DISTINCTROW per elencare le organizzazioni che hanno effettuato almeno un ordine, senza menzionare i dettagli di tali ordini. SELEZIONA DISTINCTROW Titolo DA Clienti INNER JOIN Ordini ON Clienti. CustomerId = Ordini. Codice cliente ORDINA PER Titolo; Se il componente DISTINCTROW viene omesso, la query restituisce più righe per ciascuna organizzazione che ha effettuato più ordini. Il componente DISTINCTROW ha effetto solo quando si selezionano i campi da alcune delle tabelle utilizzate nella query. Il componente DISTINCTROW viene ignorato se la query include solo una tabella o se i campi vengono recuperati da tutte le tabelle. |
|
SUPERIORE N | Restituisce il numero specificato di record compresi tra i primi o gli ultimi record nell'intervallo specificato dalla clausola ORDER BY. Supponiamo che tu voglia visualizzare i nomi dei 25 migliori studenti della classe del 1994. Nome e cognome DOVE Anno di Laurea = 2003 ORDINA PER GradoPuntoMedia DESC; Se non includi la clausola ORDER BY, la query restituirà un set casuale di 25 record dalla tabella Studenti che soddisfa la clausola WHERE. Il predicato TOP non implica una scelta tra valori uguali. Se il 25° e il 26° record dell'esempio precedente avessero lo stesso GPA, la query restituirebbe 26 record. È inoltre possibile utilizzare la parola riservata PERCENT per recuperare una percentuale del primo o dell'ultimo record nell'intervallo specificato dalla clausola ORDER BY. Supponiamo che invece dei primi 25, si voglia visualizzare il 10% degli studenti più poveri della classe di laurea. SELEZIONA I PRIMI 10 PERCENTO Nome e cognome DOVE Anno di Laurea = 2003 ORDINA PER GradoPuntoMedia ASC; Il predicato ASC specifica l'output dei valori dalla parte inferiore dell'intervallo. Il valore che segue il predicato TOP deve essere un tipo di dati Integer. Il tipo di dati di base utilizzato per memorizzare valori interi. Una variabile Integer viene archiviata come numero a 64 bit (8 byte) nell'intervallo da -32768 a 32767. ) senza segno . Il predicato TOP non influisce sulla possibilità di aggiornamento della query. |
tavolo | Il nome della tabella da cui vengono recuperati i record. |
Guarda anche
Istruzione SELEZIONATA
clausola FROM
Dove la clausola
Determina quali record delle tabelle elencate nella clausola FROM vengono elaborati dalle istruzioni SELECT, UPDATE o DELETE.
Sintassi
SELEZIONARE field_list
DA espressione_tabella
DOVE condizioni_selezione
Un'istruzione SELECT contenente una clausola WHERE include le seguenti parti.
Parte | Descrizione |
field_list | Il nome del campo o dei campi recuperati insieme a eventuali alias (Alias (SQL). Un nome alternativo per una tabella o un campo in un'espressione. Gli alias vengono generalmente utilizzati come nomi di tabelle o campi più brevi per facilitare il riferimento successivo in programmi, per evitare riferimenti ambigui e per ottenere nomi più descrittivi durante la visualizzazione dei risultati delle query.), predicati (ALL, DISTINCT, DISTINCTROW o TOP) o con qualsiasi altro parametro dell'istruzione SELECT. |
espressione_tabella | Il nome della tabella o delle tabelle da cui vengono recuperati i dati. |
condizioni_selezione | Espressione (Espressione. Una combinazione di operatori matematici e logici, costanti, funzioni, nomi di campi, controlli e proprietà che genera un singolo valore. L'espressione può eseguire calcoli, elaborare testo o convalidare dati.) che deve corrispondere ai record inclusi nei risultati della query. |
Appunti
Il motore di database di Microsoft Access seleziona i record che soddisfano le condizioni elencate nella clausola WHERE. Se la clausola WHERE non è specificata, la query restituisce tutte le righe della tabella. Se una query specifica più tabelle ma non specifica una clausola WHERE o JOIN, la query produce un prodotto cartesiano (prodotto cartesiano. È il risultato dell'esecuzione di un'istruzione SQL SELECT che ha una clausola FROM che fa riferimento a due o più tabelle e nessuna clausola WHERE o Clausola JOIN che specifica il metodo di unione.) tabelle.
La clausola WHERE non è obbligatoria ma, se utilizzata, deve seguire la clausola FROM. È possibile selezionare ad esempio tutti i dipendenti del reparto vendite (WHERE Dipartimento = "Vendite") oppure tutti i clienti di età compresa tra 18 e 30 anni (WHERE Age Between 18 And 30).
Se una clausola JOIN non viene utilizzata per un'operazione di join SQL su più tabelle, l'oggetto risultante Set di record sarà impossibile aggiornare.
La clausola WHERE è simile alla clausola HAVING e specifica i record selezionati. Dopo che i record sono stati raggruppati in base alla clausola GROUP BY, anche la clausola HAVING determina il record da visualizzare.
La clausola WHERE viene utilizzata per escludere i record che non devono essere raggruppati utilizzando la clausola GROUP BY.
Utilizzare varie espressioni per determinare quali record vengono restituiti dall'istruzione SQL. Ad esempio, la seguente istruzione SQL seleziona tutti i dipendenti il cui stipendio supera RUR.
SELECT Cognome, Stipendio FROM Dipendenti WHERE Stipendio > 21000;
La clausola WHERE può contenere fino a 40 espressioni collegate da operatori logici (ad esempio, E E O).
Se inserisci un nome di campo che contiene spazi o segni di punteggiatura, devi racchiuderlo tra parentesi quadre (). Ad esempio, una tabella dei dettagli del cliente potrebbe contenere informazioni su clienti specifici.
SELEZIONA [Ristorante preferito dal cliente]
Specificare un argomento condizioni_selezione, i valori letterali della data (Data letterale. Qualsiasi sequenza di caratteri in un formato valido, racchiusa tra segni numerici (#). I formati validi sono il formato della data specificato nelle impostazioni Lingua e standard e il formato data universale.) devono essere rappresentati nel formato statunitense , anche se viene utilizzato un formato data non statunitense.versione del motore di database di Microsoft Access. Ad esempio, la data "10 maggio 1996" viene scritta come 5/10/96 nel Regno Unito e 05/10/1996 in Russia. Ricordarsi di racchiudere i valori letterali della data tra segni numerici (#), come mostrato negli esempi seguenti.
Per trovare i record relativi al 10 maggio 1996 nel database del Regno Unito, utilizzare la seguente istruzione SQL:
SELEZIONA * FROM Ordini DOVE Data di spedizione = #10.05.1996#;
Puoi anche usare la funzione DataValore, riconoscendo i parametri internazionali, installato da Microsoft Windows®. Ad esempio, per la Russia usa questo codice:
SELECT * FROM Ordini WHERE Data di spedizione = DateValue("05/10/1996");
E il seguente codice è per il Regno Unito:
SELECT * FROM Ordini WHERE Data di spedizione = DateValue("10/5/96");
Nota. Se la colonna specificata nella riga dei criteri di selezione è di tipo GUID (ID replica (GUID). Un campo da 16 byte in un database Microsoft Access utilizzato per identificare in modo univoco la replica. I GUID vengono utilizzati per identificare repliche, set di repliche, tabelle, record e altri oggetti (nei database di Microsoft Access i codici GUID sono chiamati codici di replica), le condizioni di selezione utilizzano una sintassi leggermente diversa.
DOVE ID replica = (GUID (AB-CDEF0ABCDEF))
Assicurati che le parentesi e i trattini nidificati siano posizionati correttamente.
Pagina di origine: http://office. /ru-ru/access/HA.aspx? pid=CH
Clausola GRUPPO BY
Combina i record con gli stessi valori presenti nell'elenco di campi specificato in un unico record. Viene creato un valore di riepilogo per ciascun record se nell'istruzione SELECT è inclusa una funzione di aggregazione SQL, ad esempio Somma O Contare.
Sintassi
SELEZIONARE field_list
DA tavolo
DOVE selezione_condizione
Un'istruzione SELECT contenente una clausola GROUP BY include i seguenti elementi:
Elemento | Descrizione |
field_list | I nomi dei campi recuperati insieme a eventuali alias (Alias (SQL). Un nome alternativo per una tabella o un campo in un'espressione. Gli alias vengono generalmente utilizzati come nomi di tabelle o campi più brevi per facilitare il riferimento successivo nei programmi, per evitare riferimenti ambigui e per ottenere nomi più informativi durante la visualizzazione dei risultati delle query.) e statistici Funzioni SQL, predicati (ALL, DISTINCT, DISTINCTROW o TOP) o altri parametri dell'istruzione SELECT |
tavolo | |
condizioni_selezione | Condizione di selezione. Se l'istruzione contiene una clausola WHERE, dopo averla applicata ai record, i valori verranno raggruppati dal motore di database di Microsoft Access. |
group_field_list | group_field_list |
Appunti
La clausola GROUP BY è facoltativa.
Se le funzioni statistiche SQL non sono incluse nell'istruzione SELECT, i valori di riepilogo non vengono calcolati.
Valori del campo GROUP BY che sono Null (Null. Un valore che può essere immesso in un campo o utilizzato in espressioni e query per indicare dati mancanti o sconosciuti. In Visual Basic, la parola chiave Null specifica un valore Null. Alcuni campi, come come campi chiave primaria, non possono contenere valori Null.), sono raggruppati e non vengono omessi. Tuttavia, i valori Nullo non vengono valutati da nessuna delle funzioni statistiche SQL.
La clausola WHERE viene utilizzata per escludere le righe che non devono essere raggruppate. La clausola HAVING viene utilizzata per filtrare i record dopo il raggruppamento.
Campi dell'elenco di campi GROUP BY che non contengono il tipo di dati Memo (tipo di dati Campo Memo. Un tipo di dati di campo in un database Microsoft Access. Un campo MEMO può contenere fino a 65535 caratteri.) o Oggetto OLE (Tipo di dati campo Oggetto OLE" Un tipo di dati di campo utilizzato per salvare oggetti da altre applicazioni collegate o incorporate in un database di Microsoft Access.) può fare riferimento a qualsiasi campo in qualsiasi tabella specificata nella clausola FROM, anche se il campo non è incluso nell'istruzione SELECT. Per fare ciò è sufficiente avere almeno una funzione statistica SQL nell'istruzione SELECT. Il motore di database di Microsoft Access non consente il raggruppamento in base ai campi contenenti dati di campi MEMO o oggetti OLE.
Tutti i campi nell'elenco dei campi SELECT devono essere contenuti in una clausola GROUP BY o essere argomenti di una funzione di aggregazione SQL.
Guarda anche
Istruzione SELEZIONATA
Istruzione SELECT...INTO
Predica TUTTO, DISTINTO, DISTINTO, TOP
clausola FROM
AVERE offerta
Clausola ORDER BY
Dove la clausola
Funzioni statistiche SQL
Pagina di origine: http://office. /ru-ru/access/HA.aspx? pid=CH
AVERE offerta
Definisce i record raggruppati che dovrebbero apparire in un'istruzione SELECT con una clausola GROUP BY. Dopo che i record sono stati raggruppati dalla clausola GROUP BY, la clausola HAVING mostrerà quelli che soddisfano le sue condizioni.
Sintassi
SELEZIONARE field_list
DA tavolo
DOVE condizioni_di_selezione
RAGGRUPPA PER group_field_list
Un'istruzione SELECT contenente una clausola HAVING include i seguenti elementi:
Elemento | Descrizione |
field_list | I nomi dei campi caricati insieme agli eventuali alias (Alias (SQL). Un nome alternativo per una tabella o un campo in un'espressione. Gli alias vengono generalmente utilizzati come nomi di tabelle o campi più brevi per facilitare il riferimento successivo nei programmi, per evitare riferimenti ambigui e per ottenere nomi più informativi durante la visualizzazione dei risultati della query.) e funzioni statistiche SQL, predicati (ALL, DISTINCT, DISTINCTROW o TOP) o con altri parametri dell'istruzione SELECT. |
tavolo | Nome della tabella da cui vengono caricati i record |
selezione_condizione | Condizione di selezione. Se l'istruzione contiene una clausola WHERE, il motore di database di Microsoft Access raggrupperà i valori dopo averla applicata ai record. |
group_field_list | Nomi dei campi (fino a 10) utilizzati per raggruppare i record. L'ordine dei nomi in group_field_list determina il livello di raggruppamento, dal più alto al più basso |
condizione_gruppo | Un'espressione che specifica i record da visualizzare |
Appunti
La clausola HAVING è facoltativa.
La clausola HAVING è simile alla clausola WHERE che determina la selezione dei record. Dopo aver raggruppato i record con la clausola GROUP BY, la clausola HAVING determina i record da visualizzare.
SELEZIONA CodiceTipo,
Somma(InStock)
DA Prodotti
GRUPPO PER CodiceTipo
HAVING Sum(InStock) > 100 E Like "TEL*";
La clausola HAVING può contenere fino a 40 espressioni collegate da operatori logici come E E O.
Pagina di origine: http://office. /ru-ru/access/HA.aspx? pid=CH
Clausola ORDER BY
Ordina i record restituiti dalla query in ordine crescente o decrescente in base ai valori dei campi specificati.
Sintassi
SELEZIONARE field_list
DA tavolo
DOVE selezione_condizione
[, campo2 ][, ...]]]
Un'istruzione SELECT che contiene una clausola ORDER BY include i seguenti elementi.
Elemento | Descrizione |
field_list | I nomi dei campi recuperati insieme a eventuali alias (Alias (SQL). Un nome alternativo per una tabella o un campo in un'espressione. Gli alias vengono generalmente utilizzati come nomi di tabelle o campi più brevi per facilitare il riferimento successivo nei programmi, per evitare riferimenti ambigui e per ottenere nomi più informativi durante la visualizzazione dei risultati della query.) e funzioni statistiche SQL, predicati (ALL, DISTINCT, DISTINCTROW o TOP) o con altri parametri dell'istruzione SELECT. |
tavolo | Nome della tabella da cui vengono recuperati i record |
condizioni_selezione | Condizioni di selezione. Se l'istruzione contiene una clausola WHERE, dopo averla applicata ai record, il motore di database di Microsoft Access ordinerà i valori dei record |
campo1, campo2 | Nomi dei campi in base ai quali vengono ordinati i record. |
Appunti
La clausola ORDER BY è facoltativa. Dovrebbe essere utilizzato quando è necessario visualizzare i dati in forma ordinata.
L'ordinamento predefinito è (Ordinamento. Un modo per organizzare i dati in base ai valori e al tipo. I dati possono essere ordinati in ordine alfabetico, per valori numerici o per data. L'ordinamento può essere crescente (da 0 a 100, da A a Z) oppure discendente (da 100 a 0, da Z ad A).) ascendente (da A a Z, da 0 a 9). Gli esempi seguenti mostrano l'ordinamento dei nomi dei dipendenti in base al cognome.
SELEZIONARE Cognome, Nome
DA Dipendenti
ORDINA PER Cognome;
SELEZIONARE Cognome, Nome
DA Dipendenti
ORDINA PER Cognome ASC;
Per ordinare i campi in ordine decrescente (dalla Z alla A, da 9 a 0), aggiungere la parola riservata DESC al nome di ciascun campo. Nell'esempio seguente viene illustrato l'ordinamento in ordine decrescente in base agli stipendi dei dipendenti.
SELEZIONA Cognome, Stipendio
DA Dipendenti
ORDINA PER Stipendio DESC, Cognome;
Se si specificano i campi nella clausola ORDER BY che contengono dati di tipo campo MEMO (tipo di dati campo Memo. Un tipo di dati di campo in un database Microsoft Access. Un campo MEMO può contenere fino a 65.535 caratteri.) o campo oggetto OLE (campo oggetto OLE Tipo di dati di campo "Un tipo di dati di campo utilizzato per salvare oggetti da altre applicazioni collegate o incorporate in un database di Microsoft Access.), ciò genererà un errore. Il motore di database di Microsoft Access non può ordinare questi tipi di campo.
La clausola ORDER BY è in genere l'ultima clausola in un'istruzione SQL (istruzione SQL (stringa). Un'espressione che definisce un comando SQL, come SELECT, UPDATE o DELETE, e include clausole, come WHERE o ORDER BY. Istruzioni SQL /string sono comunemente usate nelle query e nelle funzioni statistiche.).
È possibile includere campi aggiuntivi nella clausola ORDER BY. I record vengono prima ordinati in base al campo specificato per primo nella clausola ORDER BY. I record con gli stessi valori nel primo campo vengono quindi ordinati in base al campo specificato dal secondo e così via.
Guarda anche
Istruzione SELEZIONATA
Istruzione SELECT...INTO
Predica TUTTO, DISTINTO, DISTINTO, TOP
clausola FROM
Clausola GRUPPO BY
AVERE offerta
Dove la clausola
Funzioni statistiche SQL
Pagina di origine: http://office. /ru-ru/access/HA.aspx? pid=CH
Operazione INNER JOIN
Unisce i record di due tabelle se i campi di connessione di queste tabelle contengono gli stessi valori.
Sintassi
DA Tabella 1 UNIONE INTERNA Tavolo 2 SU Tabella 1.campo1 confronto_operatore tabella2.campo2
L'operazione INNER JOIN è composta dai seguenti elementi:
Elemento | Descrizione |
Tabella 1, Tavolo 2 | Nomi delle tabelle contenenti i record da unire |
campo1, campo2 | Nomi dei campi da collegare. I campi non numerici devono essere dello stesso tipo di dati (Tipo di dati. Una caratteristica del campo che definisce il tipo di dati che il campo può contenere. I tipi di dati includono: Booleano, Intero, Lungo, Valuta, Singolo, Doppio, Data, Stringa, e Variant (impostazione predefinita).) e contengono dati dello stesso tipo. Tuttavia, i nomi di questi campi potrebbero essere diversi |
confronto_operatore | Qualsiasi operatore di confronto: (=,<, >, <=, >= o<>) |
