Rekordok beszúrása, törlése, frissítése az adatbázisban. Lekérdezés küldése adatbázisba VBA Access használatával SQL lekérdezések létrehozása hozzáférési névrokonokban
1. sz. laboratóriumi munka
SQL: DATA EXTRACT - parancsKIVÁLASZTÁS
A munka célja:
- ismerkedjen meg az SQL utasításokkal;
- megtanulják, hogyan hozhatók létre egyszerű SQL-lekérdezések az Accessben a SELECT paranccsal;
· az IN, BETWEEN, LIKE, IS NULL operátorok használata.
Gyakorlat№1. Hozzon létre egy lekérdezést, amellyel SQL módban kiválaszthatja a FIRST NÉV és a VEZETÉKNÉV mezők összes értékét a DIÁKOK táblából.
KERESZTNÉV, VEZETÉKNÉV KIVÁLASZTÁSA
DIÁKOKTÓL;
Gyakorlat№2 . Hozzon létre egy lekérdezést a TANULÓK tábla összes oszlopának SQL módban történő kijelöléséhez.
KIVÁLASZTÁS *
DIÁKOKTÓL;
3. feladat. Hozzon létre egy lekérdezést, amellyel SQL módban kiválaszthatja azoknak a városoknak a nevét, ahol a diákok élnek, amelyekről a SZEMÉLYES ADATOK táblában található információ.
VÁLASSZA KÜLÖNBÖZŐ VÁROST
[SZEMÉLYES ADATOKBÓL];
4. feladat. Hozzon létre egy kiválasztási lekérdezést SQL módban, amely lekéri az összes Ivanov vezetéknévvel rendelkező tanuló nevét, amelyre vonatkozó információk a DIÁKOK táblában találhatók.
VÁLASZTÁSA VEZETÉKNÉV, KERESZTNÉV
DIÁKOK TÓL
WHERE LAST NAME="Ivanov";
5. feladat. Hozzon létre egy kiválasztási lekérdezést SQL módban az UIT-22 csoportban költségvetési oktatási formában tanuló hallgatók vezeték- és keresztnevének lekéréséhez.
VÁLASZTÁSA VEZETÉKNÉV, KERESZTNÉV
DIÁKOK TÓL
WHERE GROUP="UIT-22" ÉS KÖLTSÉGVETÉS = igaz;
6. feladat. Hozzon létre egy lekérdezést SQL módban. a VIZSGA táblázat mintájára a csak 4-es és 5-ös osztályzattal rendelkező tanulók adatai.
KIVÁLASZTÁS *
TÓL TŐL [VÁLTOZÁSVIZSGÁLATOK]
AHOLFOKOZATIN(4,5);
7. feladat. Hozzon létre egy zanpoc és SQL módot az IOSU tantárgyból 3-as vizsgaosztályzattal rendelkező tanulók információinak kiválasztásához.
KIVÁLASZTÁS *
TÓL TŐL [VÁLTOZÁSVIZSGÁLATOK]
AHOLTÉTEL=" IOSU"ÉsFOKOZATNincs benne (4,5);
8. feladat. Hozzon létre egy lekérdezést SQL módban a 100 és 130 közötti órák rekordjainak kiválasztásához.
KIVÁLASZTÁS *
TÓL TŐLTÉTELEK
AHOLNÉZ100 ÉS 130 KÖZÖTT;
9. feladat. Hozzon létre egy lekérdezést SQL módban, hogy kiválassza a DIÁKOK táblából azokra a tanulókra vonatkozó információkat, akiknek vezetékneve például „C” betűvel kezdődik.
KIVÁLASZTÁS *
TÓL TŐLDIÁKOK
AHOLVEZETÉKNÉVMINT"VAL VEL*";
Következtetés: Alatt laboratóriumi munka megismerkedett az SQL utasításokkal, megtanulta, hogyan lehet egyszerű SQL lekérdezéseket készíteni Accessben a SELECT paranccsal az IN, BETWEEN, LIKE operátorok használatával.
Ezt a leckét annak szentelték SQL lekérdezések az adatbázisba VBA hozzáférés. Megnézzük, hogyan történik az INSERT, UPDATE, DELETE lekérdezések az adatbázisban VBA-ban, és azt is megtanuljuk, hogyan lehet egy SELECT lekérdezésből egy adott értéket lekérni.
Akik programoznak VBA hozzáférés miközben dolgozik az adatbázissal SQL szerver, nagyon gyakran olyan egyszerű és szükséges feladattal kell szembenézniük, mint egy SQL lekérdezés elküldése egy adatbázisba, legyen az INSERT, UPDATE vagy egy egyszerű SQL SELECT lekérdezés. És mivel kezdő programozók vagyunk, ezt is meg kell tudnunk tenni, így ma ezt fogjuk tenni.
Az SQL szerverről történő adatszerzés témáját már érintettük, ahol VBA-ban írtunk kódot ezeknek az adatoknak a beszerzéséhez, például az Adatok feltöltése szöveges fájlba MSSql 2008-ból cikkben, vagy érintettünk egy kevés az anyagban Adatok feltöltése az Access-ből egy Word és Excel sablonba, de így vagy úgy, ezt felületesen néztük meg, és ma azt javaslom, hogy beszéljünk erről egy kicsit részletesebben.
Jegyzet! Az alábbi példák mindegyike az Access 2003 ADP projekt és az MSSql 2008 adatbázis használatával készült. Ha nem tudja, mi az ADP projekt, akkor ezt az Access ADP projekt létrehozása és konfigurálása című anyagban néztük meg.
Példák forrásadatai
Tegyük fel, hogy van egy teszt_tábla táblázatunk, amely az év hónapjainak számát és nevét tartalmazza (a lekérdezések Menedzsment Stúdió)
TÁBLÁZAT LÉTREHOZÁSA .( NEM NULL, (50) NULL) INDULJON
Ahogy már mondtam, egy MS SQL 2008-cal való együttműködésre konfigurált ADP projektet fogunk használni, amelyben létrehoztam egy tesztűrlapot, és hozzáadtam egy start gombot aláírással "Fuss", amire szükségünk lesz a kódunk teszteléséhez, pl. Az összes kódot beírjuk az eseménykezelőbe" Gombnyomás».
Lekérdezések az adatbázishoz INSERT, UPDATE, DELETE VBA-ban
Hogy ne késlekedjünk túl sokáig, azonnal kezdjük, mondjuk hozzá kell adni egy sort a teszttáblázatunkhoz ( kód kommentálta)/
Private Sub start_Click() "Változó deklarálása a lekérdezési karakterlánc tárolására Dim sql_query As String "Írja be a szükséges lekérdezést sql_query = "INSERT INTO test_table (id, name_mon) VALUES ("6", "június")" "Végrehajtás it DoCmd. RunSQL sql_query End Sub
Ebben az esetben a lekérdezés az aktuális adatbázis-kapcsolati paraméterek használatával kerül végrehajtásra. Ellenőrizhetjük, hogy az adatok hozzáadásra kerültek-e vagy sem.
Amint látja, az adatok bekerültek.
Egy sor törléséhez a következő kódot írjuk.
Private Sub start_Click() "Változó deklarálása a lekérdezési karakterlánc tárolására Dim sql_query As String "Írjon bele egy törlési lekérdezést sql_query = "DELETE test_table WHERE id = 6" "Futtassa DoCmd.RunSQL sql_query End Sub
Ha ellenőrizzük, látni fogjuk, hogy a kívánt sort törölték.
Az adatok frissítéséhez írjon az sql_query változóba frissítési kérés, remélem érthető a jelentés.
SELECT lekérdezés egy adatbázishoz a VBA-ban
Itt a dolgok egy kicsit érdekesebbek, mint más SQL-konstrukciók esetében.
Először is tegyük fel, hogy minden adatot le kell kérnünk a táblából, és például feldolgozzuk és üzenetben megjelenítjük, és természetesen más célokra is felhasználhatja, ehhez írjuk a következőket kód
Private Sub start_Click() "Változók deklarálása "Az adatbázis rekordkészletéhez Dim RS As ADODB.Recordset "Lekérdezési karakterlánc Dim sql_query As String "Karakterlánc összefoglaló adatok üzenetben való megjelenítéséhez Dim str As String "Új objektum létrehozása rekordokhoz set RS = Új ADODB .Recordset "Query line sql_query = "SELECT id, name_mon FROM test_table" "Futtassa le a lekérdezést az aktuális projektkapcsolati beállításokkal RS.open sql_query, CurrentProject.Connection, adOpenDynamic, adLockOptimistic While Nem fut át a rekordon RS.EOF) "Töltse ki a változót az str = str & RS.Fields("id") & "-" & RS.Fields("name_mon") & vbnewline üzenet megjelenítéséhez "ugrás a következő rekordra RS.MoveNext Wend " Írja ki az üzenetet msgbox str End Sub
Itt már VBA Access hurkokat használunk a rekordkészletünk összes értékének iterálásához.
De gyakran nem minden értéket kell megszerezni egy rekordkészletből, hanem csak egyet, például a hónap nevét a kódjával. Ehhez pedig elég költséges ciklust használni, így egyszerűen írhatunk egy lekérdezést, amely csak egy értéket ad vissza, és elérjük azt, például az 5-ös kóddal megkapjuk a hónap nevét.
Private Sub start_Click() "Változók deklarálása" Az adatbázis rekordkészletéhez Dim RS As ADODB.Recordset "Query string Dim sql_query As String "String a végső érték megjelenítéséhez Dim str As String "Új objektum létrehozása az RS rekordkészlethez = Új ADODB.Recordset "Query line sql_query = "SELECT name_mon FROM test_table WHERE id = 5" "Futtassa le a lekérdezést az aktuális projektkapcsolati beállításokkal RS.open sql_query, CurrentProject.Connection, adOpenDynamic, adLockOptimistic = "RS. érték. Mezők(0) msgbox str End Sub
Az egyetemesség érdekében itt már nem a cella nevével, hanem az indexével foglalkoztunk, azaz. 0, és ez a legelső érték Rekordkészlet, végül megkaptuk az értéket "Lehet".
Mint látható, minden nagyon egyszerű. Ha gyakran kell egy adott értéket lekérnie az adatbázisból ( mint az utolsó példában), akkor azt javaslom, hogy az összes kódot egy külön függvénybe (Hogyan írjunk függvényt VBA Access 2003-ban) egy bemeneti paraméterrel, például a hónap kódjával ( ha figyelembe vesszük a példánkat) és egyszerűen, ahol ezt az értéket kell megjeleníteni, hívjuk meg a szükséges függvényt a szükséges paraméterrel, és ennyi, ezzel jelentősen csökkentjük a VBA kódot és javítjuk programunk érzékelését.
Ez minden mára. Sok szerencsét!
A "Shop" oktatási projekt leírásaTáblázat link diagramja
A táblázatok leírása
m_kategória - termékkategóriák
m_bevétel - áruátvétel
m_outcome - árufogyasztás
m_product - címtár, termékleírások
m_supplier - könyvtár; szállítói információk
m_unit - könyvtár; egységek
A tananyagban szereplő példák gyakorlati teszteléséhez a következő szoftverrel kell rendelkeznie:
Microsoft Access 2003 vagy újabb.
SQL lekérdezés az MS Accessben. Rajt
A táblázat tartalmának megtekintéséhez kattintson duplán a táblázat nevére a bal oldali panelen:
A táblázat mező szerkesztési módba való váltáshoz kattintson a gombra felső panel válassza ki a tervezési módot:
Az SQL-lekérdezés eredményének megjelenítéséhez kattintson duplán a lekérdezés nevére a bal oldali ablaktáblában:
Az SQL lekérdezés szerkesztési módra való váltáshoz válassza az SQL módot a felső panelen:
SQL lekérdezés. Példák az MS Accessben. KIVÁLASZTÁS: 1-10
Az SQL-lekérdezésekben a SELECT utasítást használjuk az adatbázistáblák közötti választásra.SQL Query Q001. Példa SQL lekérdezésre, hogy csak a szükséges mezőket kapja meg a kívánt sorrendben:
SELECT dt, product_id, summa
FROM m_jövedelem;
SQL Query Q002. Ebben a példa SQL lekérdezésben a csillag (*) karakter az m_product tábla összes oszlopának listázására szolgál, más szóval az m_product reláció összes mezőjének lekéréséhez:
KIVÁLASZTÁS *
FROM m_product;
KérésSQL Q003. A DISTINCT utasítás az ismétlődő bejegyzések eltávolítására és több egyedi bejegyzés beszerzésére szolgál:
SELECT DISTINCT product_id
FROM m_jövedelem;
SQL Query Q004. Az ORDER BY utasítás a rekordok egy adott mező értékei szerinti rendezésére szolgál. A mező neve az ORDER BY utasítás után kerül megadásra:
KIVÁLASZTÁS *
m_jövedelemtől
RENDELÉS ÁR SZERINT;
SQL Query Q005. Az ASC utasítás az ORDER BY utasítás kiegészítéseként szolgál, és a növekvő sorrend meghatározására szolgál. A DESC utasítás az ORDER BY utasítás mellett használatos, és a csökkenő rendezés megadására szolgál. Abban az esetben, ha sem ASC, sem DESC nincs megadva, az ASC (alapértelmezett) jelenléte feltételezhető:
KIVÁLASZTÁS *
m_jövedelemtől
RENDELÉS A dt DESC , ár;
SQL Query Q006. A táblázatból a szükséges rekordok kiválasztásához különféle logikai kifejezéseket használnak, amelyek kifejezik a kiválasztási feltételt. A logikai kifejezés a WHERE utasítás után jelenik meg. Példa az összes olyan rekord lekérésére az m_income táblából, amelyeknél az összeg értéke nagyobb, mint 200:
KIVÁLASZTÁS *
m_jövedelemtől
WHERE összeg>200;
SQL Query Q007. A kifejezésért nehéz körülmények használja az ÉS (kötőszó), OR (disjunkció) és NOT (logikai negáció) logikai operátorokat. Példa az m_outcome táblából az összes olyan rekord lekérésére, amelyeknél az összeg értéke 20, az ár pedig nagyobb vagy egyenlő, mint 10:
Ár
FROM m_outcome
WHERE összeg=20 ÉS ár>=10;
SQL Query Q008. Két vagy több tábla adatainak egyesítéséhez használja az INNER JOIN, LEFT JOIN, RIGHT JOIN utasításokat. A következő példa lekéri a dt, product_id, summa, ár mezőket az m_income táblából és a cím mezőt az m_termék táblából. Az m_bevétel tábla rekordja az m_termék tábla rekordjához kapcsolódik, ha az m_jövedelem.termék_id értéke megegyezik az m_termék.id értékével:
ON m_jövedelem.termékazonosító=m_termékazonosító;
SQL Query Q009. Ebben az SQL-lekérdezésben két dolgot kell megjegyezni: 1) a keresett szöveg a egyetlen idézőjel("); 2) a dátum #Hónap/Nap/Év# formátumban van megadva, ami igaz az MS Accessre. Más rendszerekben a dátum írási formátuma eltérő lehet. Példa a nyugtával kapcsolatos információk megjelenítésére a tej 2011. június 12-én. Kérjük, vegye figyelembe a dátumformátumot: #6/12/2011#:
SELECT dt, product_id, title, summa, price
FROM m_income BELSŐ CSATLAKOZÁS m_product
WHERE title="Milk" And dt=#6/12/2011#; !}
SQL Query Q010. A BETWEEN utasítás annak ellenőrzésére szolgál, hogy egy érték egy bizonyos tartományba tartozik-e. Egy példa SQL-lekérdezésre, amely információkat jelenít meg a 2011. június 1. és június 30. között kapott termékekről:
KIVÁLASZTÁS *
FROM m_income BELSŐ CSATLAKOZÁS m_product
ON m_jövedelem.termékazonosító=m_termékazonosító
WHERE dt KÖZÖTT #6/1/2011# és #6/30/2011#;
SQL lekérdezés. Példák az MS Accessben. KIVÁLASZTÁS: 11-20
Egy SQL-lekérdezés beágyazható egy másikba. Az allekérdezés nem más, mint egy lekérdezés a lekérdezésben. Általában egy segédlekérdezést használnak a WHERE záradékban. De vannak más módok is az allekérdezések használatára.Q011 lekérdezés. Megjelennek az m_product táblából származó termékek információi, amelyek kódjai szintén az m_income táblában találhatók:
KIVÁLASZTÁS *
FROM m_product
WHERE id IN (SELECT termékazonosító FROM m_bevétel);
Q012 lekérdezés. Megjelenik azon termékek listája az m_product táblából, amelyek kódjai nem szerepelnek az m_outcome táblában:
KIVÁLASZTÁS *
FROM m_product
WHERE id NOT IN (SELECT product_id FROM m_outcome);
Kérés Q013. Ez az SQL-lekérdezés egyedi listát jelenít meg azon termékkódokról és -nevekről, amelyek az m_income táblában szerepelnek, de nem az m_outcome táblában:
SELECT DISTINCT product_id, title
FROM m_income BELSŐ CSATLAKOZÁS m_product
ON m_jövedelem.termékazonosító=m_termékazonosító
WHERE product_id NOT IN (SELECT product_id FROM m_outcome);
Q014 lekérdezés. Az m_category táblázatban megjelenik az M betűvel kezdődő kategóriák egyedi listája:
SELECT DISTINCT cím
FROM m_product
WHERE cím, MINT "M*";
Q015 lekérdezés. Példa a lekérdezés mezőivel végzett aritmetikai műveletek végrehajtására és a lekérdezés mezőinek átnevezésére (alias). Ez a példa kiszámítja a költség = mennyiség*ár és nyereség minden egyes tételköltség-bejegyzéshez, feltételezve, hogy a nyereség az értékesítés 7 százaléka:
összeg*ár/100*7 AS nyereség
FROM m_outcome;
Q016 lekérdezés. Az aritmetikai műveletek elemzésével és egyszerűsítésével növelheti a lekérdezés végrehajtásának sebességét:
SELECT dt, product_id, summa, price, summa*price AS output_sum,
eredmény_összeg*0,07 AS nyereség
FROM m_outcome;
Kérjen Q017. Az INNER JOIN utasítás segítségével több tábla adatait egyesítheti. A következő példában a ctgry_id értékétől függően az m_income tábla minden bejegyzése az m_kategória tábla azon kategóriájának nevével lesz egyeztetve, amelyhez a termék tartozik:
SELECT c.title, b.title, dt, summa, price, summa*price AS bevételi_összeg
FROM (m_jövedelem MINT BELSŐ CSATLAKOZÁS m_product AS b ON a.product_id=b.id)
BELSŐ CSATLAKOZÁS m_kategória AS c ON b.ctgry_id=c.id
RENDELÉS c.cím, b.cím;
Kérjen Q018. Az olyan függvényeket, mint a SUM – összeg, COUNT – mennyiség, AVG – számtani átlagérték, MAX – maximális érték, MIN – minimális érték, összesített függvényeknek nevezzük. Sok értéket elfogadnak, és feldolgozásuk után egyetlen értéket adnak vissza. Példa az összeg és az ár mezők szorzatának összegének kiszámítására a SUM összesítő függvény segítségével:
SELECT SUM(összeg*ár) AS Total_Sum
FROM m_jövedelem;
Q019 lekérdezés. Példa több összesítő függvény használatára:
SELECT Sum(összeg) AS Összeg_Összeg, AVG(összeg) AS Összeg_AVG,
MAX(összeg) AS Összeg_Max., Min.(összeg) AS Összeg_Min.,
Szám(*) AS Total_Number
FROM m_jövedelem;
Kérjen Q020. Ebben a példában az összes 1-es kódú áru 2011 júniusában tőkésített mennyiségét számítjuk ki:
SELECT Sum(összeg*ár) AS jövedelem_összeg
m_jövedelemtől
WHERE product_id=1 ÉS dt #6/1/2011# ÉS #6/30/2011#;.
Q021 lekérdezés. A következő SQL-lekérdezés kiszámítja a 4-es vagy 6-os kódú cikkek eladásainak összegét:
SELECT Sum(összeg*ár) mint eredmény_összeg
FROM m_outcome
WHERE termékazonosító=4 VAGY termékazonosító=6;
Q022 lekérdezés. Kiszámításra került, hogy 2011. június 12-én mennyi 4-es vagy 6-os kódú árut adtak el:
SELECT Sum(összeg*ár) AS eredmény_összeg
FROM m_outcome
WHERE (termékazonosító=4 VAGY termékazonosító=6) ÉS dt=#6/12/2011#;
Q023 lekérdezés. A feladat ez. Számítsa ki a „Pékáru” kategóriában szereplő áruk teljes mennyiségét, amelyek tőkésítettek.
A probléma megoldásához három táblával kell működnie: m_jövedelem, m_termék és m_kategória, mert:
- az aktivált áruk mennyiségét és árát az m_bevétel tábla tárolja;
- minden termék kategóriakódja az m_termék táblában kerül tárolásra;
- a címkategória neve az m_kategória táblában tárolódik.
A probléma megoldásához a következő algoritmust használjuk:
- a "Pékáru" kategóriakód meghatározása az m_kategória táblából egy részlekérdezéssel;
- az m_income és m_product táblák összekapcsolása az egyes vásárolt termékek kategóriájának meghatározásához;
- az átvételi összeg (= mennyiség*ár) kiszámítása azon áruk esetében, amelyek kategóriakódja megegyezik a fenti részlekérdezésben meghatározott kóddal.
KIVÁLASZTÁS
FROM m_product MINT BELSŐ CSATLAKOZÁS m_income AS b ON a.id=b.product_id
WHERE ctgry_id = (SELECT id FROM m_category WHERE title="Pékáru"); !}
Q024 lekérdezés. A „Pékáru” kategóriába tartozó aktivált áruk teljes mennyiségének kiszámítását a következő algoritmussal oldjuk meg:
- az m_bevétel tábla minden egyes bejegyzéséhez, a termék_azonosító értékétől függően, az m_kategória táblából egyezzen meg a kategória nevével;
- válassza ki azokat a rekordokat, amelyek kategóriája „Pékáru”;
- számítsa ki a nyugta összegét = mennyiség*ár.
FROM (m_product MINT BELSŐ CSATLAKOZÁS m_bevétel AS b ON a.id=b.product_id)
WHERE c.title="Pékáru";
!}
Q025 lekérdezés. Ez a példa kiszámítja, hogy hány árut fogyasztottak el:
SELECT COUNT(product_id) AS product_cnt
FROM (SELECT DISTINCT product_id FROM m_outcome) AS t;
Q026 lekérdezés. A GROUP BY utasítás a rekordok csoportosítására szolgál. A rekordokat általában egy vagy több mező értéke alapján csoportosítják, és mindegyik csoportra valamilyen összesítő műveletet alkalmaznak. Például a következő lekérdezés egy jelentést generál az áruk értékesítéséről. Ez azt jelenti, hogy egy táblázat jön létre, amely tartalmazza az áruk nevét és azt az összeget, amelyért eladták:
SELECT cím, SUM(összeg*ár) AS eredmény_összeg
FROM m_product MINT BELSŐ JOIN m_outcome AS b
ON a.id=b.product_id
GROUP BY cím;
Kérés Q027.Értékesítési jelentés kategóriánként. Ez azt jelenti, hogy létrejön egy táblázat, amely tartalmazza a termékkategóriák megnevezését, a teljes mennyiséget, amennyiért e kategóriák termékeit értékesítették, és az átlagos értékesítési összeget. A ROUND funkcióval az átlagértéket a legközelebbi századra kerekítheti (a tizedesjel utáni második számjegy):
SELECT c.title, SUM(összeg*ár) AS output_sum,
ROUND(AVG(összeg*ár),2) AS eredmény_összeg_átl
FROM (m_product AS A INNER JOIN m_outcome AS b ON a.id=b.product_id)
BELSŐ CSATLAKOZÁS m_category AS c ON a.ctgry_id=c.id
GROUP BY c.cím;
Q028 lekérdezés. A bevételek teljes és átlagos száma minden termékre kiszámításra kerül, és információkat jelenít meg azokról a termékekről, amelyek összes bevétele legalább 500:
SELECT termékazonosító, SUM(összeg) AS összeg_összeg,
Kerek(átl.(összeg),2) AS összeg_átl
m_jövedelemtől
GROUP BY product_id
HAVING Sum(összeg)>=500;
Q029 lekérdezés. Ez a lekérdezés minden termékre kiszámítja a 2011 második negyedévében teljesített bevételek összegét és átlagát. Ha a termék bizonylat végösszege legalább 1000, akkor a termékkel kapcsolatos információk jelennek meg:
SELECT cím, SUM(összeg*ár) AS jövedelem_összeg
m_jövedelemtől a BELSŐ CSATLAKOZÁS m_product b ON a.product_id=b.id
HOL dt 2011.04.01# ÉS 2011.06.30# KÖZÖTT
GROUP BY cím
HAVING SUM(összeg*ár)>=1000;
Q030 lekérdezés. Bizonyos esetekben egy tábla minden rekordját össze kell hangolnia egy másik tábla minden rekordjával; amelyet Descartes-szorzatnak neveznek. Az ilyen kapcsolat eredményeként kapott táblázatot Descartes-táblának nevezzük. Például, ha az A tábla 100 rekordot tartalmaz, és a B tábla 15 rekordot tartalmaz, akkor a Descartes-táblázatuk 100*15=150 rekordot tartalmaz. A következő lekérdezés egyesíti az m_income tábla minden rekordját az m_outcome tábla minden rekordjával:
FROM m_jövedelem, m_eredmény;
Q031 lekérdezés. Példa a rekordok két mező szerinti csoportosítására. A következő SQL lekérdezés minden szállító számára kiszámítja a tőle kapott áruk mennyiségét és mennyiségét:
SZUM(összeg*ár) AS bevétel_összeg
Kérés Q032. Példa a rekordok két mező szerinti csoportosítására. Az alábbi lekérdezés minden beszállítóra kiszámítja az általunk értékesített termékeik mennyiségét és mennyiségét:
SELECT szállítóazonosító, termékazonosító, SUM(összeg) AS összeg összege,
GROUP BY beszállítói_azonosító, termékazonosító;
Q033 lekérdezés. Ebben a példában a fenti két lekérdezést (q031 és q032) használjuk segédlekérdezésként. Ezeknek a lekérdezéseknek a LEFT JOIN metódussal elért eredményeit egy jelentésbe egyesítik. A következő lekérdezés jelentést jelenít meg az egyes szállítók beérkezett és eladott termékek mennyiségéről és mennyiségéről. Kérjük, vegye figyelembe, hogy ha egy termék már beérkezett, de még nem adták el, akkor ennél a bejegyzésnél az output_sum cella üres lesz. hogy ez a lekérdezés csak egy példa a viszonylag összetett lekérdezések segédlekérdezésként való használatára. Ennek a nagy mennyiségű adatot tartalmazó SQL-lekérdezésnek a teljesítménye megkérdőjelezhető:
KIVÁLASZTÁS *
TÓL TŐL
SZUM(összeg*ár) AS bevétel_összeg
ON a.product_id=b.id CSOPORT BY beszállítói_azonosító, termékazonosító) AS a
BAL CSATLAKOZÁS
(SELECT szállítóazonosító, termékazonosító, SUM(összeg) AS összeg_összeg,
SZUM(összeg*ár) AS eredmény_összeg
FROM m_outcome MINT BELSŐ JOIN m_product AS b
ON a.product_id=b.id CSOPORT BY beszállítói_azonosító, termékazonosító) AS b
BE (a.product_id=b.product_id) ÉS (a.supplier_id=b.supplier_id);
Q034 lekérdezés. Ebben a példában a fenti két lekérdezést (q031 és q032) használjuk segédlekérdezésként. Ezeknek a lekérdezéseknek a RIGTH JOIN metódussal elért eredményeit egy jelentésbe egyesítik. A következő lekérdezés az egyes ügyfelek befizetéseinek összegéről jelenít meg jelentést az általa használt fizetési rendszerek és a befektetések összege szerint. A következő lekérdezés jelentést jelenít meg az egyes szállítók beérkezett és eladott termékek mennyiségéről és mennyiségéről. Kérjük, vegye figyelembe, hogy ha egy terméket már eladtak, de még nem érkezett meg, akkor ennél a bejegyzésnél a bevétel_összeg cella üres lesz. Az ilyen üres cellák jelenléte az értékesítési könyvelés hibáját jelzi, mivel az értékesítés előtt először meg kell érkeznie a megfelelő terméknek:
KIVÁLASZTÁS *
TÓL TŐL
(SELECT szállítóazonosító, termékazonosító, SUM(összeg) AS összeg_összeg,
SZUM(összeg*ár) AS bevétel_összeg
FROM m_income MINT BELSŐ CSATLAKOZÁS m_product AS b ON a.product_id=b.id
GROUP BY beszállítói_azonosító, termékazonosító) AS a
JOBB CSATLAKOZÁS
(SELECT szállítóazonosító, termékazonosító, SUM(összeg) AS összeg_összeg,
SZUM(összeg*ár) AS eredmény_összeg
FROM m_outcome MINT BELSŐ CSATLAKOZÁS m_product AS b ON a.product_id=b.id
GROUP BY beszállítói_azonosító, termékazonosító) AS b
BE (a.szállítóazonosító=b.szállítóazonosító) ÉS (a.termékazonosító=b.termékazonosító);
Q035 lekérdezés. Megjelenik egy jelentés, amely termékenként mutatja a bevételek és kiadások összegét. Ehhez az m_income és m_outcome táblák szerint készítünk egy terméklistát, majd ebből a listából minden termékre kiszámítjuk a bevételeinek összegét az m_bevétel tábla, a kiadásainak összegét pedig az m_outcome tábla szerint:
SELECT termékazonosító, SUM(összegben) AS bevételi_összeg,
SUM(out_amount) AS eredmény_összeg
TÓL TŐL
(VÁLASZTÁSA termékazonosító, AS összeg a_összegben, 0 AS out_amount
m_jövedelemtől
UNIÓ MINDEN
SELECT termékazonosító, 0 AS összegben, AS kimenő_összeg
FROM m_outcome) AS t
GROUP BY termékazonosító;
Q036 lekérdezés. Az EXISTS függvény IGAZ értéket ad vissza, ha a neki átadott halmaz tartalmaz elemeket. Az EXISTS függvény FALSE-t ad vissza, ha a neki átadott halmaz üres, azaz nem tartalmaz elemeket. A következő lekérdezés megjeleníti az m_income és m_outcome táblákban is szereplő termékkódokat:
SELECT DISTINCT product_id
FROM m_income AS a
WHERE EXISTS(SELECT termékazonosító FROM m_outcome AS b
Q037 lekérdezés. Megjelennek az m_income és m_outcome táblákban is szereplő termékkódok:
SELECT DISTINCT product_id
FROM m_income AS a
WHERE product_id IN (SELECT product_id FROM m_outcome)
Q038 lekérdezés. Olyan termékkódok jelennek meg, amelyek az m_income táblában szerepelnek, de az m_outcome táblában nem:
SELECT DISTINCT product_id
FROM m_income AS a
WHERE NOT EXISTS(SELECT termékazonosító FROM m_outcome AS b
WHERE b.product_id=a.product_id);
Q039 lekérdezés. Megjelenik a maximális eladási összeget tartalmazó termékek listája. Az algoritmus a következő. Minden termékre kiszámítják az eladások összegét. Ezután meghatározzák ezen összegek maximumát. Ezután minden terméknél újra kiszámításra kerül az eladások összege, és megjelenik azon áruk kódja és eladási összege, amelyek eladási összege megegyezik a maximummal:
SELECT termékazonosító, SUM(összeg*ár) AS összeg_összeg
FROM m_outcome
GROUP BY product_id
HAVING SUM(összeg*ár) = (SELECT MAX(s_amount)
FROM (SELECT SUM(összeg*ár) AS s_összeg FROM m_outcome GROUP BY product_id));
Q040 lekérdezés. Fenntartott szó IIF ( feltételes operátor) egy logikai kifejezés kiértékelésére és az eredménytől (IGAZ vagy HAMIS) függő művelet végrehajtására szolgál. A következő példában a tétel kiszállítását "kicsinek" tekintjük, ha a mennyiség kisebb, mint 500. Ellenkező esetben, ha az átvételi mennyiség nagyobb vagy egyenlő, mint 500, a szállítás "nagynak" minősül:
SELECT dt, product_id, summa,
IIF(összeg FROM m_jövedelem;
SQL Query Q041. Abban az esetben, ha az IIF operátort többször használják, kényelmesebb a SWITCH operátorral helyettesíteni. A SWITCH operátor (többszörös kijelölés operátor) egy logikai kifejezés kiértékelésére és az eredménytől függő művelet végrehajtására szolgál. A következő példában a leszállított tételt "kicsinek" tekintjük, ha a tételben lévő áruk mennyisége kevesebb, mint 500. Ellenkező esetben, ha az áruk mennyisége nagyobb vagy egyenlő, mint 500, a tétel "nagynak" minősül. ":
SELECT dt, product_id, summa,
SWITCH(összeg =500,"nagy") AS jel
FROM m_jövedelem;
Q042 lekérdezés. A következő kérésnél, ha a kapott tételben lévő áruk mennyisége 300-nál kisebb, akkor a tétel „kicsinek” minősül. Ellenkező esetben, ha a feltétel összege SELECT dt, termékazonosító, összeg,
IIF(összeg IIF(összeg FROM m_jövedelem;
SQL Query Q043. A következő kérésnél, ha a kapott tételben lévő áruk mennyisége 300-nál kisebb, akkor a tétel „kicsinek” minősül. Ellenkező esetben, ha a feltétel összege SELECT dt, termékazonosító, összeg,
SWITCH(összeg összeg>=1000,"nagy") AS jel
FROM m_jövedelem;
SQL Query Q044. A következő lekérdezésben az értékesítések három csoportra oszthatók: kicsi (150-ig), közepes (150-300), nagy (300 vagy több). Ezután minden csoportra kiszámítjuk a teljes összeget:
SELECT kategória, SUM(outcome_sum) AS Ctgry_Total
FROM (SELECT összeg*ár AS eredmény_összeg,
IIf(összeg*ár IIf(összeg*ár m_eredménytől) AS t
GROUP BY Kategória;
SQL Query Q045. A DateAdd funkcióval napokat, hónapokat vagy éveket adhat hozzá egy adott dátumhoz, és új dátumot kaphat. Következő kérés:
1) 30 napot ad a dátumhoz a dt mezőből, és megjeleníti az új dátumot a dt_plus_30d mezőben;
2) 1 hónapot ad a dátumhoz a dt mezőből, és megjeleníti az új dátumot a dt_plus_1m mezőben:
SELECT dt, dateadd("d",30,dt) AS dt_plus_30d, dateadd("m",1,dt) AS dt_plus_1m
FROM m_jövedelem;
SQL Query Q046. A DateDiff függvény arra szolgál, hogy kiszámítsa a különbséget két dátum között különböző mértékegységekben (napok, hónapok vagy évek). A következő lekérdezés kiszámítja a dt mezőben lévő dátum és az aktuális dátum közötti különbséget napokban, hónapokban és években:
SELECT dt, DateDiff("d",dt,Date()) AS utolsó_nap,
DateDiff("m",dt,Date()) AS utolsó_hónapok,
DateDiff("yyyy",dt,Date()) AS utolsó_évek
FROM m_jövedelem;
SQL Query Q047. Az áru átvételétől (m_bevétel tábla) az aktuális dátumig eltelt napok számát a DateDiff függvénnyel kiszámítja, és összehasonlítja a lejárati dátumot (m_termék táblázat):
DateDiff("d",dt,Date()) AS utolsó_napok
FROM m_income MINT BELSŐ JOIN m_product AS b
ON a.product_id=b.id;
SQL Query Q048. Kiszámítja az áru átvételétől az aktuális dátumig eltelt napok számát, majd ellenőrzi, hogy ez a mennyiség meghaladja-e a lejárati időt:
SELECT a.id, product_id, dt, lifedays,
DateDiff("d",dt,Date()) AS utolsó_napok, IIf(utolsó_napok>életnapok,"Igen","Nem") AS date_expire
FROM m_income a BELSŐ JOIN m_product b
ON a.product_id=b.id;
SQL Query Q049. Az áru átvételétől az aktuális dátumig eltelt hónapok száma kerül kiszámításra. A month_last1 oszlop a hónapok abszolút számát, a month_last2 oszlop pedig a teljes hónapok számát:
SELECT dt, DateDiff("m",dt,Date()) AS hónap_utolsó1,
DateDiff("m",dt,Dátum())-iif(nap(dt)>nap(dátum()),1,0) AS hónap_utolsó2
FROM m_jövedelem;
SQL Query Q050. A 2011-re vásárolt áruk mennyiségéről és mennyiségéről negyedéves jelentés jelenik meg:
SELECT kvartal, SUM(outcome_sum) AS Összesen
FROM (SELECT összeg*ár AS eredmény_összeg, hónap(dt) AS m,
KAPCSOLÓ(m =10,4) AS kvartal
FROM m_jövedelem WHERE év(dt)=2011) AS t
GROUP BY negyedév;
Q051 lekérdezés. A következő lekérdezés segít kideríteni, hogy a felhasználók képesek voltak-e a kapott áruk mennyiségénél nagyobb mennyiségű árufogyasztással kapcsolatos információt bevinni a rendszerbe:
SELECT product_id, SUM(in_sum) AS bevételi_összeg, SUM(out_sum) AS output_sum
FROM (SELECT termékazonosító, összeg*ár mint in_sum, 0 mint out_sum
m_jövedelemből
UNIÓ MINDEN
SELECT termékazonosító, 0 mint in_sum, summa*price mint out_sum
m_outcome-tól) AS t
GROUP BY product_id
HAVING SUM(összegben)
Q052 lekérdezés. A lekérdezés által visszaadott sorok számozása többféleképpen valósul meg. Például átszámozhatja az MS Accessben készített jelentés sorait magának az MS Access-nek a használatával. Programozási nyelvek, például VBA vagy PHP segítségével is újraszámozhat. Néha azonban ezt magában az SQL-lekérdezésben kell megtenni. Tehát a következő lekérdezés számozza az m_income tábla sorait az azonosító mező értékeinek növekvő sorrendje szerint:
SELECT COUNT(*) mint N, b.id, b.product_id, b.amount, b.price
FROM m_income a BELSŐ CSATLAKOZÁS m_bevétel b ON a.id GROUP BY BY b.id, b.product_id, b.amount, b.price;
Q053 lekérdezés. Megjelenik az eladási mennyiség szerint a termékek közül az első öt termék. Az első öt rekordot a TOP utasítással nyomtatjuk ki:
SELECT TOP 5, product_id, sum(összeg*ár) AS összeg
FROM m_outcome
GROUP BY product_id
ORDER BY összeg(összeg*ár) DESC;
Q054 lekérdezés. Megjelenik az eladási mennyiség szerint a termékek közül az öt legjobb termék, és ennek eredményeként a sorok számozásra kerülnek:
SELECT COUNT(*) AS N, b.product_id, b.summa
TÓL TŐL
FROM m_outcome GROUP BY product_id) AS a
BELSŐ ÖSSZEKAPCSOLÁS
(SELECT termékazonosító, összeg(összeg*ár) AS összeg,
summa*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
HAVING COUNT(*)ORDER BY COUNT(*);
Q055 lekérdezés. A következő SQL lekérdezés a COS, SIN, TAN, SQRT, ^ és ABS matematikai függvények használatát mutatja be az MS Access SQL-ben:
KIVÁLASZTÁS (a szám(*) kiválasztása az m_jövedelemből) N-ként, 3,1415926 mint pi, k,
2*pi*(k-1)/N mint x, COS(x) mint COS_, SIN(x) mint SIN_, TAN(x) mint TAN_,
SQR(x) mint SQRT_, x^3 mint "x^3", ABS(x) mint ABS_
FROM (SELECT COUNT(*) AS k
FROM m_income MINT BELSŐ JOIN m_income AS b ON a.idCSOPORT BY B.id) t;
SQL lekérdezés. Példák az MS Accessben. FRISSÍTÉS: 1-10
U001 lekérdezés. A következő SQL-módosítási lekérdezés 10%-kal növeli az m_income táblában a 3-as kódú áruk árát:UPDATE m_income SET ár = ár*1.1
WHERE termék_azonosító=3;
Kérés U002. A következő SQL-frissítési lekérdezés 22 egységgel növeli az m_income táblában szereplő összes termék mennyiségét, amelyek neve „Olaj” szóval kezdődik:
FRISSÍTÉS m_bevétel SET összeg = összeg+22
WHERE termékazonosító IN (SELECT id FROM m_product WHERE cím LIKE "Olaj*");
Kérés U003. A következő SQL lekérdezés az m_outcome tábla módosítására a Sladkoe LLC által gyártott összes termék árát 2 százalékkal csökkenti:
UPDATE m_outcome SET ár = ár*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"Сладкое"");. !}
Rekordok beszúrása, törlése, frissítése adatbázisba
Az ExecuteReader() metódus lekér egy adatolvasó objektumot, amely lehetővé teszi az SQL Select utasítás eredményeinek megtekintését egy továbbított, csak olvasható információfolyam használatával. Ha azonban olyan SQL utasításokat kell végrehajtania, amelyek módosítják az adattáblát, akkor meg kell hívnia a metódust ExecuteNonQuery() ennek a tárgynak csapatok. Ez az egyetlen módszer a parancsszöveg formátumától függően beszúrások, módosítások és törlések végrehajtására szolgál.
Koncepció nonquery olyan SQL utasítást jelent, amely nem ad vissza eredményhalmazt. Ennélfogva, Válassza ki az állításokat lekérdezések, de az Insert, Update és Delete utasítások nem. Ennek megfelelően az ExecuteNonQuery() metódus egy int értéket ad vissza, amely az utasítások által érintett sorok számát tartalmazza, nem pedig egy új rekordkészletet.
Meglévő adatbázis tartalmának csak az ExecuteNonQuery() lekérdezéssel történő módosításának bemutatásához a következő lépésben létre kell hozni egy saját adatelérési könyvtárat, amely magába foglalja az AutoLot adatbázisfolyamatot.
Valódi éles környezetben az ADO.NET logikája szinte bizonyosan el lesz izolálva egy .NET .dll összeállításban egyetlen egyszerű ok miatt – a kód újrafelhasználása miatt! Ezt a korábbi cikkekben nem tették meg, hogy ne vonják el a figyelmét az aktuális feladatokról. De időpocsékolás lenne ugyanazt a kapcsolódási logikát, ugyanazt az adatolvasási logikát és ugyanazt a parancsvégrehajtási logikát kifejleszteni minden olyan alkalmazáshoz, amelynek működnie kell az AutoLot adatbázissal.
Az adatelérési logika .NET kódkönyvtárban történő elkülönítésével a különböző alkalmazások bármilyen felhasználói felülettel (konzol stílusú, asztali stílusú, webes stílusú stb.) hozzáférhetnek a meglévő könyvtárhoz, akár nyelvtől függetlenül is. És ha C#-ban fejleszt egy adatelérési könyvtárat, akkor más .NET-programozók is létrehozhatják a sajátjukat felhasználói felületek bármilyen nyelven (például VB vagy C++/CLI).
Adatelérési könyvtárunk (AutoLotDAL.dll) egyetlen névteret (AutoLotConnectedLayer) fog tartalmazni, amely az ADO.NET csatlakoztatott típusok használatával kölcsönhatásba lép az AutoLot adatbázissal.
Kezdje azzal, hogy hozzon létre egy új C# osztálykönyvtár-projektet AutoLotDAL néven (az "AutoLot Data Access Layer" rövidítése), majd módosítsa az eredeti C# kódfájl nevét AutoLotConnDAL.cs névre.
Ezután nevezze át a névtér hatókörét AutoLotConnectedLayer névre, és módosítsa az eredeti osztály nevét InventoryDAL-ra, mert ez az osztály különböző tagokat határoz meg az AutoLot adatbázis Inventory táblájával való interakcióhoz. Végül importálja a következő .NET névtereket:
Rendszer használata; a System.Collections.Generic használatával; a System.Text használatával; a System.Data használatával; a System.Data.SqlClient használatával; névtér AutoLotConnectedLayer ( nyilvános osztály InventoryDAL ( ) )
Csatlakozási logika hozzáadása
Első feladatunk olyan metódusok meghatározása, amelyek lehetővé teszik a hívó folyamat számára, hogy érvényes kapcsolati karakterlánc segítségével csatlakozzon az adatforráshoz, és leváljon róla. Mivel az AutoLotDAL.dll összeállításunk a System.Data.SqlClient osztálytípusok használatához lesz keményen kódolva, definiáljon egy privát SqlConnection változót, amely az InventoryDAL objektum létrehozásakor kerül lefoglalásra.
Ezenkívül adjon meg egy OpenConnection() metódust, majd egy másik CloseConnection() metódust, amely kölcsönhatásba lép ezzel a változóval:
Nyilvános osztály InventoryDAL ( private SqlConnection connect = null; public void OpenConnection(string connectionString) ( connect = new SqlConnection(connectionString); connect.Open(); ) public void CloseConnection() ( connect.Close(); ) )
A rövidség kedvéért az InventoryDAL típus nem ellenőrzi az összes lehetséges kivételt, és nem dob egyéni kivételeket különböző helyzetek előfordulásakor (például, ha a kapcsolati karakterlánc hibás). Ha azonban éles adathozzáférési könyvtárat hoz létre, valószínűleg strukturált kivételkezelési technikákat kell használnia a futás közben esetlegesen előforduló rendellenességek figyelembevételéhez.
Beillesztési logika hozzáadása
Beszúrás új bejegyzés az Inventory táblához az SQL utasítás formázásához vezet Beszúrás(a felhasználói beviteltől függően) és az ExecuteNonQuery() metódus meghívása a parancsobjektum segítségével. Ehhez adjon hozzá egy nyilvános InsertAuto() metódust az InventoryDAL osztályhoz, amely négy olyan paramétert vesz fel, amelyek megfelelnek az Inventory tábla négy oszlopának (CarID, Color, Make és PetName). Ezen argumentumok alapján hozzon létre egy sort egy új bejegyzés hozzáadásához. Végül hajtsa végre az SQL utasítást az SqlConnection objektum használatával:
Public void InsertAuto(int id, string color, string make, string petName) ( // SQL utasítás string sql = string.Format("Beszúrás a készletbe" + "(CarID, Make, Color, PetName) Értékek(@CarId, @Make, @Color, @PetName)"); using (SqlCommand cmd = new SqlCommand(sql, this.connect)) ( // Paraméterek hozzáadása cmd.Parameters.AddWithValue("@CarId", id); cmd.Parameters.AddWithValue("@Make", make); cmd. Parameters.AddWithValue("@Color", color); cmd.Parameters.AddWithValue("@PetName", petName); cmd.ExecuteNonQuery(; ) )
Az adatelérési könyvtár létrehozásának gyakori módja a relációs adatbázis rekordjait képviselő osztályok meghatározása. Valójában az ADO.NET Entity Framework automatikusan generál erősen beírt osztályokat, amelyek lehetővé teszik az adatbázisadatokkal való interakciót. Mellesleg, az ADO.NET önálló rétege erősen beírt DataSet objektumokat generál, hogy egy adott táblából származó adatokat relációs adatbázisban reprezentáljon.
Egy SQL utasítás létrehozása karakterlánc-összefűzéssel biztonsági kockázatot jelenthet (gondoljunk csak az SQL beillesztési támadásokra). Jobb, ha a parancsszöveget egy paraméterezett lekérdezéssel készítjük el, amelyet egy kicsit később ismertetünk.
Törlési logika hozzáadása
Eltávolítás meglévő rekord nem nehezebb, mint egy új rekordot beszúrni. Az InsertAuto() kóddal ellentétben egy fontos try/catch terület jelenik meg, amely kezeli azt a lehetséges helyzetet, amikor egy olyan autót próbálnak eltávolítani, amelyet valaki már rendelt a Vevők táblázatból. Adja hozzá a következő metódust az InventoryDAL osztályhoz:
Public void DeleteCar(int id) ( string sql = string.Format("Törlés a készletből ahol CarID = "(0)"", id); using (SqlCommand cmd = new SqlCommand(sql, this.connect)) ( próbáld meg ( cm.
Változási logika hozzáadása
Az Inventory táblában már meglévő rekord frissítése során azonnal felmerül a kézenfekvő kérdés: pontosan miben változtatható a hívási folyamat: az autó színe, a baráti név, a modell vagy mindhárom? A rugalmasság maximalizálásának egyik módja egy olyan metódus definiálása, amely egy string típusú paramétert vesz fel, amely bármilyen SQL utasítást tartalmazhat, de ez enyhén szólva kockázatos.
Ideális esetben jobb, ha olyan metódusokkal rendelkezik, amelyek lehetővé teszik a hívási folyamat számára a rekordok módosítását különböző utak. Az egyszerű adatelérési könyvtárunkhoz azonban egyetlen metódust fogunk meghatározni, amely lehetővé teszi a hívási folyamat számára a megadott autó barátságos nevének megváltoztatását:
Public void UpdateCarPetName(int id, string newpetName) ( string sql = string.Format("Készletkészlet frissítése PetName = "(0)" Ahol CarID = "(1)"", newpetName, id); using (SqlCommand cmd = new) SqlCommand(sql, this.connect)) ( cmd.ExecuteNonQuery(); ) )
Mintavételi logika hozzáadása
Most hozzá kell adnunk egy módszert a rekordok kiválasztásához. Amint korábban bemutattuk, egy adott adatszolgáltató adatolvasó objektuma lehetővé teszi a rekordok kiválasztását egy csak olvasható kurzor használatával. A Read() metódus meghívásával az egyes rekordokat egyenként dolgozhatja fel. Ez mind nagyszerű, de most ki kell találnunk, hogyan lehet ezeket a rekordokat visszaküldeni a hívó alkalmazásrétegbe.
Az egyik megközelítés az lenne, ha az adatokat a Read() metódussal kérnénk le, majd feltöltünk és visszaadunk egy többdimenziós tömböt (vagy egy másik objektumot, például az általános listát
Egy másik módszer egy System.Data.DataTable objektum visszaadása, amely valójában az önálló ADO.NET réteghez tartozik. A DataTable egy olyan osztály, amely táblázatos adattömböt (például papírt vagy táblázatot) képvisel.
A DataTable osztály az adatokat sorok és oszlopok gyűjteményeként tartalmazza. Ezek a gyűjtemények programozottan feltölthetők, de a DataTable típusnak van egy Load() metódusa, amely képes automatikusan feltölteni őket egy adatolvasó objektum segítségével! Íme egy példa, ahol az Inventory tábla adatai DataTableként kerülnek visszaadásra:
Public DataTable GetAllInventoryAsDataTable() ( DataTable inv = new DataTable(); string sql = "Kiválasztás * a készletből"; using (SqlCommand cmd = new SqlCommand(sql, this.connect)) ( SqlDataReader dr = cmd.ExecutevReader); .Load(dr); dr.Close(); ) return inv; )
Paraméterezett parancsobjektumokkal végzett munka
Eddig az InventoryDAL típus beszúrási, frissítési és törlési logikájában keményen kódolt karakterlánc-literálokat használtunk minden SQL-lekérdezéshez. Valószínűleg tisztában van a paraméterezett lekérdezések létezésével, amelyek lehetővé teszik, hogy az SQL-paramétereket objektumként kezelje, nem pedig csak szövegrészként.
Az SQL-lekérdezések objektumorientáltabb kezelése nemcsak az elírások csökkentését segíti elő (erősen beírt tulajdonságokkal), de a paraméterezett lekérdezések általában sokkal gyorsabbak, mint a karakterlánc-literális lekérdezések, mivel csak egyszer (nem minden alkalommal) elemzik őket. a CommandText tulajdonság SQL karakterláncra van beállítva). Ezenkívül a paraméterezett lekérdezések védelmet nyújtanak az SQL injekciós támadásokkal szemben (ez egy jól ismert adathozzáférési biztonsági probléma).
A paraméterezett lekérdezések támogatása érdekében az ADO.NET parancsobjektumok egyedi paraméterobjektumok gyűjteményét tartják karban. Alapértelmezés szerint ez a gyűjtemény üres, de tetszőleges számú, egyező paraméterobjektumot hozzáadhat helyőrző paraméterek SQL lekérdezésben. Ha egy SQL lekérdezési paramétert egy parancsobjektum paramétergyűjteményének egy tagjához kell társítania, akkor az SQL paraméter előtt írja be a @ szimbólumot (legalábbis, ha a Microsofttal dolgozik SQL szerver, bár nem minden DBMS támogatja ezt a megjelölést).
Paraméterek beállítása a DbParameter típussal
Mielőtt elkezdené a paraméterezett lekérdezések létrehozását, ismerkedjünk meg a DbParameter típussal (a szolgáltatói paraméterobjektumok alaposztálya). Ez az osztály számos tulajdonsággal rendelkezik, amelyek lehetővé teszik a paraméter nevének, méretének és típusának, valamint egyéb jellemzők megadását, például a paraméter nézési irányát. A DbParameter típus néhány fontos tulajdonsága az alábbiakban található:
DbTypeLekéri vagy beállítja az adattípust egy paraméterből, amely CLR-típusként jelenik meg
IrányVisszaadja vagy beállítja a paraméter típusát: csak bemenet, csak kimenet, bemenet és kimenet, vagy paraméter érték visszaadásához
IsNullableVisszaadja vagy beállítja, hogy egy paraméter fogadhat-e üres értékeket
ParameterNameLekéri vagy beállítja a DbParameter nevét
MéretProblémák vagy telepítések maximális méret a paraméter adatai (csak szöveges adatok esetén hasznos)
ÉrtékEgy paraméter értékét adja vissza vagy állítja be
A parancsobjektumok gyűjteményének DBParameter-kompatibilis objektumokkal való feltöltésének demonstrálásához írjuk át az InsertAuto() metódust úgy, hogy paraméterobjektumokat használjon (az összes többi metódust is át lehet készíteni hasonlóan, de nekünk elég lesz a jelen példa):
Public void InsertAuto(int id, string color, string make, string petName) ( // SQL utasítás string sql = string.Format("Beszúrás a készletbe" + "(CarID, Make, Color, PetName) Values("(0)) ""(1)","(2)","(3)")", id, make, color, petName); // Paraméterezett parancs a következővel: (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. ParameterName = "@Make"; param.Value = gyártó; param.SqlDbType = SqlDbType.Char; param.Size = 10; cmd.Parameters.Add(param); param = new SqlParameter(); param.ParameterName = "@Color "; param.Value = szín; 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(); ) )
Vegye figyelembe, hogy az SQL-lekérdezés itt négy helyőrző karaktert is tartalmaz, mindegyik előtt egy @ szimbólum. Az SqlParameter típus ParameterName tulajdonságával leírhatja ezeket a helyőrzőket, és erősen tipizált módon megadhat különféle információkat (érték, adattípus, méret stb.). Az összes paraméterobjektum előkészítése után az Add() hívás segítségével hozzáadásra kerülnek a parancsobjektum-gyűjteményhez.
Itt különféle tulajdonságokat használnak a paraméterobjektumok tervezésére. Azonban vegye figyelembe, hogy a paraméterobjektumok számos túlterhelt konstruktort támogatnak, amelyek lehetővé teszik különböző tulajdonságok értékeinek beállítását (ami kompaktabb kódbázist eredményez). Vegye figyelembe azt is, hogy a Visual Studio 2010 különféle grafikus tervezőkkel rendelkezik, amelyek automatikusan generálnak egy csomó unalmas paraméter-manipuláló kódot.
Paraméterezett lekérdezés létrehozása gyakran több kódot eredményez, de az eredmény kényelmesebb módja az SQL utasítások programozott hangolásának, valamint jobb teljesítményt nyújt. Ez a technika bármely SQL-lekérdezéshez használható, bár a paraméterezett lekérdezések a leghasznosabbak, ha tárolt eljárásokat kell futtatni.
Szabályok szögletes zárójelek egy konstrukció [opcionális részét] jelenti. Egy függőleges sáv jelzi a lehetőségek közötti választást (var1|var2). Az ellipszis többszöri ismétlést jelent - 1 alkalommal, 2 alkalommal [, …]
SELECT utasítás
Utasítja a Microsoft Access adatbázismotort, hogy rekordkészletként adja vissza az adatokat az adatbázisból.
Szintaxis
KIVÁLASZTÁS [ állítmány] { * | asztal.* | [asztal.]mező1
[, [asztal.]mező2 [, ...]]}
TÓL TŐL táblázat_kifejezés [, ...]
A SELECT utasítás a következő elemeket tartalmazza.
Elem | Leírás |
Állítmány | A következő predikátumok egyike: ALL, DISTINCT, DISTINCTROW vagy TOP. A predikátumok a visszaadott rekordok számának korlátozására szolgálnak. Ha nincs predikátum megadva, az alapértelmezett érték ALL. |
Azt jelzi, hogy az összes mező ki van választva a megadott táblából vagy táblázatokból |
|
asztal | Annak a táblának a neve, amelynek mezőiből a rekordokat kiválasztja |
mező1, mező2 | A lekérendő adatokat tartalmazó mezők neve. Ha több mezőt ad meg, az adatok a nevük felsorolásának sorrendjében kerülnek lekérésre |
becenév1, becenév2 | Az eredeti oszlopnevek helyett oszlopfejlécként használt nevek táblázatok |
táblázat_kifejezés | Egy vagy több táblanév, amely a lekérendő adatokat tartalmazza. |
külső_adatbázis | Az összetevőben megadott táblákat tartalmazó adatbázis neve táblázat_kifejezés ha nem szerepelnek az aktuális adatbázisban |
Megjegyzések
A művelet végrehajtásához a Microsoft Access adatbázismotor megkeresi a megadott táblá(ka)t, lekéri a kívánt oszlopokat, kiválasztja a megadott feltételeknek megfelelő sorokat, és az eredményül kapott sorokat a megadott sorrendben rendezi vagy csoportosítja.
A SELECT utasítások nem változtatják meg az adatbázis adatait.
A SELECT utasítás általában az SQL utasítás első szava (SQL utasítás (string). Kifejezés, amely meghatározza SQL parancs, például KIVÁLASZTÁS, FRISSÍTÉS vagy TÖRLÉS, és olyan záradékokat tartalmaz, mint a WHERE vagy a ORDER BY. Az SQL utasításokat/karakterláncokat gyakran használják lekérdezésekben és statisztikai függvényekben.) A legtöbb SQL utasítás SELECT vagy SELECT...INTO utasítás.
A SELECT utasítás minimális szintaxisa a következő:
KIVÁLASZTÁS mezőket TÓL TŐL asztal
A táblázat összes mezőjének kijelöléséhez használhat egy csillagot (*). A következő példa az Alkalmazottak táblázat összes mezőjét kijelöli.
SELECT * FROM Alkalmazottak;
Ha a mezőnév több táblában is szerepel a FROM záradékban, írja be előtte a tábla nevét és az utasítást «.» (pont). A következő példában az "Osztály" mező az "Alkalmazottak" és a "Felügyelők" táblázatban található. Az SQL utasítás osztályokat választ ki az Employees táblából, a felügyelők neveit pedig a Felügyelők táblából.
VÁLASZD ki az alkalmazottakat. Osztály, vezetők. Vezetői név FROM Alkalmazottak BELSŐ CSATLAKOZÁS Vezetők WHERE Alkalmazottak. Osztály = Vezetők. Osztály;
Amikor létrehoz egy RecordSet objektumot, a Microsoft Access adatbázismotor a táblamező nevét használja az objektumban lévő "Field" objektum neveként. RecordSet. Ha a mező nevét módosítani kell, vagy a mezőt létrehozó kifejezés nem adja meg, használjon fenntartott szót (Fenntartott szó. Olyan szó, amely egy nyelv eleme, például a Visual Basic. A fenntartott szavak az utasítások neveit, beépített függvények és adattípusok, metódusok, operátorok és objektumok.) AS. A következő példa bemutatja, hogyan használják a "Day" fejlécet a visszaadott objektum elnevezésére Terület a kapott tárgyban RecordSet.
SELECT Birthday AS Day FROM Alkalmazottak;
Ha olyan összesítő függvényekkel vagy lekérdezésekkel dolgozik, amelyek kétértelmű vagy azonos objektumneveket adnak vissza Terület, használja az AS záradékot egy másik objektumnév létrehozásához Terület. A következő példában a visszaadott objektum Terület a kapott tárgyban RecordSet a „Census” nevet kapja.
SELECT COUNT(EmployeeCode) AS Census FROM Alkalmazottak;
Amikor egy SELECT utasítással dolgozik, további záradékokat használhat a visszakeresett adatok további korlátozására és rendszerezésére. További információért tekintse meg az Ön által használt ajánlat súgótémakörét.
FROM záradék
A SELECT utasításban felsorolt mezőket tartalmazó táblákat és lekérdezéseket határozza meg.
Szintaxis
KIVÁLASZTÁS field_list
TÓL TŐL táblázat_kifejezés
A FROM záradékot tartalmazó SELECT utasítás a következő elemeket tartalmazza:
Elem | Leírás |
field_list | |
táblázat_kifejezés | Egy vagy több táblát – adatforrást – meghatározó kifejezés. A kifejezés lehet egy táblanév, egy tárolt lekérdezésnév, vagy egy INNER JOIN, LEFT JOIN vagy RIGHT JOIN operátor segítségével összeállított eredménykifejezés. |
külső_adatbázis | A külső adatbázis teljes elérési útja, amely tartalmazza az összes táblát, amely a következő helyen szerepel: táblázat_kifejezés |
Megjegyzések
A SELECT utasítás után egy FROM záradék jelenléte szükséges.
A táblázatok felsorolásának sorrendje táblázat_kifejezés nem számít.
Hivatkozott táblák használata (Linked table. Olyan tábla, amely olyan fájlba van mentve, amely nem része a nyílt adatbázisnak, de elérhető a Microsoft Accessből. A felhasználó hozzáadhat, törölhet és módosíthat rekordokat a csatolt táblában, de nem módosíthatja a szerkezetét .) az IN záradék helyett egyszerűbbé és hatékonyabbá teheti az adatok külső adatbázisból történő lekérésének folyamatát.
Az alábbi példa bemutatja, hogyan lehet adatokat lekérni az Alkalmazottak táblából.
SELECT Vezetéknév, Keresztnév
Alkalmazottaktól;
Jelzi az SQL lekérdezésekhez kiválasztott rekordokat ( SQL nyelv(Strukturált lekérdezési nyelv). Strukturált lekérdezési és adatbázis-programozási nyelv, amelyet széles körben használnak adatok eléréséhez, lekérdezéséhez, frissítéséhez és kezeléséhez a relációs DBMS-ekben.
Szintaxis
KIVÁLASZTÁS ]]
TÓL TŐL asztal
Az ezeket a predikátumokat tartalmazó SELECT utasítás a következő összetevőket tartalmazza:
Összetevő | Leírás |
Értelmezett, ha nem szerepel predikátum. A Microsoft Access adatbázismotor kiválasztja az összes olyan rekordot, amely megfelel egy SQL-utasítás feltételeinek (SQL-utasítás (karakterlánc). Olyan kifejezés, amely egy SQL-parancsot határoz meg, például SELECT, UPDATE vagy DELETE, és záradékokat tartalmaz, például WHERE vagy ORDER BY Az SQL utasításokat/karakterláncokat jellemzően lekérdezésekben és statisztikai függvényekben használják). A következő két azonos példa bemutatja, hogyan lehet visszaadni az összes rekordot az Alkalmazottak táblából. Az alkalmazottaktól MEGRENDELÉS AZ EmployeeCode szerint; Az alkalmazottaktól MEGRENDELÉS AZ EmployeeCode szerint; |
|
Kizárja azokat a rekordokat, amelyek ismétlődő adatokat tartalmaznak a kijelölt mezőkben. Csak a SELECT utasításban felsorolt mezők egyedi értékei szerepelnek a lekérdezés eredményeiben. Például előfordulhat, hogy az Alkalmazottak táblázatban felsorolt egyes alkalmazottak vezetékneve megegyezik. Ha két rekord tartalmazza az „Ivanov” vezetéknevet a Vezetéknév mezőben, a következő SQL utasítás csak egy „Ivanov” vezetéknevet tartalmazó rekordot ad vissza. SELECT DISTINCT Vezetéknév Ha a DISTINCT komponenst kihagyjuk, a lekérdezés mindkét rekordot „Ivanov” vezetéknévvel adja vissza. Ha a SELECT záradék több mezőt tartalmaz, akkor az összes mezőérték kombinációja csak akkor szerepel a lekérdezés eredményeiben, ha az egyedi az adott rekordhoz. A DISTINCT összetevőt használó lekérdezések eredményei nem frissülnek, hogy tükrözzék a más felhasználók későbbi módosításait. |
|
Kizárja az adatokat azokból a rekordokból, amelyek teljes egészükben ismétlődnek, nem pedig ugyanazokat az adatokat tartalmazó egyedi mezőket. Tegyük fel, hogy létrejött egy lekérdezés, amely az „Ügyfélkód” mező segítségével összekapcsolja a „Vásárlók” és a „Rendelések” táblákat. A Vevők tábla nem tartalmaz duplikált Ügyfélazonosító mezőket, de a Rendelések táblában léteznek, mivel minden ügyfélnek több megrendelése is lehet. A következő SQL utasítás bemutatja, hogyan használhatja a DISTINCTROW összetevőt azon szervezetek listázására, amelyek legalább egy rendelést adtak le anélkül, hogy megemlítenék a rendelések részleteit. KIVÁLASZTÁS KÜLÖNBÖZŐ Cím AZ ügyfelektől BELSŐ JOIN Megrendelések ON ügyfelek. CustomerId = Megrendelések. Ügyfélkód RENDEZÉS Cím szerint; Ha a DISTINCTROW összetevőt kihagyjuk, a lekérdezés több sort eredményez minden egyes szervezethez, amely többször rendelte meg. A DISTINCTROW összetevő csak akkor lép érvénybe, ha mezőket választ ki a lekérdezésben használt egyes táblákból. A DISTINCTROW komponens figyelmen kívül marad, ha a lekérdezés csak egy táblát tartalmaz, vagy ha a mezőket az összes táblából lekéri. |
|
TOP n | A megadott számú rekordot adja vissza, amelyek az ORDER BY záradék által meghatározott tartomány első vagy utolsó rekordjai között vannak. Tegyük fel, hogy szeretné megjeleníteni az 1994-es osztály legjobb 25 tanulójának nevét. Keresztnév családnév HOL Érettségi Év = 2003 ORDER BY GradePointAverage DESC; Ha nem tartalmazza az ORDER BY záradékot, a lekérdezés egy 25 rekordból álló véletlenszerű halmazt ad vissza a Hallgatók táblából, amely kielégíti a WHERE záradékot. A TOP predikátum nem tartalmaz választást az egyenlő értékek között. Ha az előző példában a 25. és 26. rekordnak ugyanaz a GPA, akkor a lekérdezés 26 rekordot adna vissza. Használhatja a PERCENT fenntartott szót is az ORDER BY záradék által meghatározott tartomány első vagy utolsó rekordjainak bizonyos százalékának lekérésére. Tegyük fel, hogy a felső 25 helyett a végzős osztály tanulóinak alsó 10%-át szeretné megjeleníteni. A TOP 10 SZÁZALÉK KIVÁLASZTÁSA Keresztnév családnév HOL Érettségi Év = 2003 RENDELÉS GradePointAverage ASC; Az ASC predikátum a tartomány alsó részéből származó értékek kimenetét határozza meg. A TOP predikátumot követő értéknek Integer adattípusnak kell lennie. Az egész számok tárolására használt alapvető adattípus. Az Integer változó 64 bites (8 bájtos) számként van tárolva a -32768 és 32767 közötti tartományban. ) előjel nélküli . A TOP predikátum nem befolyásolja, hogy a lekérdezés frissíthető-e. |
asztal | A tábla neve, amelyből a rekordokat lekéri. |
Lásd még
SELECT utasítás
FROM záradék
WHERE záradék
Meghatározza, hogy a FROM záradékban felsorolt táblákból mely rekordokat dolgozza fel a SELECT, UPDATE vagy DELETE utasítás.
Szintaxis
KIVÁLASZTÁS field_list
TÓL TŐL táblázat_kifejezés
AHOL kiválasztási_feltételek
A WHERE záradékot tartalmazó SELECT utasítás a következő részeket tartalmazza.
Rész | Leírás |
field_list | A lekért mező vagy mezők neve az álnevekkel együtt (Alias (SQL). Egy kifejezésben lévő tábla vagy mező alternatív neve. Az álneveket általában rövidebb tábla- vagy mezőnévként használják a későbbi hivatkozás megkönnyítése érdekében programokat, hogy megakadályozzuk a félreérthető hivatkozásokat, és leíróbb neveket kapjunk a lekérdezési eredmények megjelenítésekor.), predikátumokat (ALL, DISTINCT, DISTINCTROW vagy TOP), vagy a SELECT utasítás bármely más paraméterével. |
táblázat_kifejezés | Annak a táblának vagy tábláknak a neve, amelyekből az adatokat lekéri. |
kiválasztási_feltételek | Kifejezés (Kifejezés. Matematikai és logikai operátorok, konstansok, függvények, mezőnevek, vezérlőelemek és tulajdonságok kombinációja, amely egyetlen értéket eredményez. A kifejezés számításokat végezhet, szöveget dolgozhat fel vagy adatokat ellenőrizhet.), amelynek meg kell egyeznie a benne foglalt rekordokkal a lekérdezés eredményeiben. |
Megjegyzések
A Microsoft Access adatbázismotor olyan rekordokat választ ki, amelyek megfelelnek a WHERE záradékban felsorolt feltételeknek. Ha a WHERE záradék nincs megadva, a lekérdezés a táblázat összes sorát visszaadja. Ha egy lekérdezés több táblát ad meg, de nem ad meg WHERE vagy JOIN záradékot, akkor a lekérdezés egy derékszögű szorzatot hoz létre (derékszögű szorzat. Olyan SQL SELECT utasítás végrehajtásának eredménye, amelynek van egy FROM záradéka, amely két vagy több táblára hivatkozik, és nincs WHERE vagy Az összekapcsolás módját meghatározó JOIN záradék.) táblák.
A WHERE záradék nem kötelező, de ha használjuk, akkor követnie kell a FROM záradékot. Kiválaszthatja például az értékesítési osztály összes alkalmazottját (WHERE Osztály = "Értékesítés") vagy az összes 18 és 30 év közötti ügyfelet (WHERE Age Between 18 and 30).
Ha a JOIN záradékot nem használjuk több táblán végzett SQL-illesztési művelethez, az eredményül kapott objektum Rekordkészlet frissíteni lehetetlen lesz.
A WHERE záradék hasonló a HAVING záradékhoz, és meghatározza a kiválasztott rekordokat. Miután a rekordokat a GROUP BY záradék csoportosította, a HAVING záradék határozza meg a megjelenítendő rekordot is.
A WHERE záradék olyan rekordok kizárására szolgál, amelyeket nem kell a GROUP BY záradékkal csoportosítani.
Különféle kifejezések segítségével határozza meg, hogy az SQL utasítás mely rekordokat adja vissza. Például a következő SQL utasítás minden olyan alkalmazottat kiválaszt, akinek a fizetése meghaladja a RUR-t.
SELECT Vezetéknév, Fizetés FROM Alkalmazottak WHERE Fizetés > 21000;
A WHERE záradék legfeljebb 40 logikai operátorokkal összekapcsolt kifejezést tartalmazhat (pl. ÉSÉs VAGY).
Ha olyan mezőnevet ír be, amely szóközöket vagy írásjeleket tartalmaz, akkor azt szögletes zárójelek közé kell tennie. Például egy ügyféladatokat tartalmazó táblázat konkrét ügyfelekre vonatkozó információkat tartalmazhat.
KIVÁLASZTÁS [Az ügyfél kedvenc étterme]
Egy argumentum megadása kiválasztási_feltételek, dátum literálok (Dátum literál. Bármely érvényes formátumú karaktersorozat, számjelek (#) közé zárva. Az érvényes formátumok a Nyelvi és szabványok beállításaiban és az Univerzális dátumformátumban megadott dátumformátumok.) Amerikai formátumban kell ábrázolni , még akkor is, ha nem amerikai dátumformátumot használunk.. a Microsoft Access adatbázismotor verziója. Például az "1996. május 10." dátum az Egyesült Királyságban 10/5/96, Oroszországban pedig 1996. 10. 05. Ne felejtse el a dátum literálokat számjelekbe (#) mellékelni, ahogy az alábbi példákban is látható.
Az 1996. május 10-i rekordok megkereséséhez az Egyesült Királyság adatbázisában használja a következő SQL utasítást:
SELECT * FROM Megrendelések WHERE Szállítási dátum = #10.05.1996#;
Használhatja a funkciót is DateValue, nemzetközi paraméterek felismerése, a Microsoft telepítette Windows®. Például Oroszország esetében használja ezt a kódot:
SELECT * FROM Megrendelések WHERE Szállítás dátuma = DateValue("05/10/1996");
A következő kód pedig az Egyesült Királyságra vonatkozik:
SELECT * FROM Rendelések WHERE Szállítás dátuma = DateValue("10/5/96");
Jegyzet. Ha a kiválasztási feltételek sorában megadott oszlop GUID típusú (Replikaazonosító (GUID). 16 bájtos mező a Microsoft Access adatbázisban, amely a replikáció egyedi azonosítására szolgál. A GUID-k a replikák, replikakészletek, táblák, rekordok és A Microsoft Access adatbázisokban a GUID kódokat replikakódoknak nevezik.), a kiválasztási feltételek kissé eltérő szintaxist használnak.
WHERE ReplicaID = (GUID (AB-CDEF0ABCDEF))
Győződjön meg arról, hogy a beágyazott zárójelek és kötőjelek megfelelően vannak elhelyezve.
Forrás oldal: http://office. /ru-ru/access/HA.aspx? pid=CH
GROUP BY záradék
Egy rekordba egyesíti a megadott mezők listájában szereplő azonos értékű rekordokat. Minden rekordhoz összefoglaló érték jön létre, ha egy SQL összesítő függvény szerepel a SELECT utasításban, mint pl. Összeg vagy Számol.
Szintaxis
KIVÁLASZTÁS field_list
TÓL TŐL asztal
AHOL kiválasztási_feltétel
A GROUP BY záradékot tartalmazó SELECT utasítás a következő elemeket tartalmazza:
Elem | Leírás |
field_list | A lekért mezők nevei az álnevekkel együtt (Alias (SQL). Egy kifejezésben lévő tábla vagy mező alternatív neve. Az álneveket általában rövidebb tábla- vagy mezőnévként használják a későbbi hivatkozások megkönnyítése érdekében a programokban, hogy elkerüljük a félreérthető hivatkozásokat, és informatívabb neveket kapjunk a lekérdezési eredmények megjelenítésekor.) és statisztikai SQL függvények, predikátumok (ALL, DISTINCT, DISTINCTROW vagy TOP) vagy a SELECT utasítás egyéb paraméterei |
asztal | |
kiválasztási_feltételek | Kiválasztási feltétel. Ha az utasítás WHERE záradékot tartalmaz, akkor a rekordokra való alkalmazása után az értékeket a Microsoft Access adatbázismotor csoportosítja. |
group_field_list | group_field_list |
Megjegyzések
A GROUP BY záradék nem kötelező.
Ha az SQL statisztikai függvényei nem szerepelnek a SELECT utasításban, az összegző értékek nem kerülnek kiszámításra.
GROUP BY mezőértékek, amelyek nulla (Null. Olyan érték, amely beírható egy mezőbe, vagy használható kifejezésekben és lekérdezésekben a hiányzó vagy ismeretlen adatok jelzésére. A Visual Basicben a Null kulcsszó Null értéket ad meg. Egyes mezők, mint pl. mint elsődleges kulcs mezők, a not tartalmazhatnak Null értékeket.), csoportosítva vannak, és nem maradnak ki. Azonban az értékek Nulla egyik SQL statisztikai függvény sem értékeli ki.
A WHERE záradék a nem csoportosítandó sorok kizárására szolgál. A HAVING záradék a rekordok csoportosítás utáni szűrésére szolgál.
A GROUP BY mezőlista mezői, amelyek nem tartalmaznak Memo adattípust (Memo Field adattípus. Mezőadattípus a Microsoft Access adatbázisban. A MEMO mező legfeljebb 65535 karaktert tartalmazhat.) vagy OLE Object (Mező adattípusa) OLE objektum" A Microsoft Access adatbázisba hivatkozott vagy abba beágyazott egyéb alkalmazásokból származó objektumok mentésére használt mezőadattípus.) hivatkozhat a FROM záradékban megadott tábla bármely mezőjére, még akkor is, ha a mező nem szerepel a SELECT utasításban. Ehhez elegendő, ha legalább egy SQL statisztikai függvény szerepel a SELECT utasításban. A Microsoft Access adatbázismotor nem teszi lehetővé a MEMO Field vagy OLE Object adatokat tartalmazó mezők szerinti csoportosítást.
A SELECT mezőlista minden mezőjének vagy egy GROUP BY záradéknak kell lennie, vagy egy SQL-összesítő függvény argumentumának kell lennie.
Lásd még
SELECT utasítás
SELECT...INTO utasítás
Predikátumok ALL, DISTINCT, DISTINCTROW, TOP
FROM záradék
VAN ajánlat
RENDELÉS záradék szerint
WHERE záradék
SQL statisztikai függvények
Forrás oldal: http://office. /ru-ru/access/HA.aspx? pid=CH
VAN ajánlat
Csoportosított rekordokat határoz meg, amelyeknek egy GROUP BY záradékkal rendelkező SELECT utasításban kell megjelenniük. Miután a rekordokat a GROUP BY záradékkal csoportosította, a HAVING záradék megmutatja azokat, amelyek megfelelnek a feltételeknek.
Szintaxis
KIVÁLASZTÁS field_list
TÓL TŐL asztal
AHOL kiválasztási_feltételek
CSOPORTOSÍT group_field_list
A HAVING záradékot tartalmazó SELECT utasítás a következő elemeket tartalmazza:
Elem | Leírás |
field_list | Az álnevekkel együtt betöltött mezők nevei (Alias (SQL). Egy kifejezésben lévő tábla vagy mező alternatív neve. Az álneveket általában rövidebb tábla- vagy mezőnévként használják a későbbi hivatkozások megkönnyítése érdekében a programokban, a félreérthető hivatkozások elkerülése, valamint a lekérdezés eredményeinek megjelenítésekor informatívabb nevek beszerzése.) és SQL statisztikai függvények, predikátumok (ALL, DISTINCT, DISTINCTROW vagy TOP) vagy a SELECT utasítás egyéb paramétereivel. |
asztal | A tábla neve, amelyből a rekordok betöltődnek |
kiválasztási_feltétel | Kiválasztási feltétel. Ha az utasítás WHERE záradékot tartalmaz, a Microsoft Access adatbázismotor csoportosítja az értékeket, miután alkalmazta a rekordokra. |
group_field_list | A rekordok csoportosításához használt mezők neve (legfeljebb 10). A nevek sorrendje group_field_list meghatározza a csoportosítás szintjét - a legmagasabbtól a legalacsonyabbig |
csoport_feltétele | Egy kifejezés, amely meghatározza a megjelenítendő rekordokat |
Megjegyzések
A HAVING záradék nem kötelező.
A HAVING záradék hasonló a WHERE záradékhoz, amely meghatározza a rekordok kiválasztását. A rekordok GROUP BY záradékkal történő csoportosítása után a HAVING záradék határozza meg a megjelenítendő rekordokat.
SELECT TypeCode,
Összeg (Raktáron)
A termékektől
GROUP BY TypeCode
HAVING Sum (Raktáron) > 100 És Like "TEL*";
A HAVING záradék legfeljebb 40 olyan kifejezést tartalmazhat, amelyeket logikai operátorok kapcsolnak össze, mint pl ÉsÉs Vagy.
Forrás oldal: http://office. /ru-ru/access/HA.aspx? pid=CH
RENDELÉS záradék szerint
A lekérdezés által visszaadott rekordokat a megadott mező(k) értékei szerint növekvő vagy csökkenő sorrendbe rendezi.
Szintaxis
KIVÁLASZTÁS field_list
TÓL TŐL asztal
AHOL kiválasztási_feltétel
[, mező2 ][, ...]]]
Az ORDER BY záradékot tartalmazó SELECT utasítás a következő elemeket tartalmazza.
Elem | Leírás |
field_list | A lekért mezők nevei az álnevekkel együtt (Alias (SQL). Egy kifejezésben lévő tábla vagy mező alternatív neve. Az álneveket általában rövidebb tábla- vagy mezőnévként használják a későbbi hivatkozások megkönnyítése érdekében a programokban, a félreérthető hivatkozások elkerülése, valamint a lekérdezés eredményeinek megjelenítésekor informatívabb nevek beszerzése.) és SQL statisztikai függvények, predikátumok (ALL, DISTINCT, DISTINCTROW vagy TOP) vagy a SELECT utasítás egyéb paramétereivel. |
asztal | A tábla neve, amelyből a rekordokat lekéri |
kiválasztási_feltételek | Kiválasztás feltételei. Ha az utasítás WHERE záradékot tartalmaz, akkor a rekordokra való alkalmazása után a Microsoft Access adatbázismotor rendezi a rekordok értékeit |
mező1, mező2 | Azon mezők nevei, amelyek alapján a rekordok rendezve vannak. |
Megjegyzések
Az ORDER BY záradék nem kötelező. Akkor kell használni, ha az adatokat rendezett formában kell megjeleníteni.
Az alapértelmezett rendezési sorrend (Rendezési sorrend. Az adatok elrendezésének módja az értékek és típusuk alapján. Az adatok rendezhetők ábécé sorrendben, számértékek vagy dátum szerint. A rendezési sorrend lehet növekvő (0-tól 100-ig, A-tól) Z) vagy csökkenő (100-tól 0-ig, Z-től A-ig).) növekvő (A-tól Z-ig, 0-tól 9-ig). Az alábbi példák bemutatják az alkalmazottak nevének vezetéknév szerinti rendezését.
SELECT Vezetéknév, Keresztnév
Az alkalmazottaktól
ORDER BY Vezetéknév;
SELECT Vezetéknév, Keresztnév
Az alkalmazottaktól
ORDER BY Vezetéknév ASC;
A mezők csökkenő sorrendbe rendezéséhez (Z-től A-ig, 9-től 0-ig) fűzze a fenntartott DESC szót az egyes mezők nevéhez. A következő példa az alkalmazottak fizetése alapján csökkenő sorrendben történő rendezést mutatja be.
SELECT Vezetéknév, Fizetés
Az alkalmazottaktól
RENDELÉS BÉR DESC, Vezetéknév;
Ha az ORDER BY záradékban olyan mezőket ad meg, amelyek MEMO Field (Memo Field adattípus. Mezőadattípus Microsoft Access adatbázisban. Egy MEMO mező legfeljebb 65 535 karakterből állhat.) vagy OLE Object Field (OLE Object) típusú adatokat tartalmaznak. Mezőadattípus "Mezőadattípus, amely más alkalmazásokból származó objektumok mentésére szolgál, amelyek Microsoft Access adatbázishoz kapcsolódnak vagy beágyazódnak.), ez hibát generál. A Microsoft Access adatbázismotor nem tudja rendezni ezeket a mezőtípusokat.
Az ORDER BY záradék általában az SQL utasítás utolsó záradéka (SQL utasítás (string). Olyan kifejezés, amely meghatároz egy SQL-parancsot, például SELECT, UPDATE vagy DELETE, és olyan záradékokat tartalmaz, mint a WHERE vagy ORDER BY. SQL utasítások A /karakterláncokat általában lekérdezésekben és statisztikai függvényekben használják.).
Az ORDER BY záradékban további mezőket is felvehet. A rekordokat először az ORDER BY záradékban először megadott mező szerint rendezi a rendszer. Az első mezőben azonos értékű rekordokat a rendszer a második mezőben megadott mező szerint rendezi, és így tovább.
Lásd még
SELECT utasítás
SELECT...INTO utasítás
Predikátumok ALL, DISTINCT, DISTINCTROW, TOP
FROM záradék
GROUP BY záradék
VAN ajánlat
WHERE záradék
SQL statisztikai függvények
Forrás oldal: http://office. /ru-ru/access/HA.aspx? pid=CH
INNER JOIN művelet
Két tábla rekordjait egyesíti, ha ezeknek a tábláknak az összekötő mezői azonos értékeket tartalmaznak.
Szintaxis
TÓL TŐL Asztal 1 BELSŐ ÖSSZEKAPCSOLÁS 2. táblázat TOVÁBB Asztal 1.mező1 összehasonlító_operátor táblázat2.mező2
Az INNER JOIN művelet a következő elemekből áll:
Elem | Leírás |
Asztal 1, 2. táblázat | Az összekapcsolandó rekordokat tartalmazó táblák nevei |
mező1, mező2 | A csatolandó mezők nevei. A nem numerikus mezőknek azonos adattípusúaknak kell lenniük (Adattípus. Mezőjellemző, amely meghatározza, hogy a mező milyen adattípust tartalmazhat. Az adattípusok a következők: logikai érték, egész, hosszú, pénznem, egyszeri, dupla, dátum, karakterlánc, és Variant (alapértelmezett).) és azonos típusú adatokat tartalmaznak. Ezeknek a mezőknek a neve azonban eltérő lehet |
összehasonlító_operátor | Bármely összehasonlító operátor: (=,<, >, <=, >= vagy<>) |
