Sette inn, slette, oppdatere poster i databasen. Hvordan sende en spørring til en database ved hjelp av VBA Access Opprette sql-spørringer i access-navnebror
Laboratoriearbeid nr. 1
SQL: DATAUTTREKK - kommandoPLUKKE UT
Målet med arbeidet:
- bli kjent med SQL-setninger;
- lær hvordan du lager enkle SQL-spørringer i Access ved å bruke SELECT-kommandoen;
· bruk av operatører IN, MELLOM, LIKE, ER NULL.
Trening№1. Opprett en spørring for å velge i SQL-modus alle verdiene i FIRST NAME- og LAST NAME-feltene fra STUDENTS-tabellen.
VELG FORNAVN, ETTERNAVN
FRA ELEVER;
Trening№2 . Opprett en spørring for å velge alle kolonnene i STUDENTS-tabellen i SQL-modus.
PLUKKE UT *
FRA ELEVER;
Oppgave nr. 3. Lag en spørring for å velge i SQL-modus navnene på byene der elevene bor, informasjon om hvilke er i PERSONLIG DATA-tabellen.
VELG DISTINKT BY
FRA [PERSONLIG DATA];
Oppgave nr. 4. Lag en utvelgelsesspørring i SQL-modus som henter navnene på alle elevene med etternavnet Ivanov, informasjon om hvilken er i STUDENTER-tabellen.
VELG ETTERNAVN, FORNAVN
FRA ELEVER
WHERE LAST NAME="Ivanov";
Oppgave nr. 5. Opprett en utvalgsspørring i SQL-modus for å få for- og etternavn til studenter som studerer i UIT-22-gruppen på en budsjettform for utdanning.
VELG ETTERNAVN, FORNAVN
FRA ELEVER
WHERE GROUP="UIT-22" OG BUDGET=true;
Oppgave nr. 6. Opprett en spørring i SQL-modus. for et utvalg fra EKSAMEN-tabellen, informasjon om elever som kun har karakterene 4 og 5.
PLUKKE UT *
FRA [ENDRINGEKSAMEN]
HVORKARAKTERIN(4,5);
Oppgave nr. 7. Lag en zanpoc- og SQL-modus for å velge informasjon om elever som har eksamenskarakteren 3 i faget IOSU.
PLUKKE UT *
FRA [ENDRINGEKSAMEN]
HVORPUNKT=" IOSU"OgKARAKTERIkke i (4,5);
Oppgave nr. 8. Opprett en spørring i SQL-modus for å velge poster for elementer med timer mellom 100 og 130.
PLUKKE UT *
FRAARTIKLER
HVORSEMELLOM 100 OG 130;
Oppgave nr. 9. Opprett en spørring i SQL-modus for å velge fra STUDENTS-tabellen informasjon om elever hvis etternavn begynner, for eksempel med bokstaven "C".
PLUKKE UT *
FRASTUDENTER
HVORETTERNAVNSOM"MED*";
Konklusjon: I løpet av laboratoriearbeid ble kjent med SQL-instruksjoner, lærte å lage enkle SQL-spørringer i Access ved å bruke SELECT-kommandoen ved å bruke IN, BETWEEN, LIKE-operatorene.
Denne leksjonen er dedikert til SQL-spørringer til databasen på VBA-tilgang. Vi skal se på hvordan INSERT, UPDATE, DELETE-spørringer lages til databasen i VBA, og vi vil også lære hvordan du får en spesifikk verdi fra en SELECT-spørring.
De som programmerer i VBA-tilgang og mens du arbeider med basen SQL-data servere står veldig ofte overfor en så enkel og nødvendig oppgave som å sende en SQL-spørring til en database, enten det er INSERT, UPDATE eller en enkel SQL SELECT-spørring. Og siden vi er nybegynnere programmerere, bør vi også kunne gjøre dette, så i dag skal vi gjøre nettopp det.
Vi har allerede vært inne på temaet innhenting av data fra SQL server, hvor de skrev kode i VBA for å få tak i disse dataene, for eksempel i artikkelen om Opplasting av data til en tekstfil fra MSSql 2008 eller også berørt det litt i materialet Laste opp data fra Access til en Word- og Excel-mal, men på en eller annen måte så vi på det overfladisk, og i dag foreslår jeg å snakke om dette litt mer detaljert.
Merk! Alle eksemplene nedenfor vurderes å bruke Access 2003 ADP-prosjektet og MSSql 2008-databasen. Hvis du ikke vet hva et ADP-prosjekt er, så vi på dette i materialet Hvordan opprette og konfigurere et Access ADP-prosjekt
Kildedata for eksempler
La oss si at vi har en tabell test_table, som vil inneholde tallene og navnene på månedene i året (spørringer utføres ved å bruke Management Studio)
LAG TABELL .( IKKE NULL, (50) NULL) PÅ GÅR
Som jeg allerede har sagt, vil vi bruke et ADP-prosjekt konfigurert til å fungere med MS SQL 2008, der jeg opprettet et testskjema og la til en startknapp med en signatur "Løpe", som vi trenger for å teste koden vår, dvs. Vi vil skrive all koden i hendelsesbehandleren " Knappetrykk».
Spørringer til databasen INSERT, UPDATE, DELETE i VBA
For ikke å utsette for lenge, la oss komme i gang med en gang, la oss si at vi må legge til en rad i testtabellen vår ( kode kommentert)/
Private Sub start_Click() "Erklære en variabel for å lagre spørringsstrengen Dim sql_query As String "Skriv spørringen vi trenger inn i den sql_query = "INSERT INTO test_table (id, name_mon) VALUES ("6", "juni")" "Utfør it DoCmd. RunSQL sql_query End Sub
I dette tilfellet utføres spørringen ved å bruke gjeldende databasetilkoblingsparametere. Vi kan sjekke om dataene er lagt til eller ikke.
Som du kan se, er dataene lagt inn.
For å slette en linje skriver vi følgende kode.
Private Sub start_Click() "Erklære en variabel for å lagre spørringsstrengen Dim sql_query As String "Skriv en slettespørring inn i den sql_query = "DELETE test_table WHERE id = 6" "Kjør den DoCmd.RunSQL sql_query End Sub
Hvis vi sjekker, vil vi se at ønsket linje er slettet.
For å oppdatere dataene, skriv oppdateringsforespørselen til sql_query-variabelen, jeg håper meningen er klar.
SELECT-spørring til en database i VBA
Her er ting litt mer interessant enn med andre SQL-konstruksjoner.
Først, la oss si at vi trenger å hente alle dataene fra tabellen, og for eksempel vil vi behandle dem og vise dem i en melding, og du kan selvfølgelig bruke den til andre formål, for dette skriver vi følgende kode
Private Sub start_Click() "Erklære variabler "For et sett med poster fra databasen Dim RS As ADODB.Recordset "Query string Dim sql_query As String "String for visning av sammendragsdata i en melding Dim str As String "Opprett et nytt objekt for poster set RS = New ADODB .Recordset "Query line sql_query = "SELECT id, name_mon FROM test_table" "Kjør spørringen ved å bruke gjeldende RS.open sql_query, CurrentProject.Connection, adOpenDynamic, adLockOptimistic "Loop gjennom postene mens ikke ( RS.EOF) "Fyll variabelen for å vise meldingen str = str & RS.Fields("id") & "-" & RS.Fields("name_mon") & vbnewline "gå til neste post RS.MoveNext Wend " Send ut meldingen msgbox str End Sub
Her bruker vi allerede VBA Access-løkker for å iterere gjennom alle verdiene i rekordsettet vårt.
Men ganske ofte er det nødvendig å ikke hente alle verdier fra et sett med poster, men bare én, for eksempel månedens navn etter koden. Og for å gjøre dette er det litt dyrt å bruke en løkke, så vi kan ganske enkelt skrive en spørring som vil returnere bare én verdi og få tilgang til den, for eksempel får vi månedens navn ved å bruke kode 5
Private Sub start_Click() "Declare variables" For et sett med poster fra databasen Dim RS As ADODB.Recordset "Query string Dim sql_query As String "String for å vise den endelige verdien Dim str As String "Opprett et nytt objekt for postsett RS = Nytt ADODB.Recordset "Query line sql_query = "SELECT name_mon FROM test_table WHERE id = 5" "Kjør spørringen ved å bruke gjeldende RS.open sql_query, CurrentProject.Connection, adOpenDynamic, adLockOptimistic "Få vår verdi str = RS. Fields(0) msgbox str End Sub
For universalitet, her har vi allerede adressert ikke med cellenavnet, men ved dets indeks, dvs. 0, og dette er den aller første verdien i Rekordsett, til slutt fikk vi verdien "Kan".
Som du kan se, er alt ganske enkelt. Hvis du ofte trenger å hente en bestemt verdi fra databasen ( som i det siste eksemplet), så anbefaler jeg å skrive ut all koden til en egen funksjon (Hvordan skrive en funksjon i VBA Access 2003) med én inngangsparameter, for eksempel månedskoden ( hvis vi ser på vårt eksempel) og ganske enkelt, der det er nødvendig å vise denne verdien, ring funksjonen vi trenger med den nødvendige parameteren, og det er det, ved å gjøre dette vil vi redusere VBA-koden betydelig og forbedre oppfatningen av programmet vårt.
Det var alt for i dag. Lykke til!
Beskrivelse av utdanningsprosjektet "Shop"Tabellkoblingsdiagram
Beskrivelse av tabeller
m_category - produktkategorier
m_inntekt - varemottak
m_utfall - forbruk av varer
m_product - katalog, produktbeskrivelser
m_supplier - katalog; leverandørinformasjon
m_unit - katalog; enheter
For å praktisk teste eksemplene gitt i dette opplæringsmaterialet, må du ha følgende programvare:
Microsoft Access 2003 eller nyere.
SQL-spørring i MS Access. Start
For å se innholdet i tabellen, dobbeltklikk på tabellnavnet i venstre panel:
For å bytte til redigeringsmodus for tabellfelt, klikk topppanel velg designmodus:
For å vise resultatet av en SQL-spørring, dobbeltklikk på spørringsnavnet i venstre rute:
For å bytte til redigeringsmodus for SQL-spørringer, velg SQL-modus i topppanelet:
SQL-spørring. Eksempler i MS Access. VELG: 1-10
I en SQL-spørring brukes SELECT-setningen til å velge fra databasetabeller.SQL-spørring Q001. Eksempel på SQL-spørring for å få bare de obligatoriske feltene i ønsket rekkefølge:
SELECT dt, product_id, amount
FRA m_inntekt;
SQL-spørring Q002. I dette eksempelet SQL-spørring brukes stjerne (*)-tegnet for å liste alle kolonnene i m_product-tabellen, med andre ord, for å få alle feltene i m_product-relasjonen:
PLUKKE UT *
FRA m_produkt;
Be omSQL Q003. DISTINCT-setningen brukes til å eliminere dupliserte oppføringer og få flere unike oppføringer:
VELG DISTINCT produkt-id
FRA m_inntekt;
SQL-spørring Q004. ORDER BY-setningen brukes til å sortere (ordre) poster etter verdiene til et spesifikt felt. Feltnavnet er spesifisert etter ORDER BY-setningen:
PLUKKE UT *
FRA m_inntekt
BESTILL ETTER pris;
SQL-spørring Q005. ASC-setningen brukes som et komplement til ORDER BY-setningen og tjener til å spesifisere stigende sortering. DESC-setningen brukes i tillegg til ORDER BY-setningen og brukes til å spesifisere synkende sortering. I tilfellet der verken ASC eller DESC er spesifisert, antas tilstedeværelsen av ASC (standard):
PLUKKE UT *
FRA m_inntekt
BESTILL PÅ dt DESC , pris;
SQL-spørring Q006. For å velge de nødvendige postene fra tabellen, brukes ulike logiske uttrykk som uttrykker valgbetingelsen. Det boolske uttrykket vises etter WHERE-setningen. Et eksempel på å hente alle poster fra m_inntektstabellen der beløpsverdien er større enn 200:
PLUKKE UT *
FRA m_inntekt
HVOR beløp>200;
SQL-spørring Q007. For uttrykk vanskelige forhold bruk de logiske operatorene AND (konjunksjon), OR (disjunksjon) og NOT (logisk negasjon). Et eksempel på å hente fra m_outcome-tabellen alle poster der beløpsverdien er 20 og prisverdien er større enn eller lik 10:
Pris
FRA m_utfall
WHERE beløp=20 OG pris>=10;
SQL-spørring Q008. For å slå sammen data fra to eller flere tabeller, bruk INNER JOIN, LEFT JOIN, RIGHT JOIN-instruksjonene. Følgende eksempel henter feltene dt, product_id, amount, price fra m_income-tabellen og tittelfeltet fra m_product-tabellen. M_income-tabellposten er koblet til m_product-tabellposten når verdien av m_income.product_id er lik verdien av m_product.id:
PÅ m_income.product_id=m_product.id;
SQL-spørring Q009. Det er to ting å merke seg i denne SQL-spørringen: 1) teksten du leter etter er vedlagt i enkelt sitater("); 2) datoen er gitt i formatet #Måned/Dag/År#, som er sant for MS Access. I andre systemer kan formatet for å skrive datoen være annerledes. Et eksempel på visning av informasjon om kvitteringen melk 12. juni 2011. Vær oppmerksom på datoformat #6/12/2011#:
SELECT dt, product_id, title, amount, price
FRA m_inntekt INDRE BLI MED M_produkt
WHERE title="Melk" And dt=#6/12/2011#; !}
SQL-spørring Q010. BETWEEN-instruksjonen brukes til å teste om en verdi tilhører et bestemt område. Et eksempel på SQL-spørring som viser informasjon om produkter mottatt mellom 1. juni og 30. juni 2011:
PLUKKE UT *
FRA m_inntekt INDRE BLI MED M_produkt
PÅ m_income.product_id=m_product.id
HVOR dt MELLOM #6/1/2011# Og #6/30/2011#;
SQL-spørring. Eksempler i MS Access. VELG: 11-20
En SQL-spørring kan nestes i en annen. En underspørring er ikke noe mer enn en spørring i en spørring. Vanligvis brukes en underspørring i WHERE-leddet. Men det finnes andre måter å bruke underspørringer på.Spørring Q011. Informasjon om produkter fra m_product-tabellen vises, kodene for disse er også i m_inntektstabellen:
PLUKKE UT *
FRA m_produkt
WHERE id IN (VELG produkt-ID FRA m_inntekt);
Spørring Q012. En liste over produkter fra m_product-tabellen vises, kodene som ikke er i m_outcome-tabellen:
PLUKKE UT *
FRA m_produkt
WHERE id NOT IN (VELG product_id FROM m_outcome);
Forespørsel Q013. Denne SQL-spørringen viser en unik liste over produktkoder og navn som er i m_income-tabellen, men ikke i m_outcome-tabellen:
SELECT DISTINCT product_id, title
FRA m_inntekt INDRE BLI MED M_produkt
PÅ m_income.product_id=m_product.id
WHERE product_id NOT IN (SELECT product_id FROM m_outcome);
Spørring Q014. En unik liste over kategorier hvis navn begynner med bokstaven M vises fra m_category-tabellen:
VELG DISTINKT tittel
FRA m_produkt
HVOR tittel SOM "M*";
Spørring Q015. Et eksempel på å utføre aritmetiske operasjoner på felt i en spørring og gi nytt navn til felt i en spørring (alias). Dette eksemplet beregner utgift = kvantitet*pris og fortjeneste for hver utgiftspost, forutsatt at fortjenesten er 7 prosent av salget:
beløp*pris/100*7 AS fortjeneste
FRA m_utfall;
Spørring Q016. Ved å analysere og forenkle aritmetiske operasjoner kan du øke hastigheten på utførelse av spørringer:
SELECT dt, product_id, amount, price, amount*price AS outcome_sum,
utfallssum*0,07 AS-resultat
FRA m_utfall;
Forespørsel Q017. Du kan bruke INNER JOIN-setningen til å slå sammen data fra flere tabeller. I følgende eksempel, avhengig av ctgry_id-verdien, matches hver oppføring i m_income-tabellen med navnet på kategorien fra m_category-tabellen som produktet tilhører:
VELG c.tittel, b.tittel, dt, beløp, pris, beløp*pris AS inntekt_sum
FRA (m_income AS a INNER JOIN m_product AS b ON a.product_id=b.id)
INNER JOIN m_category AS c PÅ b.ctgry_id=c.id
BESTILL ETTER c.title, b.title;
Forespørsel Q018. Funksjoner som SUM - sum, COUNT - mengde, AVG - aritmetisk gjennomsnittsverdi, MAX - maksimumsverdi, MIN - minimumsverdi kalles aggregerte funksjoner. De aksepterer mange verdier og returnerer en enkelt verdi etter å ha behandlet dem. Et eksempel på beregning av summen av produktet av feltene beløp og pris ved å bruke SUM-aggregatfunksjonen:
VELG SUM(beløp*pris) AS Total_Sum
FRA m_inntekt;
Spørsmål Q019. Et eksempel på bruk av flere aggregerte funksjoner:
SELECT Sum(amount) AS Amount_Sum, AVG(amount) AS Amount_AVG,
MAX(amount) AS Amount_Max, Min(amount) AS Amount_Min,
Count(*) AS Total_Number
FRA m_inntekt;
Forespørsel Q020. I dette eksemplet beregnes mengden av alle varer med kode 1, kapitalisert i juni 2011:
VELG Sum(beløp*pris) AS inntekt_sum
FRA m_inntekt
WHERE product_id=1 OG dt MELLOM #6/1/2011# OG #6/30/2011#;.
Spørring Q021. Følgende SQL-spørring beregner mengden salg av varer med kode 4 eller 6:
VELG Sum(beløp*pris) som utfallssum
FRA m_utfall
WHERE product_id=4 OR product_id=6;
Spørring Q022. Det er beregnet hvor mye varer med kode 4 eller 6 som ble solgt 12. juni 2011:
VELG Sum(beløp*pris) AS utfallssum
FRA m_utfall
WHERE (product_id=4 OR product_id=6) AND dt=#6/12/2011#;
Spørring Q023. Oppgaven er denne. Beregn det totale antallet varer i kategorien "Bakeriprodukter" som ble aktivert med store bokstaver.
For å løse dette problemet må du operere med tre tabeller: m_inntekt, m_produkt og m_kategori, fordi:
- mengden og prisen på aktiverte varer er lagret i m_inntektstabellen;
- kategorikoden for hvert produkt er lagret i m_product-tabellen;
- Navnet på tittelkategorien er lagret i tabellen m_category.
For å løse dette problemet vil vi bruke følgende algoritme:
- bestemme kategorikoden "Bakeriprodukter" fra m_category-tabellen ved å bruke en underspørring;
- koble sammen m_income og m_product-tabellene for å bestemme kategorien for hvert kjøpt produkt;
- beregning av mottaksbeløpet (= mengde*pris) for varer hvis kategorikode er lik koden definert av underspørringen ovenfor.
PLUKKE UT
FRA 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="Bakeriprodukter"); !}
Spørring Q024. Vi vil løse problemet med å beregne den totale mengden kapitaliserte varer i kategorien "Bakeriprodukter" ved å bruke følgende algoritme:
- for hver oppføring i m_income-tabellen, avhengig av verdien av produkt-ID-en, fra m_category-tabellen, samsvar med navnet på kategorien;
- velg poster som kategorien er "bakeriprodukter" for;
- beregn kvitteringsbeløp = mengde*pris.
FRA (m_product AS a INNER JOIN m_income AS b ON a.id=b.product_id)
WHERE c.title="Bakeriprodukter";
!}
Spørring Q025. Dette eksemplet beregner hvor mange varer som ble konsumert:
SELECT COUNT(product_id) AS product_cnt
FROM (SELECT DISTINCT product_id FROM m_outcome) AS t;
Spørring Q026. GROUP BY-setningen brukes til å gruppere poster. Vanligvis er poster gruppert etter verdien av ett eller flere felt, og noen aggregerte operasjoner brukes på hver gruppe. For eksempel genererer følgende spørring en rapport om salg av varer. Det vil si at det genereres en tabell som inneholder navnene på varene og beløpet de ble solgt for:
SELECT tittel, SUM(beløp*pris) AS outcome_sum
FRA m_product AS a INNER JOIN m_outcome AS b
PÅ a.id=b.product_id
GRUPPE ETTER tittel;
Spørring Q027. Salgsrapport etter kategori. Det vil si at det genereres en tabell som inneholder navn på produktkategorier, totalbeløpet som produktene i disse kategoriene ble solgt for, og gjennomsnittlig salgsbeløp. ROUND-funksjonen brukes til å runde av gjennomsnittsverdien til nærmeste hundredel (det andre sifferet etter desimalskilletegn):
SELECT c.title, SUM(amount*price) AS outcome_sum,
ROUND(AVG(beløp*pris),2) AS utfallssum_gjennomsnitt
FRA (m_product AS a INNER JOIN m_outcome AS b ON a.id=b.product_id)
INNER JOIN m_category AS c PÅ a.ctgry_id=c.id
GRUPPE ETTER c.tittel;
Spørring Q028. Det totale og gjennomsnittlige antallet kvitteringer beregnes for hvert produkt og viser informasjon om produkter hvis totale kvitteringer er minst 500:
SELECT product_id, SUM(amount) AS amount_sum,
Round(Avg(amount),2) AS number_avg
FRA m_inntekt
GROUP BY product_id
HAR Sum(beløp)>=500;
Spørsmål Q029. Denne spørringen beregner for hvert produkt beløpet og gjennomsnittet av dets kvitteringer i andre kvartal 2011. Hvis totalbeløpet på produktkvitteringen er minst 1000, vises informasjon om dette produktet:
SELECT tittel, SUM(beløp*pris) SOM inntektssum
FRA m_inntekt a INNER JOIN m_product b PÅ a.product_id=b.id
HVOR dt MELLOM #4/1/2011# OG #6/30/2011#
GRUPPE ETTER tittel
HAR SUM(beløp*pris)>=1000;
Spørring Q030. I noen tilfeller må du matche hver post i en tabell med hver post i en annen tabell; som kalles det kartesiske produktet. Tabellen som er et resultat av en slik forbindelse kalles Descartes' tabell. For eksempel, hvis en tabell A har 100 poster og tabell B har 15 poster, vil Descartes-tabellen deres bestå av 100*15=150 poster. Følgende spørring slår sammen hver post i m_income-tabellen med hver post i m_outcome-tabellen:
FRA m_inntekt, m_utfall;
Spørring Q031. Et eksempel på gruppering av poster etter to felt. Følgende SQL-spørring beregner for hver leverandør mengden og mengden varer mottatt fra ham:
SUM(beløp*pris) AS inntekt_sum
Forespørsel Q032. Et eksempel på gruppering av poster etter to felt. Følgende spørring beregner for hver leverandør mengden og mengden av produktene deres solgt av oss:
VELG leverandør_id, produkt_id, SUM(beløp) AS beløpsum,
GROUP BY supplier_id, product_id;
Spørring Q033. I dette eksemplet brukes de to spørringene ovenfor (q031 og q032) som underspørringer. Resultatene av disse spørringene ved hjelp av LEFT JOIN-metoden er kombinert til én rapport. Følgende spørring viser en rapport om mengde og mengde produkter mottatt og solgt for hver leverandør. Vær oppmerksom på at hvis et produkt allerede er mottatt, men ennå ikke er solgt, vil utfallssum-cellen for denne oppføringen være tom. , at denne forespørselen kun tjener som eksempel på bruk vedr komplekse spørsmål som en underspørring. Ytelsen til denne SQL-spørringen med en stor mengde data er tvilsom:
PLUKKE UT *
FRA
SUM(beløp*pris) AS inntekt_sum
PÅ a.product_id=b.id GROUP BY supplier_id, product_id) AS a
VENSTRE BLI MED
(VELG leverandør_id, produkt_id, SUM(beløp) AS beløpsum,
SUM(beløp*pris) AS utfallssum
FROM m_outcome AS a INNER JOIN m_product AS b
PÅ a.product_id=b.id GROUP BY supplier_id, product_id) AS b
PÅ (a.product_id=b.product_id) OG (a.supplier_id=b.supplier_id);
Spørring Q034. I dette eksemplet brukes de to spørringene ovenfor (q031 og q032) som underspørringer. Resultatene av disse spørringene ved hjelp av RIGTH JOIN-metoden kombineres til én rapport. Følgende spørring viser en rapport om betalingsbeløpet til hver klient i henhold til betalingssystemene han brukte og investeringene han gjorde. Følgende spørring viser en rapport om mengde og mengde produkter mottatt og solgt for hver leverandør. Vær oppmerksom på at hvis et produkt allerede er solgt, men ennå ikke har kommet, vil inntektssum-cellen for denne oppføringen være tom. Tilstedeværelsen av slike tomme celler er en indikator på en feil i salgsregnskapet, siden før et salg er det først nødvendig at det tilsvarende produktet kommer:
PLUKKE UT *
FRA
(VELG leverandør_id, produkt_id, SUM(beløp) AS beløpsum,
SUM(beløp*pris) AS inntekt_sum
FROM m_income AS a INNER JOIN m_product AS b ON a.product_id=b.id
GROUP BY supplier_id, product_id) AS a
HØYRE BLI MED
(VELG leverandør_id, produkt_id, SUM(beløp) AS beløpsum,
SUM(beløp*pris) AS utfallssum
FRA m_outcome AS a INNER JOIN m_product AS b ON a.product_id=b.id
GROUP BY supplier_id, product_id) AS b
PÅ (a.supplier_id=b.supplier_id) OG (a.product_id=b.product_id);
Spørring Q035. En rapport vises som viser mengden av inntekter og utgifter etter produkt. For å gjøre dette opprettes en liste over produkter i henhold til tabellene m_income og m_outcome, og for hvert produkt fra denne listen beregnes summen av inntekten i henhold til m_income-tabellen og utgiftsbeløpet i henhold til m_outcome-tabellen:
SELECT product_id, SUM(in_amount) AS income_amount,
SUM(out_amount) AS outcome_amount
FRA
(VELG produkt-id, beløp AS in_amount, 0 AS out_amount
FRA m_inntekt
UNION ALLE
SELECT product_id, 0 AS in_amount, amount AS out_amount
FRA m_utfall) AS t
GROUP BY product_id;
Forespørsel Q036. EXISTS-funksjonen returnerer TRUE hvis settet som sendes til det inneholder elementer. EXISTS-funksjonen returnerer FALSE hvis settet som sendes til det er tomt, det vil si at det ikke inneholder noen elementer. Følgende spørring viser produktkodene som finnes i både m_income- og m_outcome-tabellene:
VELG DISTINCT produkt-id
FRA m_inntekt AS a
WHERE EXISTS(VELG produkt-ID FRA m_utfall AS b
Spørring Q037. Produktkoder som finnes i både m_income og m_outcome-tabellene vises:
VELG DISTINCT produkt-id
FRA m_inntekt AS a
WHERE product_id IN (SELECT product_id FROM m_outcome)
Spørring Q038. Det vises produktkoder som finnes i m_income-tabellen, men som ikke finnes i m_outcome-tabellen:
VELG DISTINCT produkt-id
FRA m_inntekt AS a
WHERE NOT EXISTS(SELECT product_id FROM m_outcome AS b
WHERE b.product_id=a.product_id);
Spørring Q039. En liste over produkter med maksimalt salgsbeløp vises. Algoritmen er som følger. For hvert produkt beregnes salgsbeløpet. Deretter bestemmes maksimumet av disse beløpene. Deretter, for hvert produkt, beregnes summen av salget igjen, og koden og salgssummen for varer hvis salgssum er lik maksimum vises:
VELG produkt-id, SUM(beløp*pris) SOM beløpssum
FRA m_utfall
GROUP BY product_id
HAR SUM(beløp*pris) = (VELG MAX(s_beløp)
FROM (SELECT SUM(amount*price) AS s_amount FROM m_outcome GROUP BY product_id));
Spørring Q040. Reservert ord IIF ( betinget operatør) brukes til å evaluere et boolsk uttrykk og utføre en handling avhengig av resultatet (TRUE eller FALSE). I det følgende eksempelet regnes vareleveringen som "liten" hvis kvantumet er mindre enn 500. Ellers, det vil si at kvitteringsmengden er større enn eller lik 500, anses leveringen som "stor":
SELECT dt, product_id, amount,
IIF(beløp FRA m_inntekt;
SQL-spørring Q041. I tilfellet der IIF-operatøren brukes flere ganger, er det mer praktisk å erstatte den med SWITCH-operatøren. SWITCH-operatoren (multiple selection operator) brukes til å evaluere et logisk uttrykk og utføre en handling avhengig av resultatet. I følgende eksempel regnes det leverte partiet som "lite" hvis varemengden i partiet er mindre enn 500. Ellers, det vil si at hvis varemengden er større enn eller lik 500, regnes partiet som "stort ":
SELECT dt, product_id, amount,
SWITCH(mengde =500,"stor") AS-merke
FRA m_inntekt;
Spørring Q042. I neste forespørsel, hvis varemengden i det mottatte partiet er mindre enn 300, anses partiet som "lite". Ellers, det vil si hvis betingelsesbeløpet SELECT dt, product_id, amount,
IIF(beløp IIF(beløp FRA m_inntekt;
SQL-spørring Q043. I neste forespørsel, hvis varemengden i det mottatte partiet er mindre enn 300, anses partiet som "lite". Ellers, det vil si hvis betingelsesbeløpet SELECT dt, product_id, amount,
SWITCH(amount amount amount>=1000,"large") AS-merke
FRA m_inntekt;
SQL-spørring Q044. I følgende spørring er salget delt inn i tre grupper: liten (opptil 150), medium (fra 150 til 300), stor (300 eller mer). Deretter beregnes det totale beløpet for hver gruppe:
SELECT Category, SUM(outcome_sum) AS Ctgry_Total
FROM (VELG beløp*pris AS utfallssum,
IIf(beløp*pris IIf(beløp*pris FRA m_utfall) AS t
GRUPPE ETTER Kategori;
SQL-spørring Q045. DateAdd-funksjonen brukes til å legge til dager, måneder eller år til en gitt dato og få en ny dato. Neste forespørsel:
1) legger til 30 dager til datoen fra dt-feltet og viser den nye datoen i dt_plus_30d-feltet;
2) legger til 1 måned til datoen fra dt-feltet og viser den nye datoen i dt_plus_1m-feltet:
VELG dt, dateadd("d",30,dt) AS dt_plus_30d, dateadd("m",1,dt) AS dt_plus_1m
FRA m_inntekt;
SQL-spørring Q046. DateDiff-funksjonen er designet for å beregne forskjellen mellom to datoer i forskjellige enheter (dager, måneder eller år). Følgende spørring beregner forskjellen mellom datoen i dt-feltet og gjeldende dato i dager, måneder og år:
SELECT dt, DateDiff("d",dt,Date()) AS last_day,
DateDiff("m",dt,Date()) AS last_months,
DateDiff("åååå",dt,Dato()) AS siste_år
FRA m_inntekt;
SQL-spørring Q047. Antall dager fra datoen for mottak av varene (tabell m_inntekt) til gjeldende dato beregnes ved hjelp av DateDiff-funksjonen og utløpsdatoen sammenlignes (tabell m_produkt):
DateDiff("d",dt,Date()) AS siste_dager
FRA m_inntekt SOM INDRE BLI MED M_produkt AS b
PÅ a.product_id=b.id;
SQL-spørring Q048. Antall dager fra datoen for mottak av varene til gjeldende dato beregnes, deretter kontrolleres det om denne mengden overskrider utløpsdatoen:
SELECT a.id, product_id, dt, lifedays,
DateDiff("d",dt,Date()) AS last_days, IIf(last_days>lifedays,"Yes","No") AS date_expire
FRA m_inntekt a INNER JOIN m_produkt b
PÅ a.product_id=b.id;
SQL-spørring Q049. Antall måneder fra datoen for mottak av varene til gjeldende dato beregnes. Kolonne måned_siste1 beregner det absolutte antall måneder, kolonne månedsiste2 beregner antall hele måneder:
SELECT dt, DateDiff("m",dt,Date()) AS month_last1,
DatoDiff("m",dt,Dato())-iif(dag(dt)>dag(dato()),1,0) AS month_last2
FRA m_inntekt;
SQL Query Q050. En kvartalsrapport vises over mengden og mengden varer som er kjøpt for 2011:
SELECT kvartal, SUM(outcome_sum) AS Totalt
FROM (VELG beløp*pris AS utfall_sum, måned(dt) AS m,
SWITCH(m =10,4) AS kvartal
FRA m_inntekt HVOR år(dt)=2011) AS t
GRUPPE FOR kvartal;
Spørring Q051. Følgende spørring hjelper til med å finne ut om brukere var i stand til å legge inn informasjon om forbruk av varer i systemet i en mengde større enn mengden av mottatte varer:
SELECT product_id, SUM(in_sum) AS income_sum, SUM(out_sum) AS outcome_sum
FROM (VELG produkt-id, beløp*pris som in_sum, 0 som ut_sum
fra m_inntekt
UNION ALLE
VELG produkt-id, 0 som in_sum, beløp*pris som ut_sum
fra m_utfall) AS t
GROUP BY product_id
HAR SUM(i_sum)
Spørring Q052. Nummereringen av rader som returneres av en spørring, implementeres på forskjellige måter. Du kan for eksempel omnummerere linjene i en rapport utarbeidet i MS Access ved å bruke selve MS Access. Du kan også omnummerere ved å bruke programmeringsspråk, for eksempel VBA eller PHP. Noen ganger må dette imidlertid gjøres i selve SQL-spørringen. Så, følgende spørring vil nummerere radene i m_income-tabellen i henhold til den stigende rekkefølgen av ID-feltverdiene:
VELG ANTALL(*) som N, b.id, b.product_id, b.amount, b.price
FRA m_inntekt a INNER JOIN m_inntekt b PÅ a.id GRUPPE ETTER b.id, b.product_id, b.amount, b.price;
Spørring Q053. De fem beste produktene blant produktene etter salgsbeløp vises. De første fem postene skrives ut ved å bruke TOP-instruksjonen:
SELECT TOP 5, product_id, sum(amount*price) AS summa
FRA m_utfall
GROUP BY product_id
BESTILL ETTER sum(beløp*pris) DESK;
Spørring Q054. De fem beste produktene blant produktene etter salgsbeløp vises, og radene er nummerert som et resultat:
VELG ANTALL(*) AS N, b.product_id, b.summa
FRA
FROM m_outcome GROUP BY product_id) AS a
INDRE BLI MED
(SELECT product_id, sum(amount*price) AS summa,
summa*10000000+product_id AS-id
FROM m_outcome GROUP BY product_id) AS b
PÅ a.id>=b.id
GROUP BY b.product_id, b.summa
Å HA ANTALL(*)ORDEN ETTER ANTELL(*);
Spørring Q055. Følgende SQL-spørring viser bruken av de matematiske funksjonene COS, SIN, TAN, SQRT, ^ og ABS i MS Access SQL:
SELECT (velg count(*) fra m_inntekt) som N, 3,1415926 som pi, k,
2*pi*(k-1)/N som x, COS(x) som COS_, SIN(x) som SIN_, TAN(x) som TAN_,
SQR(x) som SQRT_, x^3 som "x^3", ABS(x) som ABS_
FRA (VELG ANTALL(*) AS k
FRA m_inntekt AS a INNER JOIN m_inntekt AS b PÅ a.idGROUP BY b.id) t;
SQL-spørring. Eksempler i MS Access. OPPDATERING: 1-10
Spørring U001. Følgende SQL-endringsspørring øker prisene på varer med kode 3 i m_inntektstabellen med 10 %:OPPDATERING m_inntekt SET pris = pris*1.1
WHERE product_id=3;
Forespørsel U002. Følgende SQL-oppdateringsspørring øker antallet av alle produkter i m_income-tabellen med 22 enheter hvis navn begynner med ordet "Oil":
OPPDATERING m_inntekt SET beløp = beløp+22
WHERE product_id IN (VELG ID FRA m_product WHERE tittel LIKE "Oil*");
Forespørsel U003. Følgende SQL-spørring for en endring i m_outcome-tabellen reduserer prisene på alle varer produsert av Sladkoe LLC med 2 prosent:
OPPDATERING m_outcome SET pris = pris*0,98
WHERE product_id IN
(VELG a.id FROM m_product a INNER JOIN m_supplier b
PÅ a.supplier_id=b.id WHERE b.title="LLC"Сладкое"");. !}
Sette inn, slette, oppdatere poster i en database
ExecuteReader()-metoden henter et dataleserobjekt som lar deg se resultatene av SQL Select-setningen ved å bruke en videresende skrivebeskyttet informasjonsstrøm. Men hvis du trenger å utføre SQL-setninger som endrer datatabellen, må du kalle metoden ExecuteNonQuery() av dette objektet lag. Denne enkeltmetoden er designet for å utføre innsettinger, endringer og slettinger, avhengig av formatet til kommandoteksten.
Konsept ikke-søk betyr en SQL-setning som ikke returnerer et resultatsett. Derfor, Velg utsagn er spørringer, men Insert-, Update- og Delete-setninger er det ikke. Følgelig returnerer ExecuteNonQuery()-metoden en int som inneholder antall rader som er påvirket av disse setningene, i stedet for et nytt sett med poster.
For å vise hvordan du endrer innholdet i en eksisterende database ved å bruke bare ExecuteNonQuery()-spørringen, er neste trinn å lage ditt eget datatilgangsbibliotek som innkapsler AutoLot-databaseprosessen.
I et ekte produksjonsmiljø vil ADO.NET-logikken din nesten helt sikkert være isolert i en .NET .dll-sammenstilling av én enkel grunn - gjenbruk av kode! Dette ble ikke gjort i tidligere artikler for ikke å distrahere deg fra oppgavene. Men det ville være bortkastet tid å utvikle den samme tilkoblingslogikken, den samme datalesingslogikken og den samme kommandoutførelseslogikken for hver applikasjon som må fungere med AutoLot-databasen.
Ved å isolere datatilgangslogikk i et .NET-kodebibliotek kan forskjellige applikasjoner med ethvert brukergrensesnitt (konsollstil, skrivebordstil, nettstil osv.) få tilgang til det eksisterende biblioteket, selv uavhengig av språk. Og hvis du utvikler et datatilgangsbibliotek i C#, vil andre .NET-programmerere kunne lage sine egne brukergrensesnitt på et hvilket som helst språk (for eksempel VB eller C++/CLI).
Datatilgangsbiblioteket vårt (AutoLotDAL.dll) vil inneholde et enkelt navneområde (AutoLotConnectedLayer) som vil samhandle med AutoLot-databasen ved å bruke ADO.NET-tilkoblede typer.
Start med å lage et nytt C# Class Library-prosjekt kalt AutoLotDAL (forkortelse for "AutoLot Data Access Layer"), og endre deretter det opprinnelige C#-kodefilnavnet til AutoLotConnDAL.cs.
Gi deretter nytt navn til omfanget av navneområdet til AutoLotConnectedLayer og endre navnet på den opprinnelige klassen til InventoryDAL, fordi denne klassen vil definere ulike medlemmer designet for å samhandle med Inventory-tabellen i AutoLot-databasen. Til slutt importerer du følgende .NET-navneområder:
Bruke System; bruker System.Collections.Generic; bruker System.Text; bruker System.Data; bruker System.Data.SqlClient; navneområde AutoLotConnectedLayer ( offentlig klasse InventoryDAL ( ) )
Legger til tilkoblingslogikk
Vår første oppgave er å definere metoder som lar anropsprosessen koble til og koble fra datakilden ved hjelp av en gyldig tilkoblingsstreng. Fordi vår AutoLotDAL.dll-sammenstilling vil bli hardkodet for å bruke System.Data.SqlClient-klassetyper, definer en privat SqlConnection-variabel som vil bli tildelt når InventoryDAL-objektet opprettes.
I tillegg, definer en metode OpenConnection() og deretter en annen CloseConnection() som vil samhandle med denne variabelen:
Offentlig klasse InventoryDAL ( privat SqlConnection connect = null; public void OpenConnection(string connectionString) ( connect = new SqlConnection(connectionString); connect.Open(); ) public void CloseConnection() ( connect.Close(); ) )
For korthets skyld vil ikke InventoryDAL-typen se etter alle mulige unntak, og vil ikke kaste egendefinerte unntak når ulike situasjoner oppstår (for eksempel når tilkoblingsstrengen er feil utformet). Men hvis du skulle bygge et, ville du sannsynligvis måtte bruke strukturerte unntakshåndteringsteknikker for å ta hensyn til eventuelle uregelmessigheter som kan oppstå under kjøring.
Legger til innsettingslogikk
Sett inn Ny inngang til Inventory-tabellen kommer ned til formatering av SQL-setningen Sett inn(avhengig av brukerinndata) og kaller ExecuteNonQuery()-metoden ved å bruke kommandoobjektet. For å gjøre dette, legg til en offentlig InsertAuto()-metode til InventoryDAL-klassen som tar fire parametere som tilsvarer de fire kolonnene i Inventory-tabellen (CarID, Color, Make og PetName). Basert på disse argumentene, generer en linje for å legge til en ny oppføring. Til slutt, utfør SQL-setningen ved å bruke SqlConnection-objektet:
Public void InsertAuto(int id, string color, string make, string petName) ( // SQL-setning string sql = string.Format("Insert Into Inventory" + "(CarID, Make, Color, PetName) Values(@CarId, @Make, @Color, @PetName)"); ved å bruke (SqlCommand cmd = new SqlCommand(sql, this.connect)) ( // Legg til parametere cmd.Parameters.AddWithValue("@CarId", id); cmd.Parameters.AddWithValue("@Make", make); cmd. Parameters.AddWithValue("@Color", farge); cmd.Parameters.AddWithValue("@PetName", petName); cmd.ExecuteNonQuery(); ) )
Å definere klasser som representerer poster i en relasjonsdatabase er en vanlig måte å lage et datatilgangsbibliotek på. Faktisk genererer ADO.NET Entity Framework automatisk sterkt skrevet klasser som lar deg samhandle med databasedata. Forresten, det frittstående laget til ADO.NET genererer sterkt innskrevne DataSet-objekter for å representere data fra en gitt tabell i en relasjonsdatabase.
Å lage en SQL-setning ved å bruke strengsammenkobling kan være en sikkerhetsrisiko (tenk på SQL-innsettingsangrep). Det er bedre å lage kommandoteksten ved å bruke en parameterisert spørring, som vil bli beskrevet litt senere.
Legger til slettelogikk
Fjerning eksisterende rekord ikke vanskeligere enn å sette inn en ny rekord. I motsetning til InsertAuto()-koden, vil ett viktig prøve-/fangstområde vises som håndterer den mulige situasjonen der det gjøres et forsøk på å fjerne en bil som noen allerede har bestilt fra Kunder-tabellen. Legg til følgende metode til InventoryDAL-klassen:
Public void DeleteCar(int id) ( string sql = string.Format("Slett fra inventar hvor CarID = "(0)"", id); bruker (SqlCommand cmd = new SqlCommand(sql, this.connect)) ( prøv ( cmd.ExecuteNonQuery(); ) catch (SqlException ex) ( Unntaksfeil = new Exception("Beklager, denne maskinen er i restordre!", ex); kastefeil; ) ) )
Legger til endringslogikk
Når det gjelder å oppdatere en eksisterende post i Inventory-tabellen, oppstår det åpenbare spørsmålet umiddelbart: hva nøyaktig kan anropsprosessen tillates å endre: fargen på bilen, det vennlige navnet, modellen eller alle tre? En måte å maksimere fleksibiliteten på er å definere en metode som tar en parameter av typen streng, som kan inneholde en hvilken som helst SQL-setning, men dette er mildt sagt risikabelt.
Ideelt sett er det bedre å ha et sett med metoder som lar anropsprosessen endre poster forskjellige måter. For vårt enkle datatilgangsbibliotek vil vi imidlertid definere en enkelt metode som lar anropsprosessen endre det vennlige navnet på den angitte bilen:
Offentlig void UpdateCarPetName(int id, string newpetName) ( string sql = string.Format("Oppdater Inventory Set PetName = "(0)" Hvor CarID = "(1)"", newpetName, id); bruker (SqlCommand cmd = new SqlCommand(sql, this.connect)) ( cmd.ExecuteNonQuery(); ) )
Legger til samplingslogikk
Nå må vi legge til en metode for å velge poster. Som vist tidligere, lar en spesifikk dataleverandørs dataleserobjekt deg velge poster ved hjelp av en skrivebeskyttet markør. Ved å kalle Read()-metoden kan du behandle hver post om gangen. Alt dette er flott, men nå må vi finne ut hvordan vi returnerer disse postene til det anropende applikasjonslaget.
En tilnærming ville være å hente dataene ved å bruke Read()-metoden og deretter fylle ut og returnere en flerdimensjonal matrise (eller et annet objekt som den generiske Listen)
En annen måte er å returnere et System.Data.DataTable-objekt, som faktisk tilhører det frittstående ADO.NET-laget. DataTable er en klasse som representerer en tabellformet blokk med data (som et papir eller et regneark).
DataTable-klassen inneholder data som en samling av rader og kolonner. Disse samlingene kan fylles ut programmatisk, men DataTable-typen har en Load()-metode som kan fylle dem automatisk ved hjelp av et dataleserobjekt! Her er et eksempel der data fra inventartabellen returneres som en datatabell:
Public DataTable GetAllInventoryAsDataTable() ( DataTable inv = new DataTable(); string sql = "Velg * Fra Inventory"; bruker (SqlCommand cmd = new SqlCommand(sql, this.connect)) ( SqlDataReader dr = cmd.ExecuteReader(); .Load(dr); dr.Close(); ) returner inv; )
Arbeide med parameteriserte kommandoobjekter
Så langt, i innsettings-, oppdaterings- og slettingslogikken for InventoryDAL-typen, har vi brukt hardkodede strengliteraler for hver SQL-spørring. Du er sannsynligvis klar over eksistensen av parameteriserte spørringer, som lar deg behandle SQL-parametere som objekter i stedet for bare et stykke tekst.
Å jobbe med SQL-spørringer på en mer objektorientert måte bidrar ikke bare til å redusere skrivefeil (med sterkt innskrevne egenskaper), men parameteriserte spørringer er vanligvis mye raskere enn strenge bokstavelige spørringer fordi de bare analyseres én gang (i stedet for hver gang). CommandText-egenskapen er satt til en SQL-streng). I tillegg beskytter parameteriserte spørringer mot SQL-injeksjonsangrep (et velkjent sikkerhetsproblem for datatilgang).
For å støtte parameteriserte spørringer opprettholder ADO.NET-kommandoobjekter en samling av individuelle parameterobjekter. Som standard er denne samlingen tom, men du kan legge til et hvilket som helst antall parameterobjekter som samsvarer plassholderparametere i en SQL-spørring. Hvis du trenger å knytte en SQL-spørringsparameter til et medlem av parametersamlingen til et kommandoobjekt, før SQL-parameteren med @-symbolet (i det minste når du arbeider med Microsoft SQL Server, selv om ikke alle DBMS-er støtter denne betegnelsen).
Innstilling av parametere ved hjelp av typen DbParameter
Før vi begynner å lage parameteriserte spørringer, la oss bli kjent med DbParameter-typen (grunnklassen for leverandørparameterobjekter). Denne klassen har en rekke egenskaper som lar deg spesifisere navnet, størrelsen og typen til parameteren, samt andre egenskaper, for eksempel visningsretningen til parameteren. Noen viktige egenskaper for DbParameter-typen er gitt nedenfor:
DbTypeHenter eller setter datatypen fra en parameter, representert som en CLR-type
RetningReturnerer eller angir parametertype: bare input, output-only, input og output, eller parameter for å returnere en verdi
Er nullbarReturnerer eller angir om en parameter kan akseptere tomme verdier
ParameternavnHenter eller angir DbParameter-navnet
StørrelseProblemer eller installasjoner maksimal størrelse data for parameteren (kun nyttig for tekstdata)
VerdiReturnerer eller angir verdien til en parameter
For å demonstrere hvordan man fyller ut en samling kommandoobjekter med DBParameter-kompatible objekter, la oss omskrive InsertAuto()-metoden slik at den vil bruke parameterobjekter (alle andre metoder kan lages om på samme måte, men dette eksemplet vil være nok for oss):
Public void InsertAuto(int id, string color, string make, string petName) ( // SQL statement string sql = string.Format("Insert Into Inventory" + "(CarID, Make, Color, PetName) Values("(0) ","(1)","(2)","(3)")", id, make, color, petName); // Parameterisert kommando ved hjelp av (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 = make; param.SqlDbType = SqlDbType.Char; param.Size = 10; cmd.Parameters.Add(param); param = new SqlParameter(); param.ParameterName = "@Color "; param.Value = color; 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(); ) )
Legg merke til at SQL-spørringen her også inneholder fire plassholdertegn, hver foran et @-symbol. Ved å bruke egenskapen ParameterName på SqlParameter-typen kan du beskrive hver av disse plassholderne og spesifisere forskjellig informasjon (verdi, datatype, størrelse osv.) på en sterkt skrevet måte. Etter at alle parameterobjekter er klargjort, legges de til kommandoobjektsamlingen ved å bruke Add()-kallet.
Ulike egenskaper brukes her for å designe parameterobjekter. Vær imidlertid oppmerksom på at parameterobjekter støtter en rekke overbelastede konstruktører som lar deg angi verdiene til ulike egenskaper (noe som resulterer i en mer kompakt kodebase). Vær også oppmerksom på at Visual Studio 2010 har forskjellige grafiske designere som automatisk vil generere mye av denne kjedelige parametermanipulerende koden for deg.
Å lage en parameterisert spørring resulterer ofte i mer kode, men resultatet er en mer praktisk måte å programmere SQL-setninger på, samt bedre ytelse. Denne teknikken kan brukes for alle SQL-spørringer, selv om parameteriserte spørringer er mest nyttige hvis du trenger å kjøre lagrede prosedyrer.
Regler firkantede parenteser står for [valgfri del] av en konstruksjon. En vertikal strek indikerer et valg mellom alternativer (var1|var2). Ellipsen betyr mulig repetisjon flere ganger - 1 gang, 2 ganger [, ...]
SELECT-setning
Instruerer Microsoft Access-databasemotoren til å returnere informasjon fra databasen som et sett med poster.
Syntaks
PLUKKE UT [ predikat] { * | bord.* | [bord.]felt1
[, [bord.]felt2 [, ...]]}
FRA tabelluttrykk [, ...]
SELECT-setningen inkluderer følgende elementer.
Element | Beskrivelse |
Predikat | Ett av følgende predikater: ALL, DISTINCT, DISTINCTROW eller TOP. Predikater brukes for å begrense antall poster som returneres. Hvis det ikke er gitt noe predikat, er standard ALL. |
Indikerer at alle felt er valgt fra den eller de spesifiserte tabellene |
|
Bord | Navnet på tabellen hvis felt postene er valgt fra |
felt1, felt2 | Navnene på feltene som inneholder dataene som skal hentes. Hvis flere felt er spesifisert, vil dataene bli hentet i den rekkefølgen navnene deres er oppført |
kallenavn 1, kallenavn2 | Navn brukt som kolonneoverskrifter i stedet for originale kolonnenavn tabeller |
tabelluttrykk | Ett eller flere tabellnavn som inneholder dataene som skal hentes. |
ekstern_database | Navnet på databasen som inneholder tabellene spesifisert i komponenten tabelluttrykk hvis de ikke er i gjeldende database |
Notater
For å utføre denne operasjonen søker Microsoft Access-databasemotoren i den eller de spesifiserte tabellene, henter de ønskede kolonnene, velger radene som oppfyller de angitte betingelsene, og sorterer eller grupperer de resulterende radene i den angitte rekkefølgen.
SELECT-setninger endrer ikke databasedata.
SELECT-setningen er vanligvis det første ordet i SQL-setningen (SQL-setning (streng). Uttrykk som definerer SQL kommando, for eksempel SELECT, UPDATE eller DELETE, og inkluderer klausuler som WHERE eller ORDER BY. SQL-setninger/strenger brukes ofte i spørringer og statistiske funksjoner.) De fleste SQL-setninger er enten SELECT-setninger eller SELECT...INTO-setninger.
Minimumssyntaksen for en SELECT-setning er som følger:
PLUKKE UT Enger FRA bord
Du kan bruke en stjerne (*) for å velge alle feltene i en tabell. Følgende eksempel velger alle feltene i tabellen Ansatte.
VELG * FRA ansatte;
Hvis feltnavnet er inkludert i flere tabeller i FROM-leddet, før det med tabellnavnet og setningen «.» (punktum). I følgende eksempel er feltet "Avdeling" til stede i tabellene "Ansatte" og "Ledere". SQL-setningen velger avdelinger fra Ansatte-tabellen og ledernavn fra Supervisors-tabellen.
VELG ansatte. Avdeling, ledere. Ledernavn FRA medarbeidere INNRE BLI MEDLEVERERE HVOR ansatte. Avdeling = Ledere. Avdeling;
Når du oppretter et RecordSet-objekt, brukes tabellfeltnavnet av Microsoft Access-databasemotoren som navnet på "Field"-objektet i objektet Rekordsett. Hvis feltnavnet må endres eller ikke er gitt av uttrykket som genererer feltet, bruk et reservert ord (Reservert ord. Et ord som er et element i et språk, for eksempel Visual Basic. Reserverte ord inkluderer navn på utsagn, innebygde funksjoner og datatyper, metoder, operatører og objekter.) AS. Følgende eksempel viser hvordan "Dag"-overskriften brukes til å navngi det returnerte objektet Felt i det mottatte objektet Rekordsett.
VELG Bursdag AS Dag FRA Ansatte;
Når du arbeider med aggregerte funksjoner eller spørringer som returnerer tvetydige eller identiske objektnavn Felt, bør du bruke AS-leddet for å lage et annet objektnavn Felt. I følgende eksempel, det returnerte objektet Felt i det mottatte objektet Rekordsett får navnet "Census".
VELG ANTALL(EmployeeCode) AS Census FROM Ansatte;
Når du arbeider med en SELECT-setning, kan du bruke tilleggssetninger for ytterligere å begrense og organisere dataene som hentes. For mer informasjon, se hjelpeemnet for tilbudet du bruker.
FRA klausul
Spesifiserer tabeller og spørringer som inneholder feltene som er oppført i SELECT-setningen.
Syntaks
PLUKKE UT Feltliste
FRA tabelluttrykk
En SELECT-setning som inneholder en FROM-klausul inkluderer følgende elementer:
Element | Beskrivelse |
Feltliste | |
tabelluttrykk | Et uttrykk som definerer én eller flere tabeller – datakilder. Uttrykket kan være et tabellnavn, et lagret spørringsnavn eller et resultatuttrykk konstruert med en INNER JOIN-, LEFT JOIN- eller RIGHT JOIN-operator |
ekstern_database | Full vei til en ekstern database som inneholder alle tabellene spesifisert i tabelluttrykk |
Notater
Tilstedeværelsen av en FROM-klausul etter en SELECT-setning er nødvendig.
Rekkefølgen tabellene er oppført i tabelluttrykk spiller ingen rolle.
Bruke koblede tabeller (Koblet tabell. En tabell som er lagret i en fil som ikke er en del av den åpne databasen, men som er tilgjengelig fra Microsoft Access. Brukeren kan legge til, slette og endre poster i den koblede tabellen, men kan ikke endre strukturen. .) i stedet for klausulen IN, kan du gjøre prosessen med å hente data fra en ekstern database enklere og mer effektiv.
Eksempelet nedenfor viser hvordan du henter data fra tabellen Ansatte.
VELG Etternavn, Fornavn
FRA ansatte;
Indikerer postene som er valgt for SQL-spørringer (SQL (Structured Query Language). Et strukturert spørrings- og databaseprogrammeringsspråk som er mye brukt for å få tilgang til, spørre, oppdatere og manipulere data i relasjonelle DBMS-er.)
Syntaks
PLUKKE UT ]]
FRA bord
SELECT-setningen som inneholder disse predikatene inkluderer følgende komponenter:
Komponent | Beskrivelse |
Underforstått hvis ingen predikater er inkludert. Microsoft Access-databasemotoren velger alle poster som samsvarer med betingelsene for en SQL-setning (SQL-setning (streng). Et uttrykk som definerer en SQL-kommando, for eksempel SELECT, UPDATE eller DELETE, og inkluderer klausuler, for eksempel WHERE eller ORDER BY SQL-setninger/strenger brukes vanligvis i spørringer og statistiske funksjoner). De følgende to identiske eksemplene viser hvordan du returnerer alle poster fra tabellen Ansatte. FRA ansatte BESTILL ETTER EmployeeCode; FRA ansatte BESTILL ETTER EmployeeCode; |
|
Ekskluderer poster som inneholder dupliserte data i de valgte feltene. Bare de unike verdiene for hvert av feltene som er oppført i SELECT-setningen er inkludert i søkeresultatene. For eksempel kan noen ansatte som er oppført i tabellen Ansatte ha samme etternavn. Hvis to poster inneholder etternavnet "Ivanov" i Etternavn-feltet, returnerer følgende SQL-setning bare én post som inneholder etternavnet "Ivanov". VELG DISTINCT Etternavn Hvis DISTINCT-komponenten utelates, returnerer spørringen begge postene med etternavnet "Ivanov". Hvis SELECT-leddet inneholder flere felt, er kombinasjonen av alle feltverdier inkludert i søkeresultatene bare hvis den er unik for den posten. Resultatene av en spørring som bruker DISTINCT-komponenten oppdateres ikke for å gjenspeile påfølgende endringer gjort av andre brukere. |
|
Ekskluderer data fra poster som gjentas i sin helhet i stedet for å inneholde individuelle felt med samme data. La oss anta at det er opprettet en spørring som kobler sammen tabellene "Kunder" og "Bestillinger" ved å bruke feltet "Kundekode". Kunder-tabellen inneholder ikke dupliserte kunde-ID-felt, men de finnes i ordretabellen fordi hver kunde kan ha flere bestillinger. Følgende SQL-setning viser hvordan du bruker DISTINCTROW-komponenten til å liste opp organisasjoner som har gjort minst én ordre, uten å nevne detaljene for disse ordrene. VELG DISTINCTROW-tittel FRA kunder INNER JOIN-ordrer ON-klienter. CustomerId = Bestillinger. Klientkode BESTILL ETTER tittel; Hvis DISTINCTROW-komponenten utelates, resulterer spørringen i flere rader for hver organisasjon som har bestilt flere ganger. DISTINCTROW-komponenten trer bare i kraft når du velger felt fra noen av tabellene som brukes i spørringen. DISTINCTROW-komponenten ignoreres hvis spørringen bare inkluderer én tabell eller hvis felt hentes fra alle tabeller. |
|
TOPP n | Returnerer det angitte antallet poster som er blant de første eller siste postene i området spesifisert av ORDER BY-leddet. La oss si at du vil vise navnene på de 25 beste elevene fra klassen i 1994. Fornavn Etternavn WHERE Graduation Year = 2003 BESTILL ETTER GradePointAverage DESC; Hvis du ikke inkluderer ORDER BY-leddet, vil spørringen returnere et tilfeldig sett med 25 poster fra Students-tabellen som tilfredsstiller WHERE-leddet. Predikatet TOP innebærer ikke et valg mellom like verdier. Hvis den 25. og 26. posten i forrige eksempel hadde samme GPA, ville spørringen returnert 26 poster. Du kan også bruke det reserverte ordet PERCENT for å hente en prosentandel av de første eller siste postene i området spesifisert av ORDER BY-leddet. Anta at du i stedet for de 25 beste, vil vise de nederste 10 % av elevene i avgangsklassen. VELG TOPP 10 PROSENT Fornavn Etternavn WHERE Graduation Year = 2003 BESTILL ETTER GradePointAverage ASC; ASC-predikatet spesifiserer utgangen av verdier fra den nedre delen av området. Verdien som følger TOP-predikatet må være en heltallsdatatype. Den grunnleggende datatypen som brukes til å lagre heltallsverdier. En heltallsvariabel lagres som et 64-biters (8-byte) tall i området -32768 til 32767. ) unsigned . TOP-predikatet påvirker ikke om spørringen kan oppdateres. |
bord | Navnet på tabellen som poster hentes fra. |
se også
SELECT-setning
FRA klausul
WHERE-klausul
Bestemmer hvilke poster fra tabellene oppført i FROM-leddet som behandles av SELECT-, UPDATE- eller DELETE-setninger.
Syntaks
PLUKKE UT Feltliste
FRA tabelluttrykk
HVOR utvalgsbetingelser
En SELECT-setning som inneholder en WHERE-klausul inkluderer følgende deler.
Del | Beskrivelse |
Feltliste | Navnet på feltet eller feltene som hentes sammen med eventuelle aliaser (Alias (SQL). Et alternativt navn for en tabell eller et felt i et uttrykk. Aliaser brukes vanligvis som kortere tabell- eller feltnavn for å lette etterfølgende referanse i programmer, for å forhindre tvetydige referanser, og for å få mer beskrivende navn når du viser søkeresultater.), predikater (ALL, DISTINCT, DISTINCTROW eller TOP), eller med en hvilken som helst annen parameter i SELECT-setningen. |
tabelluttrykk | Navnet på tabellen eller tabellene som data hentes fra. |
utvalgsbetingelser | Uttrykk (Uttrykk. En kombinasjon av matematiske og logiske operatorer, konstanter, funksjoner, feltnavn, kontroller og egenskaper som resulterer i én enkelt verdi. Uttrykket kan utføre beregninger, behandle tekst eller validere data.) som må samsvare med postene inkludert i søkeresultater. |
Notater
Microsoft Access-databasemotoren velger poster som oppfyller betingelsene som er oppført i WHERE-leddet. Hvis WHERE-leddet ikke er spesifisert, returnerer spørringen alle rader i tabellen. Hvis en spørring spesifiserer flere tabeller, men ikke spesifiserer en WHERE- eller JOIN-klausul, produserer spørringen et kartesisk produkt (kartesisk produkt. Er resultatet av å utføre en SQL SELECT-setning som har en FROM-klausul som refererer til to eller flere tabeller og ingen WHERE eller JOIN-klausul som spesifiserer metode for sammenføyning.) tabeller.
WHERE-klausulen er ikke nødvendig, men hvis den brukes, må den følge FROM-klausulen. Du kan for eksempel velge alle ansatte fra salgsavdelingen (WHERE Department = "Salg") eller alle kunder mellom 18 og 30 år (WHERE Age Between 18 And 30).
Hvis en JOIN-klausul ikke brukes for en SQL join-operasjon på flere tabeller, vil det resulterende objektet Rekord satt det vil være umulig å oppdatere.
WHERE-leddet ligner på HAVING-leddet og spesifiserer de valgte postene. Etter at postene er gruppert etter GROUP BY-leddet, bestemmer HAVING-leddet også posten som skal vises.
WHERE-leddet brukes til å ekskludere poster som ikke trenger å grupperes ved å bruke GROUP BY-leddet.
Bruk ulike uttrykk for å bestemme hvilke poster som returneres av SQL-setningen. For eksempel velger følgende SQL-setning alle ansatte hvis lønn overstiger RUR.
VELG Etternavn, Lønn FRA Ansatte HVOR Lønn > 21000;
WHERE-leddet kan inneholde opptil 40 uttrykk koblet sammen med logiske operatorer (f.eks. OG Og ELLER).
Hvis du skriver inn et feltnavn som inneholder mellomrom eller tegnsetting, må du sette det i hakeparenteser (). En kundeinformasjonstabell kan for eksempel inneholde informasjon om spesifikke kunder.
VELG [Kundens favorittrestaurant]
Spesifisere et argument utvalgsbetingelser, bokstaver på dato (dato bokstavelig. Enhver sekvens av tegn i et gyldig format, omsluttet av talltegn (#). Gyldige formater er datoformatet spesifisert i innstillingene for språk og standarder og det universelle datoformatet.) må representeres i amerikansk format. , selv om ikke-amerikansk datoformat brukes. versjon av Microsoft Access-databasemotoren. For eksempel er datoen "10. mai 1996" skrevet som 10/5/96 i Storbritannia og som 05/10/1996 i Russland. Husk å legge ved bokstaver for dato i talltegn (#), som vist i eksemplene nedenfor.
For å finne poster for 10. mai 1996 i den britiske databasen, bruk følgende SQL-setning:
VELG * FRA bestillinger HVOR Forsendelsesdato = #10.05.1996#;
Du kan også bruke funksjonen Datoverdi, gjenkjenne internasjonale parametere, installert av Microsoft Windows®. Bruk for eksempel denne koden for Russland:
VELG * FRA bestillinger WHERE Forsendelsesdato = DateValue("05/10/1996");
Og følgende kode er for Storbritannia:
VELG * FRA bestillinger WHERE Forsendelsesdato = DateValue("10/5/96");
Merk. Hvis kolonnen som er spesifisert i raden for utvalgskriterier er av typen GUID (Replica ID (GUID). Et 16-byte felt i en Microsoft Access-database som brukes til å identifisere replikering unikt. GUID-er brukes til å identifisere replikaer, replikasett, tabeller, poster og andre objekter. I Microsoft Access-databaser kalles GUID-koder replikakoder.), bruker valgbetingelsene en litt annen syntaks.
WHERE ReplicaID = (GUID (AB-CDEF0ABCDEF))
Sørg for at nestede parenteser og bindestreker er riktig plassert.
Kildeside: http://office. /ru-ru/access/HA.aspx? pid=CH
GROUP BY klausul
Kombinerer poster med de samme verdiene som er i den angitte listen over felt til én post. En oppsummeringsverdi opprettes for hver post hvis en SQL-aggregeringsfunksjon er inkludert i SELECT-setningen, for eksempel Sum eller Telle.
Syntaks
PLUKKE UT Feltliste
FRA bord
HVOR utvalg_tilstand
En SELECT-setning som inneholder en GROUP BY-klausul inkluderer følgende elementer:
Element | Beskrivelse |
Feltliste | Navnene på feltene som hentes sammen med eventuelle aliaser (Alias (SQL). Et alternativt navn for en tabell eller et felt i et uttrykk. Aliaser brukes vanligvis som kortere tabell- eller feltnavn for å lette etterfølgende referanse i programmer, for å forhindre tvetydige referanser, og for å få mer informative navn når du viser søkeresultater.) og statistiske SQL-funksjoner, predikater (ALL, DISTINCT, DISTINCTROW eller TOP), eller andre parametere i SELECT-setningen |
bord | |
utvalgsbetingelser | Utvalgsbetingelse. Hvis setningen inneholder en WHERE-klausul, etter at den er brukt på postene, vil verdiene bli gruppert av Microsoft Access-databasemotoren. |
gruppe_feltliste | gruppe_feltliste |
Notater
GROUP BY-klausulen er valgfri.
Hvis SQL-statistiske funksjoner ikke er inkludert i SELECT-setningen, beregnes ikke sammendragsverdier.
GROUP BY-feltverdier som er Null (Null. En verdi som kan legges inn i et felt eller brukes i uttrykk og spørringer for å indikere manglende eller ukjente data. I Visual Basic spesifiserer nøkkelordet Null en Null-verdi. Noen felt, f.eks. som primærnøkkelfelt, kan ikke inneholde null-verdier.), er gruppert og utelates ikke. Men verdiene Null blir ikke evaluert av noen av SQL-statistiske funksjoner.
WHERE-leddet brukes til å ekskludere rader som ikke trenger å grupperes. HAVING-leddet brukes til å filtrere poster etter gruppering.
Felt fra GROUP BY-feltlisten som ikke inneholder Memo-datatype (Memo-feltdatatype. En feltdatatype i en Microsoft Access-database. Et MEMO-felt kan inneholde opptil 65535 tegn.) eller OLE-objekt (feltdatatype). OLE-objekt" En feltdatatype som brukes til å lagre objekter fra andre applikasjoner koblet til eller innebygd i en Microsoft Access-database.) kan referere til et hvilket som helst felt i en hvilken som helst tabell spesifisert i FROM-leddet, selv om feltet ikke er inkludert i SELECT-setningen. For å gjøre dette er det nok å ha minst én SQL-statistisk funksjon i SELECT-setningen. Microsoft Access-databasemotoren tillater ikke gruppering etter felt som inneholder MEMO-felt- eller OLE-objektdata.
Alle feltene i SELECT-feltlisten må enten være inneholdt i en GROUP BY-klausul eller være argumenter til en SQL-aggregeringsfunksjon.
se også
SELECT-setning
SELECT...INTO-setning
Predikater ALL, DISTINCT, DISTINCTROW, TOP
FRA klausul
HAR tilbud
ORDER BY klausul
WHERE-klausul
SQL statistiske funksjoner
Kildeside: http://office. /ru-ru/access/HA.aspx? pid=CH
HAR tilbud
Definerer grupperte poster som skal vises i en SELECT-setning med en GROUP BY-klausul. Etter at postene har blitt gruppert etter GROUP BY-klausulen, vil HAVING-klausulen vise de som oppfyller betingelsene.
Syntaks
PLUKKE UT Feltliste
FRA bord
HVOR utvalgsbetingelser
GRUPPE AV gruppe_feltliste
En SELECT-setning som inneholder en HAVING-klausul inkluderer følgende elementer:
Element | Beskrivelse |
Feltliste | Navnene på feltene som lastes inn sammen med eventuelle aliaser (Alias (SQL). Et alternativt navn for en tabell eller et felt i et uttrykk. Aliaser brukes vanligvis som kortere tabell- eller feltnavn for å lette etterfølgende referanse i programmer, for å forhindre tvetydige referanser, og for å få mer informative navn når du viser søkeresultater.) og SQL-statistiske funksjoner, predikater (ALL, DISTINCT, DISTINCTROW eller TOP) eller med andre parametere i SELECT-setningen. |
bord | Navn på tabellen som poster lastes fra |
utvalg_tilstand | Utvalgsbetingelse. Hvis setningen inneholder en WHERE-klausul, vil Microsoft Access-databasemotoren gruppere verdiene etter at den er brukt på postene. |
gruppe_feltliste | Navn på felt (opptil 10) som brukes til å gruppere poster. Rekkefølgen av navn i gruppe_feltliste bestemmer nivået av gruppering - fra høyeste til laveste |
gruppe_tilstand | Et uttrykk som spesifiserer postene som skal vises |
Notater
HAVING-klausulen er valgfri.
HAVING-leddet ligner på WHERE-leddet som bestemmer utvalget av poster. Etter å ha gruppert poster med GROUP BY-leddet, bestemmer HAVING-leddet postene som skal vises.
VELG Typekode,
Sum (på lager)
FRA produkter
GRUPPER ETTER Typekode
Å HAR Sum(InStock) > 100 og liker "TEL*";
HAVING-leddet kan inneholde opptil 40 uttrykk koblet sammen med logiske operatorer som f.eks Og Og Eller.
Kildeside: http://office. /ru-ru/access/HA.aspx? pid=CH
ORDER BY klausul
Sorterer postene som returneres av spørringen i stigende eller synkende rekkefølge av verdiene til de spesifiserte feltene.
Syntaks
PLUKKE UT Feltliste
FRA bord
HVOR utvalg_tilstand
[, felt2 ][, ...]]]
En SELECT-setning som inneholder en ORDER BY-klausul inkluderer følgende elementer.
Element | Beskrivelse |
Feltliste | Navnene på feltene som hentes sammen med eventuelle aliaser (Alias (SQL). Et alternativt navn for en tabell eller et felt i et uttrykk. Aliaser brukes vanligvis som kortere tabell- eller feltnavn for å lette etterfølgende referanse i programmer, for å forhindre tvetydige referanser, og for å få mer informative navn når du viser søkeresultater.) og SQL-statistiske funksjoner, predikater (ALL, DISTINCT, DISTINCTROW eller TOP) eller med andre parametere i SELECT-setningen. |
bord | Navn på tabellen som poster hentes fra |
utvalgsbetingelser | Utvalgsbetingelser. Hvis setningen inneholder en WHERE-klausul, vil Microsoft Access-databasemotoren bestille verdiene til postene etter at den er brukt på postene |
felt1, felt2 | Navn på feltene som postene er sortert etter. |
Notater
ORDER BY-klausulen er valgfri. Den bør brukes når du skal vise data i sortert form.
Standard sorteringsrekkefølge er (Sorteringsrekkefølge. En måte å ordne data basert på verdier og type. Data kan sorteres alfabetisk, etter numeriske verdier eller etter dato. Sorteringsrekkefølgen kan være stigende (0 til 100, A til Z) eller synkende (fra 100 til 0, fra Z til A).) stigende (fra A til Å, fra 0 til 9). Eksemplene nedenfor viser sortering av ansattes navn etter etternavn.
VELG Etternavn, Fornavn
FRA ansatte
BESTILL ETTER Etternavn;
VELG Etternavn, Fornavn
FRA ansatte
BESTILL ETTER Etternavn ASC;
For å sortere felt i synkende rekkefølge (Z til A, 9 til 0), legg til det reserverte ordet DESC til navnet på hvert felt. Følgende eksempel viser sortering i synkende rekkefølge basert på ansattes lønn.
VELG Etternavn, Lønn
FRA ansatte
BESTILL ETTER lønn DESC, Etternavn;
Hvis du angir felt i ORDER BY-leddet som inneholder data av typen MEMO Field (Memo Field-datatype. En feltdatatype i en Microsoft Access-database. Et MEMO-felt kan inneholde opptil 65 535 tegn.) eller OLE Object Field (OLE Object Field) Feltdatatype "En feltdatatype som brukes til å lagre objekter fra andre applikasjoner koblet til eller innebygd i en Microsoft Access-database.), vil dette generere en feil. Microsoft Access-databasemotoren kan ikke sortere disse felttypene.
ORDER BY-leddet er vanligvis det siste leddet i en SQL-setning (SQL-setning (streng). Et uttrykk som definerer en SQL-kommando, for eksempel SELECT, UPDATE eller DELETE, og inkluderer ledd, for eksempel WHERE eller ORDER BY. SQL-setninger /strenger brukes ofte i spørringer og statistiske funksjoner.).
Du kan inkludere flere felt i ORDER BY-klausulen. Postene sorteres først etter feltet som er spesifisert først i ORDER BY-klausulen. Poster med samme verdier i det første feltet blir deretter sortert etter feltet spesifisert av det andre, og så videre.
se også
SELECT-setning
SELECT...INTO-setning
Predikater ALL, DISTINCT, DISTINCTROW, TOP
FRA klausul
GROUP BY klausul
HAR tilbud
WHERE-klausul
SQL statistiske funksjoner
Kildeside: http://office. /ru-ru/access/HA.aspx? pid=CH
INNER JOIN operasjon
Kobler poster fra to tabeller hvis de koblende feltene til disse tabellene inneholder de samme verdiene.
Syntaks
FRA Tabell 1 INDRE BLI MED tabell 2 PÅ Tabell 1.felt1 sammenligningsoperatørtabell2.felt2
INNER JOIN-operasjonen består av følgende elementer:
Element | Beskrivelse |
Tabell 1, tabell 2 | Navn på tabellene som inneholder postene som skal slås sammen |
felt1, felt2 | Navn på feltene som skal kobles sammen. Ikke-numeriske felt må være av samme datatype (Data Type. En feltkarakteristikk som definerer typen data som feltet kan inneholde. Datatyper inkluderer: boolsk, heltall, lang, valuta, enkel, dobbel, dato, streng, og Variant (standard). og inneholder data av samme type. Navnene på disse feltene kan imidlertid være forskjellige |
comparison_operator | Enhver sammenligningsoperator: (=,<, >, <=, >= eller<>) |
