Inserarea, ștergerea, actualizarea înregistrărilor în baza de date. Cum se trimite o interogare la o bază de date folosind VBA Access Crearea de interogări sql în nume de acces
Lucrare de laborator nr 1
SQL: DATA EXTRACT - comandăSELECTAȚI
Scopul lucrării:
- familiarizați-vă cu instrucțiunile SQL;
- învață cum să creezi interogări SQL simple în Access folosind comanda SELECT;
· utilizarea operatorilor IN, BETWEEN, LIKE, IS NULL.
Exercițiu№1. Creați o interogare pentru a selecta în modul SQL toate valorile câmpurilor PRENUME și NUME din tabelul STUDENTI.
SELECTAȚI PRENUMELE, NUMELE
DE LA STUDENTI;
Exercițiu№2 . Creați o interogare pentru a selecta în modul SQL toate coloanele din tabelul STUDENTI.
SELECTAȚI *
DE LA STUDENTI;
Sarcina nr. 3. Creați o interogare pentru a selecta în modul SQL numele orașelor în care locuiesc elevii, informații despre care se află în tabelul DATE PERSONALE.
SELECTAȚI ORAȘUL DISTINCT
DIN [DATE PERSONALE];
Sarcina nr. 4. Creați o interogare de selecție în modul SQL care preia numele tuturor elevilor cu numele de familie Ivanov, informații despre care se află în tabelul STUDENTI.
SELECTAȚI NUMELE, PRENUMELE
DE LA STUDENTI
UNDE NUMELE="Ivanov";
Sarcina nr. 5. Creați o interogare de selecție în modul SQL pentru a obține numele și prenumele studenților care studiază în grupa UIT-22 pe o formă de educație bugetară.
SELECTAȚI NUMELE, PRENUMELE
DE LA STUDENTI
WHERE GROUP="UIT-22" AND BUDGET=true;
Sarcina nr. 6. Creați o interogare în modul SQL. pentru o mostră din tabelul de EXAMEN, informații despre elevii care au doar note 4 și 5.
SELECTAȚI *
DE LA [SCHIMBAREEXAMENE]
UNDENOTAIN(4,5);
Sarcina nr. 7. Creați un mod zanpoc și SQL pentru a selecta informații despre studenții care au nota 3 la examen la materia IOSU.
SELECTAȚI *
DE LA [SCHIMBAREEXAMENE]
UNDEARTICOL=" IOSU"ȘiNOTANu în (4,5);
Sarcina nr. 8. Creați o interogare în modul SQL pentru a selecta înregistrări pentru articolele ale căror ore sunt între 100 și 130.
SELECTAȚI *
DINARTICOLE
UNDECEASINTRE 100 SI 130;
Sarcina nr. 9. Creați o interogare în modul SQL pentru a selecta din tabelul STUDENTI informații despre elevii ale căror nume de familie încep, de exemplu, cu litera „C”.
SELECTAȚI *
DINELEVI
UNDENUME DE FAMILIECA"CU*";
Concluzie: Pe parcursul munca de laborator m-am familiarizat cu instrucțiunile SQL, am învățat cum să creați interogări SQL simple în Access folosind comanda SELECT folosind operatorii IN, BETWEEN, LIKE.
Această lecție este dedicată interogări SQL la baza de date pe Acces VBA. Ne vom uita la modul în care interogările INSERT, UPDATE, DELETE sunt făcute în baza de date în VBA și vom învăța, de asemenea, cum să obținem o anumită valoare dintr-o interogare SELECT.
Cei care programează în Acces VBAîn timp ce lucrați cu baza de date SQL Server, de foarte multe ori se confruntă cu o sarcină atât de simplă și necesară precum trimiterea unei interogări SQL către o bază de date, fie că este vorba de INSERT, UPDATE sau o simplă interogare SQL SELECT. Și din moment ce suntem programatori începători, ar trebui să putem face acest lucru, așa că astăzi vom face exact asta.
Am atins deja subiectul obținerii de date de la un server SQL, unde am scris cod în VBA pentru a obține aceste date, de exemplu, în articolul despre Încărcarea datelor într-un fișier text din MSSql 2008, sau am atins și un puțin în material Încărcarea datelor din Access într-un șablon Word și Excel.dar într-un fel sau altul, ne-am uitat la acest lucru superficial, iar astăzi îmi propun să vorbim despre asta mai detaliat.
Notă! Toate exemplele de mai jos sunt luate în considerare folosind proiectul Access 2003 ADP și baza de date MSSql 2008. Dacă nu știți ce este un proiect ADP, atunci am analizat acest lucru în materialul Cum să creați și să configurați un proiect Access ADP
Date sursă pentru exemple
Să presupunem că avem un tabel test_table, care va conține numerele și numele lunilor din an (interogările sunt executate folosind Studio de management)
CREATE TABLE .( NOT NULL, (50) NULL) ON GO
După cum am spus deja, vom folosi un proiect ADP configurat să funcționeze cu MS SQL 2008, în care am creat un formular de testare și am adăugat un buton de pornire cu o semnătură "Alerga", de care va trebui să ne testăm codul, de exemplu. Vom scrie tot codul în handlerul de evenimente " Apăsați butonul».
Interogări la baza de date INSERT, UPDATE, DELETE în VBA
Pentru a nu întârzia prea mult, să începem imediat, să presupunem că trebuie să adăugăm un rând la tabelul nostru de testare ( cod comentat)/
Private Sub start_Click() „Declară o variabilă pentru a stoca șirul de interogare Dim sql_query As String „Scrie interogarea de care avem nevoie în ea sql_query = „INSERT INTO test_table (id, name_mon) VALUES (“6”, „June”)” „Execute it DoCmd. RunSQL sql_query End Sub
În acest caz, cererea este executată utilizând parametrii actuali de conectare la baza de date. Putem verifica dacă datele au fost adăugate sau nu.
După cum puteți vedea, datele au fost introduse.
Pentru a șterge o linie scriem următorul cod.
Private Sub start_Click() „Declară o variabilă pentru a stoca șirul de interogare Dim sql_query As String „Scrie o interogare de ștergere în ea sql_query = „DELETE test_table WHERE id = 6” „Run it DoCmd.RunSQL sql_query End Sub
Dacă verificăm, vom vedea că linia dorită a fost ștearsă.
Pentru a actualiza datele, scrieți în variabila sql_query cerere de actualizare, sper că sensul este clar.
interogare SELECT la o bază de date în VBA
Aici lucrurile sunt puțin mai interesante decât cu alte constructe SQL.
În primul rând, să presupunem că trebuie să obținem toate datele din tabel și, de exemplu, le vom procesa și le vom afișa într-un mesaj și, desigur, le puteți folosi în alte scopuri, pentru aceasta scriem următoarele cod
Private Sub start_Click() „Declare variabile „Pentru un set de înregistrări din baza de date Dim RS As ADODB.Recordset „Query string Dim sql_query As String „Șir pentru afișarea datelor finale în mesajul Dim str As String „Creați un nou obiect pentru set de înregistrări RS = New ADODB .Recordset "Query line sql_query = "SELECT id, name_mon FROM test_table" "Rulează interogarea utilizând setările curente de conectare la proiect RS.open sql_query, CurrentProject.Connection, adOpenDynamic, adLockOptimistic "Buclă prin înregistrări în timp ce nu (RS.EOF) "Completați variabila pentru a afișa mesajul str = str & RS.Fields("id") & "-" & RS.Fields("name_mon") & vbnewline "mergi la următoarea înregistrare RS.MoveNext Wend „Ieșiți mesajul msgbox str End Sub
Aici folosim deja buclele de acces VBA pentru a itera toate valorile din setul nostru de înregistrări.
Dar destul de des este necesar să se obțină nu toate valorile dintr-un set de înregistrări, ci doar una, de exemplu, numele lunii prin codul său. Și pentru a face acest lucru, este cumva costisitor să folosim o buclă, așa că putem pur și simplu să scriem o interogare care va returna o singură valoare și să o accesăm, de exemplu, vom obține numele lunii folosind codul 5
Private Sub start_Click() „Declare variabile” Pentru un set de înregistrări din baza de date Dim RS As ADODB.Recordset „Query string Dim sql_query As String „String pentru a afișa valoarea finală Dim str As String „Creați un nou obiect pentru setul de înregistrări RS = Nou ADODB.Recordset "Query line sql_query = "SELECT name_mon FROM test_table WHERE id = 5" "Rulați interogarea folosind setările curente de conectare la proiect RS.open sql_query, CurrentProject.Connection, adOpenDynamic, adLockOptimistic "Obțineți valoarea noastră str = RS. Fields(0) msgbox str End Sub
Pentru universalitate, aici ne-am adresat deja nu prin numele celulei, ci prin indexul acesteia, i.e. 0, iar aceasta este prima valoare în Set de înregistrări, pana la urma am obtinut valoarea "Mai".
După cum puteți vedea, totul este destul de simplu. Dacă deseori trebuie să obțineți o anumită valoare din baza de date ( ca în ultimul exemplu), apoi recomand să scoateți tot codul într-o funcție separată (Cum se scrie o funcție în VBA Access 2003) cu un parametru de intrare, de exemplu, codul lunii ( dacă luăm în considerare exemplul nostru) și pur și simplu, acolo unde este necesar să afișăm această valoare, apelăm funcția de care avem nevoie cu parametrul necesar și gata, făcând acest lucru vom reduce semnificativ codul VBA și vom îmbunătăți percepția programului nostru.
Asta e tot pentru azi. Noroc!
Descrierea proiectului educațional „Magazin”Diagrama legăturii tabelului
Descrierea tabelelor
m_category - categorii de produse
m_venit - primire marfa
m_outcome - consumul de bunuri
m_product - director, descrieri de produse
m_supplier - director; informatii despre furnizor
m_unit - director; unitati
Pentru a testa practic exemplele date în acest material de instruire, trebuie să aveți următorul software:
Microsoft Access 2003 sau mai nou.
Interogare SQL în MS Access. start
Pentru a vedea conținutul tabelului, faceți dublu clic pe numele tabelului din panoul din stânga:
Pentru a comuta la modul de editare a câmpurilor de tabel, faceți clic panoul de sus selectați modul Design:
Pentru a afișa rezultatul unei interogări SQL, faceți dublu clic pe numele interogării din panoul din stânga:
Pentru a comuta la modul de editare a interogărilor SQL, selectați modul SQL din panoul superior:
Interogare SQL. Exemple în MS Access. SELECTARE: 1-10
Într-o interogare SQL, instrucțiunea SELECT este utilizată pentru a selecta din tabelele bazei de date.Interogare SQL Q001. Exemplu de interogare SQL pentru a obține numai câmpurile necesare în secvența dorită:
SELECT dt, product_id, amount
DIN m_venit;
Interogare SQL Q002.În acest exemplu de interogare SQL, caracterul asterisc (*) este folosit pentru a lista toate coloanele din tabelul m_product, cu alte cuvinte, pentru a obține toate câmpurile relației m_product:
SELECTAȚI *
FROM m_product;
CerereSQL Q003. Declarația DISTINCT este folosită pentru a elimina intrările duplicate și pentru a obține mai multe intrări unice:
SELECTAȚI DISTINCT ID_produs
DIN m_venit;
Interogare SQL Q004. Instrucțiunea ORDER BY este folosită pentru a sorta (ordona) înregistrările după valorile unui anumit câmp. Numele câmpului este specificat după instrucțiunea ORDER BY:
SELECTAȚI *
DIN m_venit
COMANDA DUPA pret;
Interogare SQL Q005. Instrucțiunea ASC este folosită ca o completare a instrucțiunii ORDER BY și servește la specificarea sortării crescătoare. Instrucțiunea DESC este utilizată în plus față de instrucțiunea ORDER BY și este folosită pentru a specifica sortarea descendentă. În cazul în care nu sunt specificate nici ASC, nici DESC, se presupune prezența ASC (implicit):
SELECTAȚI *
DIN m_venit
COMANDA PRIN dt DESC , pret;
Interogare SQL Q006. Pentru a selecta înregistrările necesare din tabel, se folosesc diverse expresii logice care exprimă condiția de selecție. Expresia booleană apare după instrucțiunea WHERE. Un exemplu de obținere a tuturor înregistrărilor din tabelul m_income pentru care valoarea sumei este mai mare de 200:
SELECTAȚI *
DIN m_venit
UNDE suma>200;
Interogare SQL Q007. Pentru exprimare conditii dificile utilizați operatorii logici AND (conjuncție), OR (disjuncție) și NOT (negație logică). Un exemplu de obținere din tabelul m_outcome a tuturor înregistrărilor pentru care valoarea sumei este 20 și valoarea prețului este mai mare sau egală cu 10:
Preț
DIN m_rezultat
WHERE suma=20 ȘI preț>=10;
Interogare SQL Q008. Pentru a uni date din două sau mai multe tabele, utilizați instrucțiunile INNER JOIN, LEFT JOIN, RIGHT JOIN. Următorul exemplu preia câmpurile dt, product_id, amount, price din tabelul m_income și câmpul titlu din tabelul m_product. Înregistrarea tabelului m_income este asociată cu înregistrarea tabelului m_product atunci când valoarea m_income.product_id este egală cu valoarea m_product.id:
ON m_income.product_id=m_product.id;
Interogare SQL Q009. Există două lucruri de remarcat în această interogare SQL: 1) textul pe care îl căutați este inclus ghilimele simple("); 2) data este dată în formatul #Lună/Zi/An#, ceea ce este valabil pentru MS Access. În alte sisteme, formatul de scriere a datei poate fi diferit. Un exemplu de afișare a informațiilor despre chitanță de lapte pe 12 iunie 2011. Vă rugăm să rețineți formatul de dată #6/12/2011#:
SELECT dt, product_id, title, amount, price
FROM m_income INNER JOIN m_product
WHERE title="Lapte" And dt=#6/12/2011#; !}
Interogare SQL Q010. Instrucțiunea BETWEEN este utilizată pentru a testa dacă o valoare aparține unui anumit interval. Un exemplu de interogare SQL care afișează informații despre produsele primite între 1 iunie și 30 iunie 2011:
SELECTAȚI *
FROM m_income INNER JOIN m_product
ON m_income.product_id=m_product.id
UNDE dt ÎNTRE #6/1/2011# Și #6/30/2011#;
Interogare SQL. Exemple în MS Access. SELECT: 11-20
O interogare SQL poate fi imbricată în alta. O subinterogare nu este altceva decât o interogare în cadrul unei interogări. De obicei, o subinterogare este utilizată în clauza WHERE. Dar există și alte moduri de a folosi subinterogări.Interogarea Q011. Sunt afișate informații despre produsele din tabelul m_product, ale căror coduri se află și în tabelul m_income:
SELECTAȚI *
DE LA m_product
WHERE id IN (SELECTARE ID_produs FROM m_venit);
Interogarea Q012. Este afișată o listă de produse din tabelul m_product, ale căror coduri nu se află în tabelul m_outcome:
SELECTAȚI *
DE LA m_product
WHERE id NOT IN (SELECTARE product_id FROM m_outcome);
Solicitați Q013. Această interogare SQL afișează o listă unică de coduri și nume de produse care se află în tabelul m_income, dar nu în tabelul m_outcome:
SELECTAȚI DISTINCT product_id, titlu
FROM m_income INNER JOIN m_product
ON m_income.product_id=m_product.id
WHERE product_id NOT IN (SELECTARE product_id FROM m_outcome);
Interogarea Q014. O listă unică de categorii ale căror nume încep cu litera M este afișată din tabelul m_category:
SELECTAȚI un titlu DISTINCT
DE LA m_produs
UNDE titlul LIKE „M*”;
Interogarea Q015. Un exemplu de efectuare a operațiunilor aritmetice asupra câmpurilor dintr-o interogare și redenumirea câmpurilor dintr-o interogare (alias). Acest exemplu calculează cheltuiala = cantitate*preț și profit pentru fiecare intrare de cheltuială de articol, presupunând că profitul este de 7% din vânzări:
suma*pret/100*7 AS profit
DIN m_rezultat;
Interogarea Q016. Prin analiza și simplificarea operațiilor aritmetice, puteți crește viteza de execuție a interogărilor:
SELECT dt, product_id, amount, price, amount*price AS outcome_sum,
sumă_rezultat*0,07 AS profit
DIN m_rezultat;
Solicitați Q017. Puteți utiliza instrucțiunea INNER JOIN pentru a uni date din mai multe tabele. În exemplul următor, în funcție de valoarea lui ctgry_id, fiecare intrare din tabelul m_income este asociată cu numele categoriei din tabelul m_category căreia îi aparține produsul:
SELECTAȚI c.titlu, b.titlu, dt, sumă, preț, sumă*preț AS income_sum
FROM (m_income AS a INNER JOIN m_product AS b ON a.product_id=b.id)
INNER JOIN m_category AS c ON b.ctgry_id=c.id
ORDENAREA PENTRU c.titlu, b.titlu;
Solicitați Q018. Funcții precum SUM - sumă, COUNT - cantitate, AVG - medie aritmetică, MAX - valoare maximă, MIN - valoare minimă sunt numite funcții agregate. Acceptă multe valori și după procesare returnează o singură valoare. Un exemplu de calcul al sumei produsului dintre câmpurile sumă și preț folosind funcția de agregare SUM:
SELECTAȚI SUMA(suma*preț) AS Total_Sum
DIN m_venit;
Interogarea Q019. Un exemplu de utilizare a mai multor funcții agregate:
SELECT Suma(suma) AS Amount_Sum, AVG(amount) AS Amount_AVG,
MAX(amount) AS Amount_Max, Min(amount) AS Amount_Min,
Count(*) AS Total_Number
DIN m_venit;
Solicitați Q020.În acest exemplu, se calculează cantitatea tuturor bunurilor cu codul 1, capitalizată în iunie 2011:
SELECT Sum(suma*preț) AS income_sum
DIN m_venit
WHERE product_id=1 ȘI dt ÎNTRE #6/1/2011# ȘI #6/30/2011#;.
Interogarea Q021. Următoarea interogare SQL calculează valoarea vânzărilor de articole cu codul 4 sau 6:
SELECTAȚI Suma(amount*price) ca rezultat_sum
DIN m_rezultat
WHERE product_id=4 SAU product_id=6;
Interogarea Q022. Se calculează câte bunuri cu codul 4 sau 6 au fost vândute la 12 iunie 2011:
SELECTAȚI Suma(suma*preț) AS rezultatul_sumă
DIN m_rezultat
WHERE (product_id=4 SAU product_id=6) ȘI dt=#6/12/2011#;
Interogarea Q023. Sarcina este aceasta. Calculați cantitatea totală de mărfuri din categoria „Produse de panificație” care au fost valorificate.
Pentru a rezolva această problemă, trebuie să operați cu trei tabele: m_income, m_product și m_category, deoarece:
- cantitatea si pretul bunurilor capitalizate sunt stocate in tabelul m_income;
- codul categoriei fiecărui produs este stocat în tabelul m_product;
- numele categoriei de titlu este stocat în tabelul m_category.
Pentru a rezolva această problemă vom folosi următorul algoritm:
- determinarea codului categoriei „Produse de panificatie” din tabelul m_category folosind o subinterogare;
- conectarea tabelelor m_income și m_product pentru a determina categoria fiecărui produs achiziționat;
- calculul sumei de primire (= cantitate*pret) pentru marfa al caror cod de categorie este egal cu codul definit de subinterogarea de mai sus.
SELECTAȚI
FROM m_product AS a INNER JOIN m_income AS b ON a.id=b.product_id
WHERE ctgry_id = (SELECT ID FROM m_category WHERE title="Produse de panificație"); !}
Interogarea Q024. Vom rezolva problema calculării cantității totale de bunuri capitalizate din categoria „Produse de panificație” folosind următorul algoritm:
- pentru fiecare intrare din tabelul m_income, în funcție de valoarea product_id-ului acestuia, din tabelul m_category, potriviți numele categoriei;
- selectați înregistrări pentru care categoria este „Produse de panificație”;
- se calculeaza suma chitantei = cantitate*pret.
FROM (m_product AS a INNER JOIN m_income AS b ON a.id=b.product_id)
WHERE c.title="Produse de panificație";
!}
Interogarea Q025. Acest exemplu calculează câte bunuri au fost consumate:
SELECTAȚI COUNT(product_id) AS product_cnt
FROM (SELECT DISTINCT product_id FROM m_outcome) AS t;
Interogarea Q026. Instrucțiunea GROUP BY este utilizată pentru a grupa înregistrările. În mod obișnuit, înregistrările sunt grupate după valoarea unuia sau mai multor câmpuri și se aplică o operațiune agregată fiecărui grup. De exemplu, următoarea interogare generează un raport privind vânzarea mărfurilor. Adică, se generează un tabel care conține numele bunurilor și suma pentru care au fost vândute:
SELECTează titlul, SUM(suma*preț) AS rezultatul_sumă
FROM m_product CA o INNER JOIN m_outcome AS b
ON a.id=b.product_id
GROUP BY titlu;
Cerere Q027. Raport de vânzări pe categorii. Adică, este generat un tabel care conține numele categoriilor de produse, suma totală pentru care au fost vândute produsele din aceste categorii și valoarea medie a vânzărilor. Funcția ROUND este utilizată pentru a rotunji valoarea medie la cea mai apropiată sutime (a doua cifră după separatorul zecimal):
SELECTAȚI titlul c., SUM(suma*preț) AS rezultatul_sumă,
ROUND(AVG(cantitate*preț),2) AS outcome_sum_avg
FROM (m_product AS a INNER JOIN m_outcome AS b ON a.id=b.product_id)
INNER JOIN m_category AS c ON a.ctgry_id=c.id
GROUP BY c.titlu;
Interogarea Q028. Numărul total și mediu al încasărilor sale este calculat pentru fiecare produs și afișează informații despre produsele ale căror încasări totale este de cel puțin 500:
SELECT produs_id, SUM(amount) AS amount_sum,
Rotunjite(Avg(amount),2) AS amount_avg
DIN m_venit
GROUP BY product_id
AVÂND Sumă(suma)>=500;
Interogarea Q029. Această interogare calculează pentru fiecare produs suma și media încasărilor efectuate în al doilea trimestru al anului 2011. Dacă suma totală a bonului de produs este de cel puțin 1000, atunci sunt afișate informații despre acest produs:
SELECTează titlul, SUM(suma*preț) AS income_sum
FROM m_income a INNER JOIN m_product b ON a.product_id=b.id
UNDE dt INTRE #4/1/2011# SI #6/30/2011#
GROUP BY titlu
AVÂND SUM(suma*preț)>=1000;
Interogarea Q030.În unele cazuri, trebuie să potriviți fiecare înregistrare a unui tabel cu fiecare înregistrare a altui tabel; care se numeşte produsul cartezian. Tabelul rezultat dintr-o astfel de conexiune se numeste masa lui Descartes. De exemplu, dacă un tabel A are 100 de înregistrări și tabelul B are 15 înregistrări, atunci tabelul lor cartezian va fi format din 100*15=150 de înregistrări. Următoarea interogare unește fiecare înregistrare din tabelul m_income cu fiecare înregistrare din tabelul m_outcome:
FROM m_venit, m_rezultat;
Interogarea Q031. Un exemplu de grupare a înregistrărilor după două câmpuri. Următoarea interogare SQL calculează pentru fiecare furnizor cantitatea și cantitatea de mărfuri primite de la acesta:
SUM(suma*preț) AS income_sum
Interogarea Q032. Un exemplu de grupare a înregistrărilor după două câmpuri. Următoarea interogare calculează pentru fiecare furnizor cantitatea și cantitatea produselor sale vândute de noi:
SELECT furnizor_id, product_id, SUM(amount) AS amount_sum,
GROUP BY furnizor_id, produs_id;
Interogarea Q033.În acest exemplu, cele două interogări de mai sus (q031 și q032) sunt folosite ca subinterogări. Rezultatele acestor interogări folosind metoda LEFT JOIN sunt combinate într-un singur raport. Următoarea interogare afișează un raport privind cantitatea și cantitatea de produse primite și vândute pentru fiecare furnizor. Vă rugăm să rețineți că, dacă un produs a fost deja primit, dar nu a fost încă vândut, atunci celula rezultat_sum pentru această intrare va fi goală. că această interogare este doar un exemplu de utilizare a interogărilor relativ complexe ca subinterogare. Performanța acestei interogări SQL cu o cantitate mare de date este discutabilă:
SELECTAȚI *
DIN
SUM(suma*preț) AS income_sum
ON a.product_id=b.id GROUP BY furnizor_id, product_id) AS a
LEFT JOIN
(SELECTAȚI ID-ul furnizorului, ID-ul produsului, SUM(amount) AS amount_sum,
SUM(sumă*preț) AS rezultat_sumă
FROM m_outcome CA un INNER JOIN m_product AS b
ON a.product_id=b.id GROUP BY furnizor_id, product_id) AS b
ON (a.product_id=b.product_id) ȘI (a.supplier_id=b.supplier_id);
Interogarea Q034.În acest exemplu, cele două interogări de mai sus (q031 și q032) sunt folosite ca subinterogări. Rezultatele acestor interogări folosind metoda RIGTH JOIN sunt combinate într-un singur raport. Următoarea interogare afișează un raport privind valoarea plăților fiecărui client în funcție de sistemele de plată pe care le-a folosit și de valoarea investițiilor pe care le-a făcut. Următoarea interogare afișează un raport privind cantitatea și cantitatea de produse primite și vândute pentru fiecare furnizor. Vă rugăm să rețineți că, dacă un produs a fost deja vândut, dar nu a sosit încă, atunci celula income_sum pentru această intrare va fi goală. Prezența unor astfel de celule goale este un indicator al unei erori în contabilitatea vânzărilor, deoarece înainte de vânzare este mai întâi necesar ca produsul corespunzător să sosească:
SELECTAȚI *
DIN
(SELECTAȚI ID-ul furnizorului, ID-ul produsului, SUM(amount) AS amount_sum,
SUM(suma*preț) AS income_sum
FROM m_income AS a INNER JOIN m_product AS b ON a.product_id=b.id
GROUP BY furnizor_id, produs_id) AS a
ÎNSCRIEȚI DREPT
(SELECTAȚI ID-ul furnizorului, ID-ul produsului, SUM(amount) AS amount_sum,
SUM(sumă*preț) AS rezultat_sumă
FROM m_outcome AS a INNER JOIN m_product AS b ON a.product_id=b.id
GROUP BY furnizor_id, produs_id) AS b
ON (a.supplier_id=b.supplier_id) ȘI (a.product_id=b.product_id);
Interogarea Q035. Este afișat un raport care arată valoarea veniturilor și cheltuielilor pe produs. Pentru a face acest lucru, se creează o listă de produse conform tabelelor m_income și m_outcome, apoi pentru fiecare produs din această listă se calculează suma veniturilor sale conform tabelului m_income și suma cheltuielilor sale conform tabelului m_outcome:
SELECT produs_id, SUM(in_amount) AS income_amount,
SUM(out_amount) AS outcome_amount
DIN
(SELECTARE ID_produs, suma AS in_amount, 0 AS Out_amount
DIN m_venit
UNIREA TOȚI
SELECT produs_id, 0 AS in_amount, suma AS out_amount
DIN m_rezultat) AS t
GROUP BY product_id;
Interogarea Q036. Funcția EXISTS returnează TRUE dacă setul transmis conține elemente. Funcția EXISTS returnează FALSE dacă setul care i-a fost transmis este gol, adică nu conține niciun element. Următoarea interogare afișează codurile de produs care sunt conținute în ambele tabele m_income și m_outcome:
SELECTAȚI DISTINCT ID_produs
FROM m_income AS a
WHERE EXISTS(SELECT product_id FROM m_outcome AS b
Interogarea Q037. Sunt afișate codurile de produs care sunt conținute atât în tabelele m_income, cât și în tabelul m_outcome:
SELECTAȚI DISTINCT ID_produs
FROM m_income AS a
WHERE product_id IN (SELECTARE product_id FROM m_outcome)
Interogarea Q038. Sunt afișate codurile de produs care sunt conținute în tabelul m_income, dar nu sunt incluse în tabelul m_outcome:
SELECTAȚI DISTINCT ID_produs
FROM m_income AS a
WHERE NU EXISTS(SELECT product_id FROM m_outcome AS b
UNDE b.product_id=a.product_id);
Interogarea Q039. Este afișată o listă de produse cu valoarea maximă a vânzărilor. Algoritmul este după cum urmează. Pentru fiecare produs se calculează valoarea vânzărilor sale. Apoi, se determină maximul acestor sume. Apoi, pentru fiecare produs, se calculează din nou suma vânzărilor sale și se afișează codul și suma vânzărilor de mărfuri a căror sumă a vânzărilor este egală cu maximul:
SELECTAȚI ID-ul_produsului, SUM(suma*preț) AS suma_sumă
DIN m_rezultat
GROUP BY product_id
AVÂND SUM(suma*preț) = (SELECT MAX(s_amount)
FROM (SELECT SUM(suma*preț) AS s_amount FROM m_rezultat GROUP BY product_id));
Interogarea Q040. Cuvânt rezervat IIF ( operator condițional) este folosit pentru a evalua o expresie booleană și pentru a efectua o acțiune în funcție de rezultat (adevărat sau fals). În exemplul următor, livrarea articolului este considerată „mică” dacă cantitatea este mai mică de 500. În caz contrar, adică cantitatea de primire este mai mare sau egală cu 500, livrarea este considerată „mare”:
SELECT dt, product_id, amount,
IIF(suma DIN m_venit;
Interogare SQL Q041.În cazul în care operatorul IIF este folosit de mai multe ori, este mai convenabil să îl înlocuiți cu operatorul SWITCH. Operatorul SWITCH (operator de selecție multiplă) este folosit pentru a evalua o expresie logică și a efectua o acțiune în funcție de rezultat. În exemplul următor, lotul livrat este considerat „mic” dacă cantitatea de mărfuri din lot este mai mică de 500. În caz contrar, adică dacă cantitatea de mărfuri este mai mare sau egală cu 500, lotul este considerat „mare ":
SELECT dt, product_id, amount,
SWITCH(cantitate =500,„mare”) marca AS
DIN m_venit;
Interogarea Q042.În următoarea cerere, dacă cantitatea de mărfuri din lotul primit este mai mică de 300, atunci lotul este considerat „mic”. În caz contrar, adică dacă valoarea condiției SELECT dt, product_id, amount,
IIF(suma IIF(suma DIN m_venit;
Interogare SQL Q043.În următoarea cerere, dacă cantitatea de mărfuri din lotul primit este mai mică de 300, atunci lotul este considerat „mic”. În caz contrar, adică dacă valoarea condiției SELECT dt, product_id, amount,
SWITCH(suma sumă suma>=1000,„mare”) marca AS
DIN m_venit;
Interogare SQL Q044.În următoarea interogare, vânzările sunt împărțite în trei grupuri: mici (până la 150), medii (de la 150 la 300), mari (300 sau mai mult). În continuare, se calculează suma totală pentru fiecare grup:
SELECT Categorie, SUM(suma_rezultat) AS Ctgry_Total
FROM (SELECT suma*preț AS rezultat_sumă,
IIf(suma*preț IIf(suma*preț FROM m_rezultat) AS t
GROUP BY Categorie;
Interogare SQL Q045. Funcția DateAdd este utilizată pentru a adăuga zile, luni sau ani la o dată dată și pentru a obține o nouă dată. Următoarea cerere:
1) adaugă 30 de zile la data din câmpul dt și afișează noua dată în câmpul dt_plus_30d;
2) adaugă 1 lună la data din câmpul dt și afișează noua dată în câmpul dt_plus_1m:
SELECT dt, dateadd("d",30,dt) AS dt_plus_30d, dateadd("m",1,dt) AS dt_plus_1m
DIN m_venit;
Interogare SQL Q046. Funcția DateDiff este concepută pentru a calcula diferența dintre două date în unități diferite (zile, luni sau ani). Următoarea interogare calculează diferența dintre data din câmpul dt și data curentă în zile, luni și ani:
SELECT dt, DateDiff("d",dt,Date()) AS ultima_zi,
DateDiff("m",dt,Date()) AS last_months,
DateDiff("aaaa", dt,Data()) AS anii_ultim
DIN m_venit;
Interogare SQL Q047. Numărul de zile de la data primirii mărfurilor (tabelul m_income) până la data curentă este calculat utilizând funcția DateDiff și se compară data de expirare (tabelul m_product):
DateDiff("d",dt,Date()) AS ultimele_zile
FROM m_income CA un INNER JOIN m_product AS b
ON a.product_id=b.id;
Interogare SQL Q048. Se calculează numărul de zile de la data primirii mărfurilor până la data curentă, apoi se verifică dacă această cantitate depășește data de expirare:
SELECT a.id, product_id, dt, lifedays,
DateDiff("d",dt,Date()) AS ultimele_zile, IIf(last_days>lifedays,"Yes","Nu") AS data_expire
FROM m_income a INNER JOIN m_product b
ON a.product_id=b.id;
Interogare SQL Q049. Se calculează numărul de luni de la data primirii mărfurilor până la data curentă. Coloana month_last1 calculează numărul absolut de luni, coloana month_last2 calculează numărul de luni întregi:
SELECT dt, DateDiff("m",dt,Date()) AS month_last1,
DateDiff("l",dt,Date())-iif(day(dt)>day(data()),1,0) AS month_last2
DIN m_venit;
Interogare SQL Q050. Este afișat un raport trimestrial privind cantitatea și cantitatea de bunuri achiziționate pentru anul 2011:
SELECT kvartal, SUM(outcome_sum) AS Total
FROM (SELECT suma*preț AS rezultat_sum, luna(dt) AS m,
SWITCH(m =10,4) AS kvartal
DIN m_venit WHERE an(dt)=2011) AS t
GRUPĂ PE trimestru;
Interogarea Q051. Următoarea interogare vă ajută să aflați dacă utilizatorii au putut introduce în sistem informații despre consumul de bunuri într-o cantitate mai mare decât cantitatea de bunuri primite:
SELECT produs_id, SUM(in_sum) AS income_sum, SUM(out_sum) AS outcome_sum
FROM (SELECT ID_produs, suma*preț ca în_sum, 0 ca out_sum
din m_income
UNIREA TOȚI
SELECTAȚI ID-ul_produsului, 0 ca sumă_intră, sumă*preț ca sumă_sumă
din m_rezultat) AS t
GROUP BY product_id
AVÂND SUM(în_sumă)
Interogarea Q052. Numerotarea rândurilor returnate de o interogare este implementată în moduri diferite. De exemplu, puteți renumerota rândurile unui raport pregătit în MS Access folosind MS Access însuși. De asemenea, puteți renumerota folosind limbaje de programare, de exemplu, VBA sau PHP. Cu toate acestea, uneori, acest lucru trebuie făcut în interogarea SQL în sine. Deci, următoarea interogare va numerota rândurile tabelului m_income în funcție de ordinea crescătoare a valorilor câmpului ID:
SELECTAȚI COUNT(*) ca N, b.id, b.product_id, b.amount, b.price
FROM m_income a INNER JOIN m_income b ON a.id GROUP BY b.id, b.product_id, b.amount, b.price;
Interogarea Q053. Sunt afișate primele cinci produse dintre produsele după valoarea vânzărilor. Primele cinci înregistrări sunt tipărite folosind instrucțiunea TOP:
SELECTARE TOP 5, product_id, sum(amount*price) AS summa
DIN m_rezultat
GROUP BY product_id
COMANDA PENTRU suma(suma*pret) DESC;
Interogarea Q054. Sunt afișate primele cinci produse dintre produse după valoarea vânzărilor, iar rândurile sunt numerotate ca rezultat:
SELECTARE COUNT(*) AS N, b.product_id, b.summa
DIN
FROM m_outcome GROUP BY product_id) AS a
INNER JOIN
(SELECTARE ID_produs, sum(cantitate*preț) AS summa,
suma*10000000+product_id AS id
FROM m_outcome GROUP BY product_id) AS b
ON a.id>=b.id
GROUP BY b.product_id, b.summa
AVÂND NUMĂRARE(*)ORDINARE PENTRU NUMĂRARE(*);
Interogarea Q055. Următoarea interogare SQL arată utilizarea funcțiilor matematice COS, SIN, TAN, SQRT, ^ și ABS în MS Access SQL:
SELECT (selectați count(*) din m_income) ca N, 3,1415926 ca pi, k,
2*pi*(k-1)/N ca x, COS(x) ca COS_, SIN(x) ca SIN_, TAN(x) ca TAN_,
SQR(x) ca SQRT_, x^3 ca „x^3”, ABS(x) ca ABS_
FROM (SELECT COUNT (*)) AS k
FROM m_income AS a INNER JOIN m_income AS b ON a.idGROUP BY b.id) t;
Interogare SQL. Exemple în MS Access. UPDATE: 1-10
Interogarea U001. Următoarea interogare de modificare SQL crește prețurile bunurilor cu codul 3 din tabelul m_income cu 10%:UPDATE m_income SET preț = preț*1.1
WHERE product_id=3;
Cerere U002. Următoarea interogare de actualizare SQL crește cantitatea tuturor produselor din tabelul m_income cu 22 de unități ale căror nume încep cu cuvântul „Ulei”:
UPDATE m_income SET suma = suma+22
WHERE product_id IN (SELECT ID FROM m_product WHERE titlul LIKE "Oil*");
Cerere U003. Următoarea interogare SQL pentru o modificare a tabelului m_outcome reduce prețurile tuturor bunurilor fabricate de Sladkoe LLC cu 2 procente:
UPDATE m_outcome SET preț = preț*0,98
WHERE product_id IN
(SELECT a.id FROM m_product a INNER JOIN m_supplier b
ON a.supplier_id=b.id WHERE b.title="LLC"Сладкое"");. !}
Inserarea, ștergerea, actualizarea înregistrărilor într-o bază de date
Metoda ExecuteReader() preia un obiect cititor de date care vă permite să vizualizați rezultatele instrucțiunii SQL Select folosind un flux de informații înainte de numai citire. Cu toate acestea, dacă trebuie să executați instrucțiuni SQL care modifică tabelul de date, atunci trebuie să apelați metoda ExecuteNonQuery() a acestui obiect echipe. Această metodă unică este concepută pentru a efectua inserări, modificări și ștergeri, în funcție de formatul textului comenzii.
Concept noninterogareînseamnă o instrucțiune SQL care nu returnează un set de rezultate. Prin urmare, Selectați declarații sunt interogări, dar instrucțiunile Insert, Update și Delete nu sunt. În consecință, metoda ExecuteNonQuery() returnează un int care conține numărul de rânduri afectate de aceste instrucțiuni, mai degrabă decât un nou set de înregistrări.
Pentru a arăta cum să modificați conținutul unei baze de date existente folosind doar interogarea ExecuteNonQuery(), următorul pas este să vă creați propria bibliotecă de acces la date care încapsulează procesul de bază de date AutoLot.
Într-un mediu de producție real, logica dvs. ADO.NET va fi aproape sigur izolată într-un ansamblu .NET .dll dintr-un motiv simplu - reutilizarea codului! Acest lucru nu a fost făcut în articolele anterioare pentru a nu vă distrage atenția de la sarcinile pe care le aveți la îndemână. Dar ar fi o pierdere de timp să dezvoltam aceeași logică de conectare, aceeași logică de citire a datelor și aceeași logică de execuție a comenzilor pentru fiecare aplicație care trebuie să funcționeze cu baza de date AutoLot.
Prin izolarea logicii de acces la date într-o bibliotecă de coduri .NET, diferite aplicații cu orice interfață utilizator (stil consolă, stil desktop, stil web etc.) pot accesa biblioteca existentă, chiar și indiferent de limbă. Și dacă dezvoltați o bibliotecă de acces la date în C#, atunci alți programatori .NET își vor putea crea propria lor bibliotecă. interfețe cu utilizatorulîn orice limbă (de exemplu, VB sau C++/CLI).
Biblioteca noastră de acces la date (AutoLotDAL.dll) va conține un singur spațiu de nume (AutoLotConnectedLayer) care va interacționa cu baza de date AutoLot folosind tipurile conectate ADO.NET.
Începeți prin a crea un nou proiect C# Class Library numit AutoLotDAL (prescurtare de la „AutoLot Data Access Layer”), apoi schimbați numele fișierului de cod C# original în AutoLotConnDAL.cs.
Apoi redenumiți domeniul de aplicare al spațiului de nume în AutoLotConnectedLayer și schimbați numele clasei originale în InventoryDAL, deoarece această clasă va defini diverși membri care să interacționeze cu tabelul de inventar al bazei de date AutoLot. În cele din urmă, importați următoarele spații de nume .NET:
Utilizarea sistemului; folosind System.Collections.Generic; folosind System.Text; folosind System.Data; folosind System.Data.SqlClient; spațiu de nume AutoLotConnectedLayer (clasa publică InventoryDAL ( ) )
Adăugarea logicii de conectare
Prima noastră sarcină este să definim metode care să permită procesului apelant să se conecteze și să se deconecteze de la sursa de date folosind un șir de conexiune valid. Deoarece ansamblul nostru AutoLotDAL.dll va fi codificat pentru a utiliza tipurile de clasă System.Data.SqlClient, definiți o variabilă SqlConnection privată care va fi alocată atunci când este creat obiectul InventoryDAL.
În plus, definiți o metodă OpenConnection() și apoi o altă CloseConnection() care va interacționa cu această variabilă:
Clasa publică InventoryDAL ( private SqlConnection connect = null; public void OpenConnection(string connectionString) ( connect = nou SqlConnection(connectionString); connect.Open(); ) public void CloseConnection() ( connect.Close(); ) )
Pentru concizie, tipul InventoryDAL nu va verifica toate excepțiile posibile și nu va arunca excepții personalizate atunci când apar diverse situații (de exemplu, când șirul de conexiune este malformat). Cu toate acestea, dacă ați construi o bibliotecă de acces la date de producție, probabil că va trebui să utilizați tehnici structurate de gestionare a excepțiilor pentru a lua în considerare orice anomalie care ar putea apărea în timpul execuției.
Adăugarea logicii de inserare
Introduce intrare nouă la tabelul de inventar se reduce la formatarea instrucțiunii SQL Introduce(în funcție de intrarea utilizatorului) și apelarea metodei ExecuteNonQuery() folosind obiectul de comandă. Pentru a face acest lucru, adăugați o metodă publică InsertAuto() la clasa InventoryDAL care ia patru parametri care corespund celor patru coloane ale tabelului Inventory (CarID, Color, Make și PetName). Pe baza acestor argumente, generați o linie pentru a adăuga o nouă intrare. În cele din urmă, executați instrucțiunea SQL folosind obiectul SqlConnection:
Public void InsertAuto(int id, culoarea șirului, marca șirului, șirul petName) ( // Declarație SQL string sql = string.Format("Insert Into Inventory" + "(CarID, Make, Color, PetName) Values(@CarId, @Make, @Color, @PetName)"); folosind (SqlCommand cmd = new SqlCommand(sql, this.connect)) ( // Adăugați parametri cmd.Parameters.AddWithValue("@CarId", id); cmd.Parameters.AddWithValue("@Make", make); cmd. Parameters.AddWithValue("@Color", culoare); cmd.Parameters.AddWithValue("@PetName", petName); cmd.ExecuteNonQuery(); ) )
Definirea claselor care reprezintă înregistrări într-o bază de date relațională este o modalitate comună de a crea o bibliotecă de acces la date. De fapt, ADO.NET Entity Framework generează automat clase puternic tipizate care vă permit să interacționați cu datele bazei de date. Apropo, stratul autonom al ADO.NET generează obiecte DataSet puternic tipizate pentru a reprezenta date dintr-un tabel dat într-o bază de date relațională.
Crearea unei instrucțiuni SQL folosind concatenarea șirurilor poate fi un risc de securitate (gândiți-vă la atacurile de inserare SQL). Este mai bine să creați textul comenzii folosind o interogare parametrizată, care va fi descrisă puțin mai târziu.
Adăugarea Ștergere logică
Îndepărtarea înregistrarea existentă nu mai dificil decât introducerea unei noi înregistrări. Spre deosebire de codul InsertAuto(), va fi afișată o zonă importantă de încercare/prindere care se ocupă de posibila situație în care se încearcă scoaterea unei mașini pe care cineva a comandat-o deja din tabelul Clienți. Adăugați următoarea metodă la clasa InventoryDAL:
Public void DeleteCar(int id) ( șir sql = șir.Format ("Ștergeți din inventar unde CarID = "(0)"", id); folosind (SqlCommand cmd = new SqlCommand(sql, this.connect)) ( încercați ( cmd.ExecuteNonQuery(); ) catch (SqlException ex) (Eroare de excepție = nouă Excepție ("Ne pare rău, această mașină este pe comandă înapoi!", ex); eroare de aruncare; ) ) )
Adăugarea logicii schimbării
Când vine vorba de actualizarea unei înregistrări existente în tabelul de inventar, apare imediat întrebarea evidentă: ce anume poate fi permis să schimbe procesul de apelare: culoarea mașinii, numele prietenos, modelul sau toate trei? O modalitate de a maximiza flexibilitatea este definirea unei metode care ia un parametru de tip șir, care poate conține orice instrucțiune SQL, dar acest lucru este cel puțin riscant.
În mod ideal, este mai bine să aveți un set de metode care să permită procesului de apelare să modifice înregistrările căi diferite. Cu toate acestea, pentru biblioteca noastră simplă de acces la date, vom defini o singură metodă care permite procesului de apelare să schimbe numele prietenos al mașinii specificate:
Public void UpdateCarPetName(int id, string newpetName) ( string sql = string.Format("Update Inventory Set PetName = "(0))" Unde CarID = "(1)"", newpetName, id); folosind (SqlCommand cmd = new SqlCommand(sql, this.connect)) ( cmd.ExecuteNonQuery(); ) )
Adăugarea logicii de eșantionare
Acum trebuie să adăugăm o metodă de selectare a înregistrărilor. După cum sa arătat mai devreme, obiectul cititor de date al unui anumit furnizor de date vă permite să selectați înregistrări folosind un cursor numai pentru citire. Apelând metoda Read(), puteți procesa fiecare înregistrare pe rând. Toate acestea sunt grozave, dar acum trebuie să ne dăm seama cum să returnăm aceste înregistrări la nivelul aplicației care apelează.
O abordare ar fi să preluați datele folosind metoda Read() și apoi să populați și să returnați o matrice multidimensională (sau un alt obiect precum lista generică
O altă modalitate este de a returna un obiect System.Data.DataTable, care aparține de fapt stratului ADO.NET autonom. DataTable este o clasă care reprezintă un bloc tabelar de date (cum ar fi o hârtie sau o foaie de calcul).
Clasa DataTable conține date ca o colecție de rânduri și coloane. Aceste colecții pot fi populate programatic, dar tipul DataTable are o metodă Load() care le poate popula automat folosind un obiect cititor de date! Iată un exemplu în care datele din tabelul Inventar sunt returnate ca DataTable:
Public DataTable GetAllInventoryAsDataTable() ( DataTable inv = new DataTable(); șir sql = „Selectați * din inventar”; folosind (SqlCommand cmd = new SqlCommand(sql, this.connect)) ( SqlDataReader dr = cmd.ExecutevReader(); .Load(dr); dr.Close(); ) return inv; )
Lucrul cu obiecte de comandă parametrizate
Până acum, în logica de inserare, actualizare și ștergere pentru tipul InventoryDAL, am folosit literale șir codificate greu pentru fiecare interogare SQL. Probabil că sunteți conștient de existența interogărilor parametrizate, care vă permit să tratați parametrii SQL ca obiecte, mai degrabă decât doar o bucată de text.
Lucrul cu interogări SQL într-un mod mai orientat pe obiecte nu numai că ajută la reducerea greșelilor de scriere (cu proprietăți puternic tastate), dar interogările parametrizate sunt de obicei mult mai rapide decât interogările literale cu șir, deoarece sunt analizate o singură dată (mai degrabă decât de fiecare dată). proprietatea CommandText este setată la un șir SQL). În plus, interogările parametrizate protejează împotriva atacurilor de injecție SQL (o problemă binecunoscută de securitate a accesului la date).
Pentru a suporta interogări parametrizate, obiectele de comandă ADO.NET mențin o colecție de obiecte parametri individuale. În mod implicit, această colecție este goală, dar puteți adăuga orice număr de obiecte parametri care se potrivesc parametrii substituentîntr-o interogare SQL. Dacă trebuie să asociați un parametru de interogare SQL cu un membru al colecției de parametri a unui obiect de comandă, precedați parametrul SQL cu simbolul @ (cel puțin atunci când lucrați cu Microsoft SQL Server, deși nu toate SGBD-urile acceptă această denumire).
Setarea parametrilor folosind tipul DbParameter
Înainte de a începe să creăm interogări parametrizate, să ne familiarizăm cu tipul DbParameter (clasa de bază pentru obiectele parametrilor furnizorului). Această clasă are o serie de proprietăți care vă permit să specificați numele, dimensiunea și tipul parametrului, precum și alte caracteristici, cum ar fi direcția de vizualizare a parametrului. Câteva proprietăți importante ale tipului DbParameter sunt prezentate mai jos:
DbTypeObține sau setează tipul de date dintr-un parametru, reprezentat ca tip CLR
DirecţieReturnează sau setează tipul de parametru: doar intrare, numai ieșire, intrare și ieșire sau parametru pentru a returna o valoare
Este NullabilReturnează sau stabilește dacă un parametru poate accepta valori goale
ParameterNameObține sau setează numele DbParameter
mărimeaProbleme sau instalări dimensiune maximă date pentru parametru (util doar pentru date text)
ValoareReturnează sau setează valoarea unui parametru
Pentru a demonstra cum să populați o colecție de obiecte de comandă cu obiecte compatibile cu DBParameter, să rescriem metoda InsertAuto() astfel încât să folosească obiecte parametri (toate celelalte metode pot fi refăcute în mod similar, dar exemplul de față va fi suficient pentru noi):
Public void InsertAuto(int id, string color, string make, string petName) ( // instrucțiune SQL șir sql = șir.Format("Insert Into Inventory" + "(CarID, Make, Color, PetName) Values("(0) ","(1)","(2)","(3)")", id, make, color, petName); // Comanda parametrizată folosind (SqlCommand cmd = new SqlCommand(sql, this.connect)) ( SqlParameter param = nou SqlParameter(); param.ParameterName = „@CarID”; param.Value = id; param.SqlDbType = SqlDbType.Int; cmd.Parameters.Add(param); param = nou SqlParameter(); param. ParameterName = „@Make”; param.Value = make; param.SqlDbType = SqlDbType.Char; param.Size = 10; cmd.Parameters.Add(param); param = new SqlParameter(); param.ParameterName = „@Color "; param.Value = culoare; param.SqlDbType = SqlDbType.Char; param.Size = 10; cmd.Parameters.Add(param); param = nou SqlParameter(); param.ParameterName = "@PetName"; param.Value = petName; param.SqlDbType = SqlDbType.Char; param.Size = 10; cmd.Parameters.Add(param); cmd.ExecuteNonQuery(); ) )
Rețineți că interogarea SQL de aici conține și patru caractere substituenți, fiecare precedat de un simbol @. Folosind proprietatea ParameterName de pe tipul SqlParameter, puteți descrie fiecare dintre acești substituenți și puteți specifica diverse informații (valoare, tip de date, dimensiune etc.) într-o manieră puternic tipizată. După ce toate obiectele parametri sunt pregătite, acestea sunt adăugate la colecția de obiecte de comandă folosind apelul Add().
Aici sunt folosite diferite proprietăți pentru a proiecta obiecte parametri. Cu toate acestea, rețineți că obiectele parametrii acceptă o serie de constructori supraîncărcați care vă permit să setați valorile diferitelor proprietăți (ceea ce duce la o bază de cod mai compactă). De asemenea, rețineți că Visual Studio 2010 are diverși designeri grafici care vor genera automat o mulțime de acest cod obositor de manipulare a parametrilor pentru dvs.
Crearea unei interogări parametrizate duce adesea la mai mult cod, dar rezultatul este o modalitate mai convenabilă de a regla programatic instrucțiunile SQL, precum și o performanță mai bună. Această tehnică poate fi utilizată pentru orice interogare SQL, deși interogările parametrizate sunt cele mai utile dacă trebuie să rulați proceduri stocate.
Reguli paranteza patrata reprezintă [partea opțională] a unui construct. O bară verticală indică o alegere între opțiuni (var1|var2). Puntea suspensie înseamnă posibilă repetare de mai multe ori - 1 dată, 2 ori [, …]
instrucțiunea SELECT
Instruiește motorului bazei de date Microsoft Access să returneze informații din baza de date ca un set de înregistrări.
Sintaxă
SELECTAȚI [ predicat] { * | masa.* | [masa.]câmpul 1
[, [masa.]câmpul 2 [, ...]]}
DIN expresie_tabelă [, ...]
Instrucțiunea SELECT include următoarele elemente.
Element | Descriere |
Predicat | Unul dintre următoarele predicate: ALL, DISTINCT, DISTINCTROW sau TOP. Predicatele sunt folosite pentru a limita numărul de înregistrări returnate. Dacă nu este dat niciun predicat, implicit este ALL. |
Indică faptul că toate câmpurile sunt selectate din tabelul sau tabelele specificate |
|
Masa | Numele tabelului din ale cărui câmpuri sunt selectate înregistrările |
câmpul 1, câmpul 2 | Numele câmpurilor care conțin datele de preluat. Dacă sunt specificate mai multe câmpuri, datele vor fi preluate în ordinea în care sunt listate numele lor |
porecla1, porecla2 | Nume utilizate ca titluri de coloană în loc de numele coloanelor originale Mese |
expresie_tabelă | Unul sau mai multe nume de tabel care conțin datele de preluat. |
baza_de_date_externă | Numele bazei de date care conține tabelele specificate în componentă expresie_tabelă dacă nu se află în baza de date curentă |
Note
Pentru a efectua această operație, motorul de bază de date Microsoft Access caută în tabelele specificate, preia coloanele dorite, selectează rândurile care îndeplinesc condițiile specificate și sortează sau grupează rândurile rezultate în ordinea specificată.
Instrucțiunile SELECT nu modifică datele bazei de date.
Instrucțiunea SELECT este de obicei primul cuvânt al instrucțiunii SQL (instrucțiunea SQL (șir). Expresie care definește Comanda SQL, cum ar fi SELECT, UPDATE sau DELETE, inclusiv clauze precum WHERE sau ORDER BY. Instrucțiunile/șirurile SQL sunt utilizate în mod obișnuit în interogări și funcții statistice.) Majoritatea instrucțiunilor SQL sunt fie instrucțiuni SELECT, fie instrucțiuni SELECT...INTO.
Sintaxa minimă pentru o instrucțiune SELECT este următoarea:
SELECTAȚI câmpuri DIN masa
Puteți utiliza un asterisc (*) pentru a selecta toate câmpurile dintr-un tabel. Următorul exemplu selectează toate câmpurile din tabelul Angajați.
SELECT * FROM Angajati;
Dacă numele câmpului este inclus în mai multe tabele în clauza FROM, precedați-l cu numele tabelului și instrucțiunea «.» (punct). În exemplul următor, câmpul „Departament” este prezent în tabelele „Angajați” și „Supervizori”. Instrucțiunea SQL selectează departamentele din tabelul Angajați și numele supraveghetorilor din tabelul Supervisori.
SELECT angajați. Șefi de departament. Numele directorului FROM Angajații INNER JOIN Directori WHERE Angajații. Departament = Manageri. Departament;
Când creați un obiect RecordSet, numele câmpului tabelului este folosit de motorul bazei de date Microsoft Access ca nume al obiectului „Field” din obiect. RecordSet. Dacă numele câmpului trebuie schimbat sau nu este furnizat de expresia care generează câmpul, utilizați un cuvânt rezervat (Cuvânt rezervat. Un cuvânt care este un element al unui limbaj, cum ar fi Visual Basic. Cuvintele rezervate includ nume de declarații, funcții încorporate și tipuri de date, metode, operatori și obiecte.) AS. Următorul exemplu arată cum este folosit antetul „Ziua” pentru a denumi obiectul returnat Campîn obiectul primit RecordSet.
SELECTAȚI ziua de naștere ca zi FROM angajați;
Când lucrați cu funcții agregate sau interogări care returnează nume de obiecte ambigue sau identice Camp, ar trebui să utilizați clauza AS pentru a crea un nume de obiect diferit Camp. În exemplul următor, obiectul returnat Campîn obiectul primit RecordSet i se dă numele de „recensământ”.
SELECTARE NUMĂR (EmployeeCode) AS CENSUS FROM Angajații;
Când lucrați cu o instrucțiune SELECT, puteți utiliza clauze suplimentare pentru a restricționa și a organiza și mai mult datele preluate. Pentru mai multe informații, consultați subiectul de ajutor pentru oferta pe care o utilizați.
clauza FROM
Specifică tabelele și interogările care conțin câmpurile enumerate în instrucțiunea SELECT.
Sintaxă
SELECTAȚI listă_câmpuri
DIN expresie_tabelă
O instrucțiune SELECT care conține o clauză FROM include următoarele elemente:
Element | Descriere |
listă_câmpuri | |
expresie_tabelă | O expresie care definește unul sau mai multe tabele - surse de date. Expresia poate fi un nume de tabel, un nume de interogare stocat sau o expresie rezultat construită folosind un operator INNER JOIN, LEFT JOIN sau RIGHT JOIN |
baza_de_date_externă | Calea completă către baza de date externă care conține toate tabelele specificate în expresie_tabelă |
Note
Este necesară prezența unei clauze FROM după o instrucțiune SELECT.
Ordinea în care sunt listate tabelele expresie_tabelă nu contează.
Utilizarea tabelelor legate (Tabel legat. Un tabel care este salvat într-un fișier care nu face parte din baza de date deschisă, dar este accesibil din Microsoft Access. Utilizatorul poate adăuga, șterge și modifica înregistrări în tabelul legat, dar nu poate modifica structura acestuia. .) în locul clauzei IN, puteți face procesul de preluare a datelor dintr-o bază de date externă mai ușor și mai eficient.
Exemplul de mai jos arată cum să preluați date din tabelul Angajații.
SELECTAȚI Nume, Prenume
DE LA Angajati;
Indică înregistrările selectate pentru interogările SQL ( Limbajul SQL(Limbajul de interogare structurat). Un limbaj structurat de interogare și de programare a bazelor de date utilizat pe scară largă pentru accesarea, interogarea, actualizarea și gestionarea datelor în SGBD-urile relaționale.
Sintaxă
SELECTAȚI ]]
DIN masa
Instrucțiunea SELECT care conține aceste predicate include următoarele componente:
Componentă | Descriere |
Implicit dacă nu sunt incluse predicate. Motorul de baze de date Microsoft Access selectează toate înregistrările care corespund condițiilor unei instrucțiuni SQL (instrucțiune SQL (șir). O expresie care definește o comandă SQL, cum ar fi SELECT, UPDATE sau DELETE și include clauze, cum ar fi WHERE sau ORDER BY .Instrucțiunile/șirurile SQL sunt de obicei utilizate în interogări și funcții statistice). Următoarele două exemple identice arată cum să returnați toate înregistrările din tabelul Angajați. DE LA Angajati COMANDĂ PRIN EmployeeCode; DE LA Angajati COMANDĂ PRIN EmployeeCode; |
|
Exclude înregistrările care conțin date duplicat în câmpurile selectate. Doar valorile unice ale fiecărui câmp listat în instrucțiunea SELECT sunt incluse în rezultatele interogării. De exemplu, unii angajați listați în tabelul Angajați pot avea același nume de familie. Dacă două înregistrări conțin numele de familie „Ivanov” în câmpul Nume de familie, următoarea instrucțiune SQL returnează o singură înregistrare care conține numele de familie „Ivanov”. SELECTAȚI DISTINCT Nume Dacă componenta DISTINCT este omisă, interogarea returnează ambele înregistrări cu numele de familie „Ivanov”. Dacă clauza SELECT conține mai multe câmpuri, combinația tuturor valorilor câmpului este inclusă în rezultatele interogării numai dacă este unică pentru acea înregistrare. Rezultatele unei interogări care utilizează componenta DISTINCT nu sunt actualizate pentru a reflecta modificările ulterioare făcute de alți utilizatori. |
|
Exclude datele din înregistrările care sunt repetate în întregime, mai degrabă decât să conțină câmpuri individuale cu aceleași date. Să presupunem că a fost creată o interogare care conectează tabelele „Clienți” și „Comenzi” folosind câmpul „Cod client”. Tabelul Clienți nu conține câmpuri duplicat ID client, dar ele există în tabelul Comenzi deoarece fiecare client poate avea mai multe comenzi. Următoarea instrucțiune SQL arată cum să utilizați componenta DISTINCTROW pentru a enumera organizațiile care au făcut cel puțin o comandă, fără a menționa detaliile acelor comenzi. SELECTAȚI Titlul DISTINCTROW DIN Comenzile Clienti INNER JOIN Clienții ON. CustomerId = Comenzi. Cod client ORDENAȚI PENTRU Titlu; Dacă componenta DISTINCTROW este omisă, interogarea are ca rezultat mai multe rânduri pentru fiecare organizație care a comandat de mai multe ori. Componenta DISTINCTROW are efect numai la selectarea câmpurilor din unele dintre tabelele utilizate în interogare. Componenta DISTINCTROW este ignorată dacă interogarea include doar un tabel sau dacă câmpurile sunt preluate din toate tabelele. |
|
TOP n | Returnează numărul specificat de înregistrări care sunt printre primele sau ultimele înregistrări din intervalul specificat de clauza ORDER BY. Să presupunem că doriți să afișați numele primilor 25 de elevi din clasa anului 1994. Prenume, Nume UNDE GraduationYear = 2003 ORDER BY GradePointAverage DESC; Dacă nu includeți clauza ORDER BY, interogarea va returna un set aleatoriu de 25 de înregistrări din tabelul Students care satisface clauza WHERE. Predicatul TOP nu implică o alegere între valori egale. Dacă a 25-a și a 26-a înregistrări din exemplul anterior aveau același GPA, interogarea ar returna 26 de înregistrări. De asemenea, puteți utiliza cuvântul rezervat PERCENT pentru a prelua un procent din primele sau ultimele înregistrări din intervalul specificat de clauza ORDER BY. Să presupunem că, în loc de primii 25, doriți să afișați ultimii 10% dintre studenți din clasa absolventă. SELECTAȚI TOP 10 PROCENT Prenume, Nume UNDE GraduationYear = 2003 COMANDA PENTRU GradePointAverage ASC; Predicatul ASC specifică ieșirea valorilor din partea inferioară a intervalului. Valoarea care urmează predicatului TOP trebuie să fie un tip de date Integer. Tipul de date de bază utilizat pentru a stoca valori întregi. O variabilă Integer este stocată ca un număr de 64 de biți (8 octeți) în intervalul -32768 până la 32767. ) fără semn . Predicatul TOP nu afectează dacă interogarea poate fi actualizată. |
masa | Numele tabelului din care sunt preluate înregistrările. |
Vezi si
instrucțiunea SELECT
clauza FROM
clauza WHERE
Determină ce înregistrări din tabelele enumerate în clauza FROM sunt procesate de instrucțiunile SELECT, UPDATE sau DELETE.
Sintaxă
SELECTAȚI listă_câmpuri
DIN expresie_tabelă
UNDE condiţii_selecţie
O instrucțiune SELECT care conține o clauză WHERE include următoarele părți.
Parte | Descriere |
listă_câmpuri | Numele câmpului sau câmpurilor care sunt preluate împreună cu orice alias (Alias (SQL). Un nume alternativ pentru un tabel sau câmp într-o expresie. Aliasurile sunt de obicei folosite ca nume mai scurte de tabel sau câmp pentru ușurința de referință ulterioară în programe, pentru a preveni referințele ambigue și pentru a obține nume mai descriptive la afișarea rezultatelor interogării.), predicate (ALL, DISTINCT, DISTINCTROW sau TOP) sau cu orice alt parametru al instrucțiunii SELECT. |
expresie_tabelă | Numele tabelului sau tabelelor din care sunt preluate datele. |
condiţii_selecţie | Expresie (Expresie. O combinație de operatori matematici și logici, constante, funcții, nume de câmpuri, controale și proprietăți care are ca rezultat o singură valoare. Expresia poate efectua calcule, procesa text sau valida date.) care trebuie să se potrivească cu înregistrările incluse. în rezultatele interogării. |
Note
Motorul de baze de date Microsoft Access selectează înregistrările care îndeplinesc condițiile enumerate în clauza WHERE. Dacă nu este specificată clauza WHERE, interogarea returnează toate rândurile din tabel. Dacă o interogare specifică mai multe tabele, dar nu specifică o clauză WHERE sau JOIN, interogarea produce un produs cartezian (produs cartezian. Este rezultatul executării unei instrucțiuni SQL SELECT care are o clauză FROM care face referire la două sau mai multe tabele și nu WHERE sau Clauza JOIN care specifică metoda de îmbinare.) tabele.
Clauza WHERE nu este necesară, dar dacă este utilizată, trebuie să urmeze clauza FROM. De exemplu, puteți selecta toți angajații din departamentul de vânzări (WHERE Department = „Vânzări”) sau toți clienții cu vârste cuprinse între 18 și 30 de ani (WHERE Age Between 18 And 30).
Dacă o clauză JOIN nu este utilizată pentru o operație de îmbinare SQL pe mai multe tabele, obiectul rezultat Set record va fi imposibil de actualizat.
Clauza WHERE este similară cu clauza HAVING și specifică înregistrările selectate. După ce înregistrările sunt grupate după clauza GROUP BY, clauza HAVING determină și înregistrarea care trebuie afișată.
Clauza WHERE este folosită pentru a exclude înregistrările care nu trebuie grupate folosind clauza GROUP BY.
Utilizați diferite expresii pentru a determina ce înregistrări sunt returnate de instrucțiunea SQL. De exemplu, următoarea instrucțiune SQL selectează toți angajații al căror salariu depășește RUR.
SELECT Nume, Salariu FROM Angajații WHERE Salariu > 21000;
Clauza WHERE poate conține până la 40 de expresii conectate prin operatori logici (de exemplu, ȘIȘi SAU).
Dacă introduceți un nume de câmp care conține spații sau semne de punctuație, trebuie să îl includeți între paranteze drepte (). De exemplu, un tabel cu detalii despre clienți poate conține informații despre anumiți clienți.
SELECTAȚI [Restaurantul preferat al clientului]
Specificarea unui argument condiţii_selecţie, literale de dată (Literal de dată. Orice succesiune de caractere într-un format valid, încadrată în semne numerice (#). Formatele valide sunt formatul de dată specificat în setările de limbă și standarde și în formatul de dată universal.) trebuie să fie reprezentate în format S.U.A. , chiar dacă se folosește un format de dată care nu este SUA, versiunea motorului de bază de date Microsoft Access. De exemplu, data „10 mai 1996” este scrisă ca 10/5/96 în Regatul Unit și ca 05/10/1996 în Rusia. Nu uitați să includeți literalele date în semnele numerice (#), așa cum se arată în exemplele de mai jos.
Pentru a găsi înregistrările pentru 10 mai 1996 în baza de date din Marea Britanie, utilizați următoarea instrucțiune SQL:
SELECTAȚI * FROM Comenzi WHERE Data expedierii = #10.05.1996#;
De asemenea, puteți utiliza funcția DateValue, recunoscând parametrii internaționali, instalat de Microsoft Windows®. De exemplu, pentru Rusia utilizați acest cod:
SELECT * FROM Comenzi WHERE Data expedierii = DateValue("05/10/1996");
Și următorul cod este pentru Marea Britanie:
SELECT * FROM Comenzi WHERE Data expedierii = DateValue("10/5/96");
Notă. Dacă coloana specificată în rândul de criterii de selecție este de tip GUID (Replica ID (GUID). Un câmp de 16 octeți dintr-o bază de date Microsoft Access folosit pentru a identifica în mod unic replicarea. GUID-urile sunt folosite pentru a identifica replici, seturi de replici, tabele, înregistrări și alte obiecte În bazele de date Microsoft Access, codurile GUID sunt numite coduri replica.), condițiile de selecție folosesc o sintaxă ușor diferită.
WHERE ReplicaID = (GUID (AB-CDEF0ABCDEF))
Asigurați-vă că parantezele și cratimele imbricate sunt poziționate corect.
Pagina sursă: http://office. /ru-ru/access/HA.aspx? pid=CH
Clauza GROUP BY
Combină înregistrările cu aceleași valori care sunt în lista specificată de câmpuri într-o singură înregistrare. O valoare rezumat este creată pentru fiecare înregistrare dacă o funcție de agregare SQL este inclusă în instrucțiunea SELECT, cum ar fi Sumă sau Numara.
Sintaxă
SELECTAȚI listă_câmpuri
DIN masa
UNDE stare_selecție
O instrucțiune SELECT care conține o clauză GROUP BY include următoarele elemente:
Element | Descriere |
listă_câmpuri | Numele câmpurilor care sunt preluate împreună cu orice alias (Alias (SQL). Un nume alternativ pentru un tabel sau câmp într-o expresie. Aliasurile sunt de obicei folosite ca nume mai scurte de tabel sau câmp pentru ușurința de referință ulterioară în programe, pentru a preveni referințele ambigue și pentru a obține nume mai informative la afișarea rezultatelor interogărilor.) și statistic Funcții SQL, predicate (ALL, DISTINCT, DISTINCTROW sau TOP) sau alți parametri ai instrucțiunii SELECT |
masa | |
condiţii_selecţie | Condiție de selecție. Dacă declarația conține o clauză WHERE, atunci după ce este aplicată înregistrărilor, valorile vor fi grupate de motorul bazei de date Microsoft Access. |
list_câmpuri_grup | list_câmpuri_grup |
Note
Clauza GROUP BY este opțională.
Dacă funcțiile statistice SQL nu sunt incluse în instrucțiunea SELECT, valorile rezumative nu sunt calculate.
GROUP BY valorile câmpului care sunt Null (Null. O valoare care poate fi introdusă într-un câmp sau utilizată în expresii și interogări pentru a indica date lipsă sau necunoscute. În Visual Basic, cuvântul cheie Null specifică o valoare Nulă. Unele câmpuri, cum ar fi ca câmpuri cheie primară, nu pot conține valori Null.), sunt grupate și nu sunt omise. Cu toate acestea, valorile Nul nu sunt evaluate de niciuna dintre funcțiile statistice SQL.
Clauza WHERE este folosită pentru a exclude rândurile care nu trebuie grupate. Clauza HAVING este folosită pentru a filtra înregistrările după grupare.
Câmpuri din lista de câmpuri GROUP BY care nu conțin tip de date Memo (Tip de date Memo Field. Un tip de date câmp într-o bază de date Microsoft Access. Un câmp MEMO poate conține până la 65535 de caractere.) sau Obiect OLE (Tip de date câmp obiect OLE" Un tip de date de câmp folosit pentru a salva obiecte din alte aplicații legate sau încorporate într-o bază de date Microsoft Access.) poate face referire la orice câmp din orice tabel specificat în clauza FROM, chiar dacă câmpul nu este inclus în instrucțiunea SELECT. Pentru a face acest lucru, este suficient să aveți cel puțin o funcție statistică SQL în instrucțiunea SELECT. Motorul de baze de date Microsoft Access nu permite gruparea după câmpuri care conțin date MEMO Field sau OLE Object.
Toate câmpurile din lista de câmpuri SELECT trebuie fie să fie conținute într-o clauză GROUP BY, fie să fie argumente pentru o funcție de agregare SQL.
Vezi si
instrucțiunea SELECT
instrucțiunea SELECT...INTO
Predica ALL, DISTINCT, DISTINCTROW, TOP
clauza FROM
AVÂND oferta
clauza ORDER BY
clauza WHERE
Funcții statistice SQL
Pagina sursă: http://office. /ru-ru/access/HA.aspx? pid=CH
AVÂND oferta
Definește înregistrările grupate care ar trebui să apară într-o instrucțiune SELECT cu o clauză GROUP BY. După ce înregistrările au fost grupate după clauza GROUP BY, clauza HAVING le va arăta pe cele care îndeplinesc condițiile acesteia.
Sintaxă
SELECTAȚI listă_câmpuri
DIN masa
UNDE condiţii_selecţie
A SE GRUPA CU list_câmpuri_grup
O instrucțiune SELECT care conține o clauză HAVING include următoarele elemente:
Element | Descriere |
listă_câmpuri | Numele câmpurilor care sunt încărcate împreună cu orice alias (Alias (SQL). Un nume alternativ pentru un tabel sau câmp într-o expresie. Aliasurile sunt de obicei folosite ca nume de tabel sau câmpuri mai scurte pentru ușurința de referință ulterioară în programe, pentru a preveni referințele ambigue și pentru a obține nume mai informative la afișarea rezultatelor interogării.) și funcții statistice SQL, predicate (ALL, DISTINCT, DISTINCTROW sau TOP) sau cu alți parametri ai instrucțiunii SELECT. |
masa | Numele tabelului din care sunt încărcate înregistrările |
stare_selecție | Condiție de selecție. Dacă declarația conține o clauză WHERE, motorul bazei de date Microsoft Access va grupa valorile după ce este aplicat înregistrărilor. |
list_câmpuri_grup | Numele câmpurilor (până la 10) utilizate pentru gruparea înregistrărilor. Ordinea numelor în list_câmpuri_grup determină nivelul de grupare – de la cel mai mare la cel mai mic |
condiție_grup | O expresie care specifică înregistrările care trebuie afișate |
Note
Clauza HAVING este opțională.
Clauza HAVING este similară cu clauza WHERE care determină selecția înregistrărilor. După gruparea înregistrărilor cu clauza GROUP BY, clauza HAVING determină înregistrările care trebuie afișate.
SELECT TypeCode,
Sumă(Stoc)
DIN Produse
GROUP BY TypeCode
AVÂND Suma(InStock) > 100 Și Ca „TEL*”;
Clauza HAVING poate conține până la 40 de expresii legate de operatori logici, cum ar fi ȘiȘi Sau.
Pagina sursă: http://office. /ru-ru/access/HA.aspx? pid=CH
clauza ORDER BY
Sortează înregistrările returnate de interogare în ordine crescătoare sau descrescătoare a valorilor câmpurilor specificate.
Sintaxă
SELECTAȚI listă_câmpuri
DIN masa
UNDE stare_selecție
[, câmpul 2 ][, ...]]]
O instrucțiune SELECT care conține o clauză ORDER BY include următoarele elemente.
Element | Descriere |
listă_câmpuri | Numele câmpurilor care sunt preluate împreună cu orice alias (Alias (SQL). Un nume alternativ pentru un tabel sau câmp într-o expresie. Aliasurile sunt de obicei folosite ca nume mai scurte de tabel sau câmp pentru ușurința de referință ulterioară în programe, pentru a preveni referințele ambigue și pentru a obține nume mai informative la afișarea rezultatelor interogării.) și funcții statistice SQL, predicate (ALL, DISTINCT, DISTINCTROW sau TOP) sau cu alți parametri ai instrucțiunii SELECT. |
masa | Numele tabelului din care sunt preluate înregistrările |
condiţii_selecţie | Conditii de selectie. Dacă declarația conține o clauză WHERE, atunci după ce este aplicată înregistrărilor, motorul de bază de date Microsoft Access va ordona valorile înregistrărilor |
câmpul 1, câmpul 2 | Numele câmpurilor după care sunt sortate înregistrările. |
Note
Clauza ORDER BY este opțională. Ar trebui să fie utilizat atunci când trebuie să afișați datele în formă sortată.
Ordinea implicită de sortare este (Ordine de sortare. O modalitate de a aranja datele în funcție de valorile și tipul acestora. Datele pot fi sortate alfabetic, după valori numerice sau după dată. Ordinea de sortare poate fi crescătoare (de la 0 la 100, de la A la Z) sau descendent (de la 100 la 0, de la Z la A).) crescător (de la A la Z, de la 0 la 9). Exemplele de mai jos demonstrează sortarea numelor angajaților după nume.
SELECTAȚI Nume, Prenume
DE LA Angajati
COMANDA PENTRU Nume;
SELECTAȚI Nume, Prenume
DE LA Angajati
COMANDA PENTRU Nume ASC;
Pentru a sorta câmpurile în ordine descrescătoare (Z la A, 9 la 0), adăugați cuvântul rezervat DESC la numele fiecărui câmp. Următorul exemplu demonstrează sortarea în ordine descrescătoare în funcție de salariile angajaților.
SELECTează Nume, Salariu
DE LA Angajati
COMANDA DUPA SALARIU DESC, Nume;
Dacă specificați câmpuri în clauza ORDER BY care conțin date de tipul MEMO Field (Tip de date Memo Field. Un tip de date câmp într-o bază de date Microsoft Access. Un câmp MEMO poate conține până la 65.535 de caractere.) sau OLE Object Field (OLE Object Field) Tip de date de câmp „Un tip de date de câmp folosit pentru a salva obiecte din alte aplicații legate sau încorporate într-o bază de date Microsoft Access.), aceasta va genera o eroare. Motorul bazei de date Microsoft Access nu poate sorta aceste tipuri de câmpuri.
Clauza ORDER BY este de obicei ultima clauză dintr-o instrucțiune SQL (instrucțiune SQL (șir). O expresie care definește o comandă SQL, cum ar fi SELECT, UPDATE sau DELETE, și include clauze, cum ar fi WHERE sau ORDER BY. Instrucțiuni SQL /șirurile sunt utilizate în mod obișnuit în interogări și funcții statistice.).
Puteți include câmpuri suplimentare în clauza ORDER BY. Înregistrările sunt mai întâi sortate după câmpul specificat mai întâi în clauza ORDER BY. Înregistrările cu aceleași valori în primul câmp sunt apoi sortate după câmpul specificat de al doilea și așa mai departe.
Vezi si
instrucțiunea SELECT
instrucțiunea SELECT...INTO
Predica ALL, DISTINCT, DISTINCTROW, TOP
clauza FROM
Clauza GROUP BY
AVÂND oferta
clauza WHERE
Funcții statistice SQL
Pagina sursă: http://office. /ru-ru/access/HA.aspx? pid=CH
Operațiunea INNER JOIN
Unește înregistrările din două tabele dacă câmpurile de legătură ale acestor tabele conțin aceleași valori.
Sintaxă
DIN tabelul 1 INNER JOIN masa 2 PE tabelul 1.câmpul 1 tabel_operator_comparație2.câmpul 2
Operația INNER JOIN constă din următoarele elemente:
Element | Descriere |
tabelul 1, masa 2 | Numele tabelelor care conțin înregistrările care urmează să fie unite |
câmpul 1, câmpul 2 | Numele câmpurilor care vor fi legate. Câmpurile nenumerice trebuie să fie de același tip de date (Tip de date. O caracteristică de câmp care definește tipul de date pe care le poate conține câmpul. Tipurile de date includ: Boolean, Întregi, Lung, Monedă, Single, Double, Data, String, și Variant (implicit).) și conțin date de același tip. Cu toate acestea, numele acestor câmpuri pot fi diferite |
operator_comparaţie | Orice operator de comparație: (=,<, >, <=, >= sau<>) |
