Nestede spørringer i konstruktøren. Spørringskonstruktører 1c spørrekonstruktørbetingelser
Så la oss starte med noe enkelt: lag en ny prosessering i konfiguratoren, navngi den Query Console eller Query Builder, som du vil.
Vi kan umiddelbart legge til en tabell i "Data" for fremtidige parametere som vi trenger, slik at vi i konsollen vår ikke kjører den mest primitive forespørselen, men med parametere og lenker, for eksempel for vårt arbeid, vil vi opprette en forespørsel til periodiske registre , men her uten parameterinstruksjoner=&Dato ingensteds.
For å lage vår parametertabell, på "Data"-fanen i dens "Tabulære del" vil vi legge til en ny tabell, la oss kalle den spørringsparametre, her vil vi legge til kolonnene i denne tabellen: 1) Parameternavn, skriv streng = 25 tegn ; ParameterValue, her er en sammensatt datatype, se fig.
Derfor, som vist på bildet, velger vi en sammensatt type for Parameterverdi-kolonnen: i typemenyen som åpnes, merk av for "Sammensatt type", velg nummer, streng (spesifiser 20 tegn), dato, boolsk og sjekk den nederste avmerkingsboksen – AnyLink – det betyr det som følger, når vi spesifiserer parametrene for forespørselen vår, kan vi referere til ethvert objekt i konfigurasjonen vår, for eksempel kataloger eller dokumenter.
Nå må vi lage formen til vår fremtidige spørrekonsoll. I behandlingen, la oss gå til "Skjemaer"-fanen og legge til en ny. Vi går inn i dette skjemaet, og det er allerede et ubegrenset felt for kreativitet - du kan ordne de to detaljene du nettopp opprettet og en tallerken med parametere som du vil! For å gjøre dette kan du bruke standard skjemaelementer som en gruppe eller en side med sider (hvis du foretrekker å vende sider.
Det viktigste her er én ting: etter å ha trukket "TextValues"-attributtet inn i venstre felt for å redigere skjemaet, sørg for å sette "View"=Text Document Field i egenskapene. Se fig.
I egenskapene til «Query Table»-attributtet kan du eventuelt spesifisere «Display Grid» og «Display Headers».
Deretter, i det høyre vinduet for å redigere skjemaet, gå til "Kommandoer" -fanen og legg til en ny knapp, når du klikker, vil konsollen vår utføre en bestemt handling. La oss lage en "Query Designer"-knapp, hvis du ønsker det, kan du legge til et ikon på knappen, det viktigste er å plassere selve knappen i venstre skjemaredigeringsvindu - slik at vi kan se den. Deretter i høyre form redigeringsvindu, høyreklikk på knappen vår og velg egenskaper - i egenskapene, klikk på "Handling" -elementet, et modalt vindu vil dukke opp som spør hvor nøyaktig vår programkode vil bli utført, som vi vil tilordne til knappen - velg " På klienten”.
Skjemamodulen åpnes med en ferdig tom prosedyre "Procedure Query Constructor (Command)". Inne i denne prosedyren vil vi beskrive kallet til standard 1c8 Query Builder. Det er veldig lett: Konstruktør = Ny Konstruktør for forespørsel; Men det er fallgruver her - Query Constructor innebygd i plattformen fungerer i brukermodus BARE under en tykk klient! Derfor vil vi sette inn tilstanden til forbehandlerinstruksjonen #If, men her bestemmer du selv, basert på plattformen din, eller du har vanlige skjemaer, velg deretter " FatClientRegularApp" eller du har en plattform basert på administrerte skjemaer, så " ThickClientManagedApplication“.se fig.
Nå gjenstår det å legge til denne prosedyren en betingelse for registrering av forespørselsteksten, som spørringsbyggeren vil generere for oss i vår "Request Text"-skjemadetaljer:
If Constructor.OpenModal()=True Then Object.RequestText=Constructor.Text; slutt om;
Men vi kan manuelt endre noe i forespørselsteksten (i brukermodus - i "Request Text" attributtvinduet) slik at endringene våre kommer inn i Query Constructor når den kalles opp igjen - vi legger til en enkel betingelse her:
Hvis ikke EmptyString(Object.QueryText) Da Constructor.Text = Object.QueryText; slutt om;
Det er det, vi har koblet til Query Constructor innebygd i 1c8-plattformen, la oss se på arbeidet vårt. For å gjøre dette, start 1C:Enterprise i tykk klientmodus ved å bruke en av følgende metoder: 1) hovedmenyen til konfiguratoren – Debugging – Start feilsøking – Thick Client; 2) eller hvis du har disse tastene på kontrollpanelet i konfiguratoren - trykk bare på knappen med en gul sirkel med en tykk prikk, se figur:
Brukermodusen til 1cEnterprise8 starter, vi finner behandlingen vår, starter den, klikker på "Query Designer"-knappen og ser hvordan designeren som er innebygd i plattformen åpnes. se fig.
Så vi har Query Constructor i gang, vi kan begynne å sette sammen vår fremtidige spørring i den, men vi er interessert i å se hvordan spørringen vi opprettet vil fungere! Og for å gjøre dette, må vi lage en annen knapp i konfiguratoren når vi redigerer formen til konsollen vår, la oss kalle det "Run Query". I egenskapene til "Kjør spørring" -knappen, klikk på "Handling", en meny vises igjen der vi blir spurt hvor programkoden vår skal behandles, i dette tilfellet velger vi "Både på klienten og på serveren", igjen befinner vi oss i Skjemamodulen.
I Execute Query()-prosedyren, som vi har på klienten, vil vi skrive en betingelse dersom brukeren ikke har skrevet inn spørringsteksten, men ber om å utføre den:
If EmptyString(Object.QueryText) Then report("Skriv inn spørringsteksten!"); slutt om;
Systemet har allerede automatisk generert en kobling til Execute RequestOnServer()-prosedyren; – det er bra, la oss gå til denne prosedyren, som utføres på serveren, og skrive her koden for å utføre vår innlagte forespørsel.
Det er muligheter her: Du kan skrive alle uttrykkene knyttet til byggespørringer selv, dvs. manuelt, men det er et enda enklere alternativ - inne i prosedyren, høyreklikk og i rullegardinmenyen velg "Spørrebygger med behandling av resultater, se figur":
Hvis du klikket på elementet "Spørringsbygger med resultatbehandling", vil et modalt vindu "Forespørselstekst ikke funnet. Lag en ny?" vises, klikk ja. Den innebygde spørringsdesigneren åpnes, hvor på den første fanen "Resultatbehandling" - velg det første elementet "Omgå resultatet." Det er det, vi trenger ikke noe annet fra denne konstruktøren, klikk på "Ok" -knappen - et modalt vindu vises "Ingen felt er valgt i forespørselen, klikk på "Ok".
Etter dette vil følgende ferdiglagde mal vises i vår ExecuteRequestOnServer()-prosedyre:
La oss gå videre til uttrykket konstruert av konstruktøren:
Request.Text = "";
Request.Text = Object.RequestText;
Så enkelt er det, vår "Utfør forespørsel"-knappen på behandlingsskjemaet er allerede praktisk talt operativ, så langt kan den bare behandle enkle forespørsler uten parametere, men det viktigste er at det fungerer! Alt som gjenstår er å visuelt vise resultatene av forespørselen vår i "Verditabell"-attributtet på behandlingsskjemaet. La meg minne deg på at attributtet vårt "Verditabell" er av typen "Tabelldokument", fordi ellers vil vi ikke se resultatene våre i brukermodus. Visning av tabelldata til brukeren gjøres alltid enten av et tabelldokument eller et layout. Jeg skulle virkelig ønske at det var mulig å vise data gjennom en verditabell - siden det er veldig enkelt å bruke og kjent, men , dessverre er en verditabell bare et verktøy som en utvikler trenger, du kan ikke vise data på skjermen ved å bruke den...
La oss se nærmere på hva et regnearkdokument er - det er som et Excel-ark - du kan bare komme til en post i en spesifikk celle ved å bruke tabellceller, her kaller vi dem et område, men vi kan selv velge rekkevidden til dette området inn i en bestemt celle:
Så vi fant ut hva et regnearkdokument er og bestemte oss for at vi må definere dataene fra spørringen vår i en bestemt celle i dette regnearkdokumentet. Men la oss tenke: hva er "Query Result" som designeren så raskt genererte for oss? Åpne hjelpen - Resultatet av spørringen er en tabell som har de riktige egenskapene! se fig.
Og hvis vi nå skriver etter uttrykket Query Result = Query.Execute(); (laget av konstruktøren), her er en så enkel syklus for samlinger:
For hvert kolonnenavn fra spørringsresultat. kolonner Loop-rapport(kolonnenavn.navn); EndCycle;
Etter denne syklusen, noter foreløpig alle uttrykkene som er bygget automatisk av konstruktøren. Og kjør 1C:Enterprise8 under den tykke klienten. Lag en enkel spørring (Du kan bruke Query Builder - den fungerer allerede for oss) og klikk på "Run Query"-knappen:
Du vil se nederst i meldingsvinduet at spørringsresultattabellen lagrer navnene på feltene vi nettopp valgte ved å lage en enkel spørring.
La oss nå vise disse navnene på lidelsens felt i et regnearkdokument:
For hvert kolonnenavn fra spørreresultat.kolonner Loop Cell=Object.QueryTable.Area(1,QueryResult.Columns.Index(ColumnName)+1); Cell.Text=Kolonnenavn.Navn; EndCycle;
For å vise detaljene i spørringsdataene, la oss analysere uttrykkene opprettet automatisk av designeren og sette inn i "SelectionDetailedRecords" sorteringsløkken til selve spørringen nøyaktig den samme løkken som vi brukte til å vise kolonnenavnene, bare nå må vi overføre ikke dataene fra "Query Result"-tabellen inn i celleteksten. og dataene til selve utvalget, la oss se i hjelpen hvordan du får tilgang til feltet for detaljert utvalg i forespørselen:
SelectionDetailRecords = QueryResult.Select(); Mens SelectionDetailedRecords.Next() Loop //i den første linjen har vi allerede navnene på tabellkolonnene skrevet ned, så vi laster inn dataene under den første lineDocRowNumber=Object.QueryTable.TableHeight+1; For hvert kolonnenavn fra spørring Result.Columns Cycle Cell=Object.QueryTable.Area(DocRowNumber,QueryResult.Columns.Index(ColumnName)+1); Cell.Text = SelectionDetailedRecords[ColumnName.Name]; EndCycle; EndCycle;
Det er alt, vi kan sjekke, laste bedriften under en tykk klient, angi en enkel forespørsel uten parametere, klikk på "Kjør spørring" -knappen, se figur:
Hurra, alt fungerer!!!
Det er veldig praktisk når, når du åpner/lukker spørrekonsollen vår, spørringsteksten vår, som vi jobbet med før vi lukket konsollen, igjen skrives i «Spørringstekst»-feltet. For å gjøre dette trenger du bare å aktivere form-egenskapen = Autolagre, se fig:
Det er det, konsollen vår fungerer. For at vi kan skrive mer komplekse spørringer med parametere spesifisert i dem, må vi opprette en annen "Finn parametere" -knapp, samt koden for "Kjør spørring" -knappen - koden for "Finn parametere" -knappen vil bli utført på klienten og på serveren. Deretter, i serverprosedyren, starter vi forespørselen på samme måte med teksten som sendes inn i den fra "Request Text"-vinduet, ved å bruke uttrykket "Request.FindParameters()" finner vi de beståtte parameterne og skriver dem inn i en sløyfe inn i den tabellformede delen av "Request Parameters"-skjemaet. Ikke glem å deretter overføre dem fra den ferdige tabellen med parametere til "Run Query"-prosedyren.
Du kan også legge til et par knapper til konsollen vår som vil tømme Parameter-vinduet og Request Text-vinduet i brukermodus.
Vår Query Console er klar til bruk, jeg ønsker deg vellykkede kreative løsninger ved å bruke et så enkelt og kraftig verktøy som Query Console!
Denne behandlingen er skrevet på 1c8.3-plattformen (administrerte skjemaer) og kjører under en tykk klient. Det kan også skrives på 1c8.2-plattformen, både under vanlige skjemaer og under administrerte.
Nedlastingen inneholder et eksempel på Query Console vi nettopp opprettet.
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Query Console-oppgradering:
1) Nå vil vår hjemmelagde spørrekonsoll med en innebygd spørringsbygger kjøre under enhver klient: under en tykk klient med vanlige og administrerte skjemaer og under en tynn og nettklient.
p.s. Formen og utseendet til den innebygde Query Builder er forskjellig - avhengig av hvilken klient vi lanserte konsollen under. (Jeg personlig er mer kjent og praktisk med formen til Query Builder under en tykk klient)
&På klientprosedyren Query Constructor (kommando) //kalling av standard Query Constructor er bare mulig under en tykk klient #If ThickClientManagedApplication eller ThickClientNormalApplication Then Constructor=New Query Constructor; Hvis ikke EmptyString(Object.QueryText) Da Constructor.Text = Object.QueryText; slutt om; If Constructor.OpenModal()=True Then Object.RequestText=Constructor.Text; slutt om; // #Else // Report("Å ringe spørringsbyggeren er bare mulig under en tykk klient"); // Komme tilbake; //# EndIf #Else Report("Du kjører Query Builder under en tynn klient - den avviker litt i form og ytelseshastighet!"); Konstruktør = Ny QueryConstructor(); Hvis ikke EmptyString(Object.QueryText) Da Constructor.Text = Object.QueryText; slutt om; Constructor Alert = New AlertDescription("RunAfterClosingConstructor", ThisForm); Constructor.Show(Constructor Alert); # EndIf End of Procedure &På klienten Prosedyre ExecuteAfterClosingConstructor(Result, ConstructorParameters) Eksporter //Result=text, hvis Constructor ble lukket med ok-knappen Object.RequestText = AbbreviatedLP(Result); //virker!!! Slutt på prosedyre
2) Lagt til muligheten til vår enkle spørringskonsoll for å legge inn komplekse spørringer med en midlertidig tabell sendt til parameterne!!! Mekanismen viste seg å være veldig enkel og elegant – uten å bruke XML-kode, slik man gjør i profesjonelle konsoller.
Du kan se selve koden og prosedyrene for overføringsmekanismen til parametrene til midlertidige tabeller i den andre vedlagte filen. Hvordan jeg begynte å utvikle min egen versjon av midlertidige tabeller i parameterne finner du på denne lenken https://forum.infostart.ru/forum9/topic183700/
Nå hvordan bruker du konsollen for en kompleks spørring når en midlertidig tabell sendes til parameterne. For eksempel kan du ta koden til denne forespørselen;
VELG ExternalData.Product, ExternalData.Quantity PLASS ExternalData FRA &ExternalData AS ExternalData; ////////////////////////////////////////////// ////////////////////////// SELECT ExternalData.Product, ExternalData.Quantity, ISNULL(RemainingProductRemaining.QuantityRemaining, 0) AS Field1, ISNULL(Remaining ProductsRemainings.QuantityRemaining, 0) - ExternalData.Quantity AS Remaining FROM ExternalData AS ExternalData LEFT JOIN Registrer Akkumuleringer.Resterende produkter.Rester(&Dato, Produkt IN (VELG EksternData.Produkt FROM EksternData) ASRevDatai Programvare) ASRemaiProduct. Gjenværende produkt Produkt
Basert på eksemplet og likheten til spørringskoden ovenfor, kan du lage din egen komplekse spørring, med tanke på dataobjektene dine.
Så, i spørringsdesigneren opprettet vi spørringen ovenfor, og lukker konstruktøren - spørringsteksten vil gå inn i konsollfeltet "Spørringstekst", klikk på "Finn parametere" -knappen, vi ser at i parametertabellen har en linje dukket opp = "Eksterne data", Verditype = "Verditabell", se fig.
I denne tabellen med parametere - skriv inn datoparameteren, for eksempel dagens dato, klikk deretter for å prøve å redigere vår midlertidige tabellparameter "Eksterne data", klikk i feltet med "Verditabell" på tre prikker - et utvalg typer vil vises, klikker du Rad, mekanismen vår snur oss til siden på skjemaet, der vi manuelt må legge inn denne svært midlertidige tabellen.
Merk her at i dette tilfellet, på «Tidtabeller»-siden nederst i «Midlertidig tabellnavn i parametere»-feltet, vil navnet på vår midlertidige tabell vises (den er kopiert fra Parametertabellen).
Så langt ser vi bare én tom tabell på "Time Tables"-siden - dette er tabellen over typer av vår fremtidige midlertidige tabell. Ved å bruke "Legg til"-knappen vil vi legge til navnet på detaljene og typen for den fremtidige tabellen. . Vær forsiktig – navnet og typen må samsvare med det vi spesifiserte i forespørselen om &Eksterne Data:
Nå trykker vi på "Oppdater midlertidig tabell"-knappen - og vi vil ha en andre tabell her - vi vil direkte fylle den med midlertidige tabelldata gjennom "Legg til"-knappen.
Det er det, vi kan dobbeltsjekke oss selv en gang til om vi har lagt inn de primitive dataene til spørringsparametrene i parametertabellen på første behandlingsside, og klikk på "Kjør spørring" -knappen - alt beregnes og velges deretter med begrensning av dataene som sendes i parameteren til vår midlertidige tabell
p.s. Hvis du gjorde en feil når du skrev inn navnet på detaljene og typene deres (i den første tabellen) - bare lukk konsollen og åpne den igjen - den midlertidige datatabellen vil bli slettet - og Typetabellen kan igjen redigeres og en ny datatabell kan opprettes på nytt.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Det er alt, vi kan lage et veldig kraftig arbeidsverktøy med egne hender, i tillegg er konsollen vår fortsatt veldig rask sammenlignet med profesjonelle - og dette er et veldig stort pluss for utviklere! Og, selvfølgelig, nå fungerer konsollen vår under enhver klient! Lykke til i din kreative utvikling!!!
La oss se på hvordan vi kan slå sammen disse to tabellene etter felt Produktkode ved hjelp av
spørringskonstruktør (kode for å lage midlertidige tabeller er gitt som et eksempel
Jeg vil ikke. Du kan ta det fra lenken ovenfor).
Åpne designervinduet, gå til fanen "Tabeller og felt", til seksjon
"tabeller" velg begge våre tabeller, og i seksjonen "Enger" -
de feltene fra begge tabellene som vi ønsker å se som et resultat av spørringen.
Gå til bokmerket "Tilkoblinger". Legg til en ny linje. I felt Tabell 1
fra nedtrekkslisten velg tabellen med produkter, og i feltet Tabell 2 Bord
med land.
Til Tabeller 1 merk av i boksen Alle. Til
Tabeller2 Vi merker ikke av i denne boksen. Dette betyr at fra Tabeller 1
alle poster vil bli valgt, og fra Tabeller2 bare de det utføres for
forbindelsestilstand, det vil si med en slik kombinasjon av flagg får vi
VENSTRE FORBINDELSE. Deretter må du fylle ut Kommunikasjonstilstand.
Her velger vi tabellfeltene fra nedtrekkslistene og sammenligningstegnet også fra nedtrekkslisten
liste. 
Som et resultat av denne forbindelsen får vi følgende forespørselstekst:
VELG VT_Product.Product Code, VT_Product.Name, VT_Country.Country FROM VT_Product AS VT_Product VENSTRE JOIN VT_Country AS VT_Country BY VT_Product.Product Code = VT_Country.Product Code
La oss nå se nærmere på noen punkter.
La oss prøve å bytte avmerkingsboksen Alle.
Det ser ut til at det til slutt skulle ordne seg HØYRE BLI MED, men hvis vi
La oss se på spørringsteksten generert av konstruktøren, vi vil se at tabellene
byttet plass, men forbindelsen forble fortsatt igjen:
VELG VT_Product.Product Code, VT_Product.Name, VT_Country.Country FROM VT_Country AS VT_Country VENSTRE JOIN VT_Product AS VT_Product BY VT_Product.Product Code = VT_Country.Product Code
La oss se hva som skjer hvis vi fjerner merket for begge boksene 
Som et resultat får vi en intern forbindelse.
VELG VT_Product.Product Code, VT_Product.Name, VT_Country.Country FROM VT_Product AS VT_Product INTERNAL JOIN VT_Country AS VT_Country BY VT_Product.Product Code = VT_Country.Product Code
Til slutt, hvis begge avmerkingsboksene er merket av 
vi får full forbindelse
VELG VT_Product.Product Code, VT_Product.Name, VT_Country.Country FROM VT_Product AS VT_Product FULL TILKOBLING VT_Country AS VT_Country BY VT_Product.Product Code = VT_Country.Product Code
Du kan angi flere linjer på et bokmerke Tilkoblinger. I dette tilfellet flere
rader er forbundet med tilstand OG. Dessuten er linjer ikke nødvendig
kjøre inn igjen hver gang. De kan kopieres med nøkkelen F9.
Og i den nye linjen, endre bare tilkoblingstilstanden. Dette fremskynder utviklingen betydelig.
I koblingstilstanden er det heller ikke nødvendig å bruke kun de forhåndsdefinerte feltene fra
nedtrekkslister. Du kan bruke et vilkårlig uttrykk som tilfredsstiller
1C spørrespråk. For å gjøre dette, må du merke av i boksen gratis
og skriv inn betingelsen direkte i feltet, eller åpne et hjelpevindu i
hvor du kan bruke maler med spørringsspråkfunksjoner. 
Selvfølgelig er det i praksis mye mer komplekse spørsmål hvor
flere bord med ulike forbindelser mellom hverandre. Men i spørringsbyggeren
forbindelser av enhver kompleksitet kan reproduseres.
Spørringsdesigneren består av følgende faner:
1. "Tabeller og felt" - det er tre hierarkiske lister på fanen:
en. "Database" - viser alle tilgjengelige objekter som en spørring kan gjøres til. Også knapp "Vis byttebord", som du kan få tilgang til tabeller over endringer i informasjonssikkerhetsobjekter med hvis de er registrert for en utvekslingsplan.
b. "Tabeller" - en liste over utvalgte tabeller som spørringen vil bli utført til. Også i dette vinduet kan du slette en tabell, gi nytt navn til eller erstatte en tabell, og legge til en intern spørring.
Du kan tilordne parametere for virtuelle tabeller ved å klikke på "Virtuelle tabellparametere"-knappen:
Det anbefales å aktivt bruke parametrene til virtuelle tabeller for valg etter visse dimensjoner, siden dette øker hastigheten på utførelse av spørringer. Du kan bruke eksterne variabler i parametere, hvis navn er innledet med "&"-tegnet.
c. "Felt" - en liste over felt som er valgt fra tabeller. Du kan også legge til beregnede felt; for å gjøre dette, klikker du på "Legg til"-knappen åpner den tilpassede uttrykkskonstruktøren:
Til venstre er et vindu med feltene som er tilgjengelige i uttrykket. Til høyre er et hint om funksjonene som brukes. Nedenfor er et konstruerbart vilkårlig uttrykk. Du kan bruke eksterne parametere i uttrykk; de er merket med "&"-tegnet, for eksempel: &Period, &StartDate
Du må være forsiktig, hvis et langt og komplekst uttrykk skrives inn i vinduet, som inneholder en liten syntaksfeil, vil systemet gi en advarsel og lukke vinduet etter å ha klikket på "OK". All innskrevet kode vil gå tapt, så jeg anbefaler at hvis du ikke er sikker på at uttrykket er korrekt, så lagre alltid innholdet på utklippstavlen (Ctrl-C) før du lukker konstruktøren.
2. "Relasjoner" - på fanen er forbindelser mellom tabeller indikert.
Tabellen angir tabellene som skal kobles, forholdet mellom tabellene som skal kobles og tilkoblingstilstanden. Hvis tilkoblingsbetingelsen er kompleks, kan du spesifisere et bestemt beregnet uttrykk, og den tilpassede feltkonstruktøren åpnes.
3. "Gruppering" - fanen angir hvilke felt som er gruppert og hvilke som er aggregert (oppsummert).
4. Fane "Betingelser" - viser betingelsene som er pålagt forespørselen.
I forhold kan du også skrive komplekse uttrykk ved å bruke den enkle uttrykkskonstruktøren og bruke eksterne variabler:
5. "Avansert"
Ytterligere parametere pålagt forespørselen
6. "Associasjoner og pseudonymer"
På denne fanen kan du tilordne aliaser for felt, samt administrere spørringer som er koblet sammen gjennom "UNITE" eller "UNITE ALL"-konstruksjonene.
7. "Bestilling"
I hvilken rekkefølge vil søkeresultatene vises?
Merk følgende! Nederst i bokmerket kan du se en hake "Auto-bestilling"- i den nåværende versjonen av 1C 8.1 i ACS er det ubrukelig; dessuten, når avkrysningsboksen er merket, under opptak, gir ACS en feil, så du bør ikke bruke den.
8. "Datasammensetning"
Fanen der tjenestefelt for adgangskontrollsystemet er definert. Den spiller omtrent samme rolle som "Rapportbygger"-fanen i en vanlig rapportdesigner.
A. På "Tabell"-fanen - tabellene som brukes i spørringen er oppført, du kan angi om tabellen må inkluderes i spørringen ved å merke av for "Obligatorisk". De. hvis ingen felt er inkludert i utvalget, deltar ikke denne tabellen i spørringen i det hele tatt. Du kan også angi parametere for tabeller.
I prosessen med å sette opp tilgangskontrollsystemet spesifiserer vi eventuelle valg, så vil alle utvalgsverdier bli erstattet med parametrene til de virtuelle tabellene, noe som igjen vil hjelpe oss med å optimalisere og øke hastigheten på spørringen.
b. På "Felt"-fanen er feltene og deres aliaser oppført som vil bli lagt til listen over ACS-felt.
c. "Betingelser" - hvis valg er spesifisert i ACS-innstillingene, vil alle utvalgsverdier legges til som tilleggsbetingelser; komplekse uttrykk kan også legges til betingelsene.
9. "Kenskaper"
Et bokmerke som ikke har noen analog i den vanlige utdataformkonstruktøren.
Denne fanen lar deg utvide arbeidet med spørringer med egenskaper. Tabellen på fanen består av flere felt:
en. "Verditype" - typen som egenskapene skal velges for. Hvis du for eksempel spesifiserer "Directory Link.Nomenclature", vil alle egenskapene for nomenklaturen bli valgt i spørringen.
b. "Kilde" - kilden for egenskaper av karakteristiske typer, kan være en spørring eller en tabell. I dette feltet kan vi skrive en forespørsel om å velge bare de egenskapene vi trenger.
c. "Liste over egenskaper" - et felt der kilden for egenskapene til egenskapene er angitt. Oftest er dette en plan av karakteristiske typer eller en forespørsel. Du må også spesifisere feltene som er ansvarlige for "Identifier", "Navn" og "Type" til eiendommen.
d. "Kilde" er det neste feltet der vi angir kilden til de karakteristiske verdiene, som også kan være enten en tabell eller en spørring.
e. "Karakteristisk verdi" er en tabell eller spørring som mottar karakteristiske verdier. For eksempel kan informasjonsregisteret "ObjectPropertyValues" tjene som en tabell med karakteristikkverdier. Vi må også indikere de feltene fra tabellen (eller spørringen) som er ansvarlige for "Objekt", "Egenskap" og "Verdi" til karakteristikken.
Etter å ha redigert forespørselen kan forespørselsteksten ses i vinduet under listen over felt. Nedenfor, med avmerkingsboksen "Autofyll", kan vi regulere fullføringen av tilleggsparametere for feltene spesifisert i forespørselen. Vær oppmerksom på at sammensetningen av feltene kun bestemmes i selve forespørselen.
Informasjon hentet fra siden
I dag skal vi snakke om hvordan du gjør nestede søk ved hjelp av spørringsbygger. La oss gå rett til et eksempel.
La oss si at vi har dette enkle informasjonsregisteret, der prisene lagres av varer og leverandører:
Vi ønsker å be om å motta alle produkter som har mer enn én leverandør. Dette kan implementeres ved hjelp av følgende spørring:
VELG Antall Leverandører.Produkt AS Produkt FRA (VELG Pris.Produkt AS Produkt, ANTALL(ANNLIG Pris.Leverandør) AS Leverandører FRA RegisterInformasjon.Pris AS Pris GRUPPE ETTER Pris.Produkt) AS Antall leverandører HVOR Antall leverandører.Leverandører > 1
Danner en nestet spørring i konstruktøren
La oss lage forespørselen ovenfor ved å bruke konstruktøren.
For å gjøre dette, i kommandopanelet over feltet Tabeller trykk på knappen Opprett en underspørring:
Deretter åpnes et vindu med en annen forekomst av spørringskonstruktøren: 
Og i dette nye vinduet konstruerer vi en nestet spørring: 
Klikk på knappen Be om I nedre venstre hjørne kan vi se teksten til underspørringen: 
Etter å ha klikket på OK-knappen i hjelpekonstruktøren, får vi følgende bilde i hovedvinduet: 
Siden setningen NestedQuery ikke veldig praktisk for persepsjon, la oss bruke høyre museknapp for å gi nytt navn til tabellen Antall leverandører, velg et felt fra det Produkt og på bokmerket Forhold La oss skrive ned den nødvendige betingelsen: 
Og etter alle disse manipulasjonene mottar vi ønsket forespørsel. Om nødvendig kan du opprette spørringer med flere nivåer av hekking.
Hvordan lage en nestet spørring fra en vanlig spørring i konstruktøren
Svært ofte oppstår det en situasjon når du begynner å lage en forespørsel i konstruktøren og på et tidspunkt innser du at den må nestes. Selvfølgelig, i vårt eksempel er det ikke noe problem - du kan ganske enkelt slette alt og sende forespørselen på nytt. Men i praksis er det mye mer komplekse eksempler, for eksempel med flere hekkingsnivåer, da det ble brukt flere timer på å stille forespørselen. Og i dette tilfellet er det en ganske enkel vei ut. Du kan bruke søketekstredigering som er innebygd i designeren. Må bruke en knapp Be om få forespørselsteksten (se bildet over) og kopier den til utklippstavlen. Deretter oppretter du en ny nestet spørring og trykker på knappen igjen Be om, lim inn teksten fra bufferen, klikk OK. Følgelig fjerner vi den gamle forespørselen på toppnivå. På denne måten, om nødvendig, kan vi enkelt lage nestede spørringer på flere nivåer i farten.
Muligheten til å skrive spørringstekst "manuelt" har aldri vært "overflødig", men det er mer praktisk å bruke en spørringsdesigner.
Kommentar.
Dessverre, i en administrert applikasjon kan du ikke bruke spørringsdesigneren i "Gjør kjent med spørring"-behandlingen. Du kan bruke den i denne behandlingen ved å bytte til normal modus, men vi vil ikke gjøre dette.
La oss lage "Request Constructor"-behandlingen og definere den i "Reports and Processing"-delsystemet.
La oss lage et behandlingsskjema og legge til attributtet til "TabDoc"-skjemaet av typen "Tabulært dokument", samt kommandoen "Run Query" med "Run Query"-handlingen. Deretter drar du dem til skjemaet.
I skjemamodulen, for at kommandoen skal fungere, skriver vi en prosedyre:
&På klient
Prosedyre Utfør spørring (kommando)
ExecuteRequestServer();
Slutt på prosedyre
&På server
Slutt på prosedyre
Vi blir inne i prosedyren som kalles på serveren og kaller "Query constructor with result processing" fra kontekstmenyen (Figur 2.65).
Figur 2.65 Spørringskonstruktør med resultatbehandling
Sett behandlingstypen til "Output til et regnearkdokument" og klikk enten på "Neste"-knappen eller "Tabeller og felt"-fanen.
På "Tables and Fields"-fanen til designeren kan du se de eksisterende tabellene i systemet (den venstre delen har tittelen "Database") (Figur 2.66).
Figur 2.67 Spørringskonstruktør
Tabellene som spørringen vil hente data fra, overføres til "Tabell"-området; feltene som kreves av spørringen, overføres til "Felt"-området. La oss gjøre det som i figur 2.68.
Fig 2.68 Spørringskonstruktør
Her har vi fjernet standardvisningsfeltet som er opprettet - "PREPRESENTATION (ProduktkvitteringProdukter.Nomenklatur)"
Når som helst mens du arbeider med designeren, kan du se den resulterende forespørselsteksten. For å utføre denne oppgaven må du klikke på "Request"-knappen i nedre venstre hjørne av designerskjemaet (Figur 2.69).
Du kan redigere forespørselsteksten manuelt ved å klikke på "Rediger"-knappen.
Øve på. Klikk på "OK"-knappen og sjekk behandlingen vår i brukermodus. Hvis du analyserer dataene som ble mottatt når du utfører forespørselen, kan du komme over "gjentakelser" av vareelementer (hvis dette ikke fungerer for deg, kan du kopiere og legge inn ethvert "varemottak"-dokument).
Vi går tilbake til ExecuteRequestServer()-prosedyren i «Request Constructor»-behandlingen og kaller igjen «Query Constructor med resultatbehandling» fra kontekstmenyen.
Hvis du vil "kollapse" resultatet av en spørring, kan du for dette formålet bruke kategorien "Grupper" til spørringsdesigneren.
Når du definerer grupperinger, må du overholde følgende regel: alle felt for valg av spørring er delt inn i felt som gruppering (konvolusjon) utføres etter, felt med nestede tabeller (felt som summeres i forhold til de som grupperingen utføres med) og aggregert funksjoner. La oss definere grupperinger (Figur 2.70).
Figur 2.70 Query Builder
Hvis dataene mottatt av forespørselen må velges i henhold til en eller annen betingelse, kan det i dette tilfellet være nødvendig å bruke fanen "Betingelser". La oss velge Goods ReceiptGoods.Quantity=10 (Figur 2.71).
Figur 2.71 Spørringskonstruktørtilstand.
Vær oppmerksom på at hvis betingelsen er definert på samme måte som i figuren, vil forespørselen ikke bli utført.
Det er to måter å rette opp situasjonen på:
Ved å omdefinere betingelsen ved å sjekke "P..."-flagget;
Ved å benytte muligheten til å endre selve forespørselsteksten (oppnåes ved å klikke på knappen "Rediger forespørsel").
Selve den manuelle endringen vil bestå i det faktum at det er nødvendig å fjerne "&"-symbolet før tallet "10". Dette symbolet i forespørselsteksten definerer forespørselsparametrene, som noen verdier må skrives inn senere (men før forespørselen utføres). Klikk på "Rediger spørring"-knappen og rediger (Figur 2.72).
Figur 2.73 Redigere en spørring
På «Avansert»-fanen kan du sjekke en rekke flagg (relatert til «Velg»-nøkkelordet for spørringsspråket) og bestemme sammensetningen av tabellene som er beregnet på å endre spørringen (Figur 2.74).
Figur 2.74 Ytterligere spørringsfunksjoner
På fanen "Joins/Aliases" kan du endre feltnavnene ved å sette "Aliaser", men vi vil ikke gjøre dette.
På «Ordre»-fanen kan du bestemme sorteringsrekkefølgen for poster som et resultat av spørringen (Figur 2.75).
Figur 2.75 Postsorteringsrekkefølge
Vær oppmerksom på "Auto-order"-flagget, det kan brukes til å bestille etter felt av en referansetype.
Når du definerer "Totaler"-delen, bør du være forberedt på at "ytterligere" totale poster vil vises som et resultat av spørringen. Sammen med disse postene blir spørringsresultatet hierarkisk (Figur 2.76).
Figur 2.76. Resultater av spørringskonstruktøren.
Det er mulig å spesifisere flere typer totaler:
Elementer (utvalget av søkeresultater inneholder gruppering av totaler og detaljerte poster);
Hierarki (i utvalget av søkeresultater, i det generelle tilfellet, er det sammendragsposter etter hierarki, sammendragsposter etter gruppering og detaljerte poster);
Bare hierarki (i utvalget av søkeresultater er det generelt oppsummeringsposter etter hierarki).
Etter å ha klikket på "Ok"-knappen til konstruktøren, vil en "Layout" bli generert og koden for ExecuteRequestServer()-prosedyren vil bli skrevet i skjemamodulen:
&På server
Prosedyre ExecuteRequestServer()
//((QUERY_CONSTRUCTOR_WITH_RESULT_PROCESSING
// Dette fragmentet er bygget av konstruktøren.
// Ved gjenbruk av konstruktøren vil endringer som er gjort manuelt gå tapt!!!
Layout = Processing.QueryConstructor.GetLayout("Layout");
Request = Ny forespørsel;
Request.Text =
| Varemottak Nomenclature AS Nomenclature,
| SUM (Receipt of Goods Goods. Quantity) AS Quantity,
| SUM(Receipt of GoodsGoods.Amount) AS Beløp
| Dokument.mottak av varer.varer
| HVORDAN MOTTA PRODUKTER
| Mottak av varer Varer. Antall > 1
|GRUPP ETTER
| Mottak av GoodsGoods.Nomenklatur
| BESTILL ETTER
| Mengde,
| Mengde MINSK
| SUM(antall),
| SUM(Sum)
| Nomenklaturhierarki";
Resultat = Query.Run();
HeaderArea = Layout.GetArea("Header");
AreaFooter = Layout.GetArea("Footer");
TableHeadArea = Layout.GetArea("TableHeader");
TableFooterArea = Layout.GetArea("TableFooter");
AreaNomenclatureHierarchy = Layout.GetArea("NomenclatureHierarchy");
AreaNomenclature = Layout.GetArea("Nomenclature");
TabDoc.Clear();
TabDoc.Output(AreaHeader);
TabDoc.Output(TableHeadArea);
TabDoc.StartAutoGroupingRows();
SelectionNomenclature = Result.Select(BypassQueryResult.ByGrouping);
Mens SelectionNomenclature.Next() Loop
Hvis SelectionNomenclature.RecordType() = RequestRecordType.TotalByHierarchy Then
Area = AreaNomenclatureHierarchy;
Region = RegionNomenklatur;
slutt om;
Area.Parameters.Fill(SelectionNomenclature);
TabDoc.Output(Area, SelectionNomenclature.Level());
EndCycle;
TabDoc.FinishAutoGroupingRows();
TabDoc.Output(TableFooterArea);
TabDoc.Output(AreaFooter);
//))CONSTRUCTOR_QUERY_WITH_RESULT_PROCESSING
