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 periodisk registrerer, 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 avkrysningsboksen - 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 et nytt. Vi går inn i dette skjemaet, og det er allerede et ubegrenset felt for kreativitet - du kan ordne de to detaljene du nettopp har 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 det venstre feltet for å redigere skjemaet, sørg for å sette "View"=Text Document Field i egenskapene.
I egenskapene til «Query Table»-attributtet kan du eventuelt spesifisere «Display Grid» og «Display Headers».
Deretter, i høyre skjemaredigeringsvindu, gå til "Kommandoer"-fanen og legg til en ny knapp, når du klikker på den, vil konsollen vår utføre en bestemt handling. La oss lage en knapp "Query Constructor", hvis du ønsker det, kan du legge til et ikon på knappen, det viktigste er å plassere selve knappen i det venstre skjemaredigeringsvinduet - slik at vi kan se det i høyre skjema 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 skal utføres, som vi vil tildele 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 preprosessorinstruksjonen #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, da" 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 opprette en annen knapp i konfiguratoren når vi redigerer konsollskjemaet vårt, la oss kalle det "Kjør spørring". 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 ModuleForms.
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ørringsbygger med behandling av resultater, se figur.":
Hvis du klikket på elementet "Spørringsdesigner med behandling av resultater", vil et modalt vindu "Spørringsteksten ble ikke funnet?", klikk ja på den første fanen "Behandler resultatet" - velg det første elementet "Omgå resultatet, vi trenger ikke noe annet fra denne konstruktøren, klikk på "Ok" -knappen - et modalt vindu vises: "Nei." felt er valgt i forespørselen, klikk "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;
Det er så enkelt, 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 "Verditabell"-attributtet er av typen "Tabelldokument", fordi ellers vil vi ikke se resultatene våre i brukermodus. Utdata fra tabelldata til brukeren håndteres alltid enten av et tabelldokument eller et layout. Jeg vil virkelig at det skal være 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( (opprettet 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 Opprett en enkel spørring (Du kan bruke Query Builder - den fungerer allerede for oss) og klikk på "Kjør spørring"-knappen:
Deretter vil du se nederst i meldingsvinduet - at Query Result-tabellen lagrer navnene på feltene som 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, skrive inn en enkel forespørsel uten parametere, klikk på "Kjør spørring" -knappen, se fig:
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å nøyaktig 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 løkke 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 vår konsoll under (jeg er personlig 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=tekst, 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) ASRemaiDataProduct 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 "Query Text", 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 en tom tabell på siden "Tidtabeller" - dette er tabellen over typer av vår fremtidige midlertidige tabell. Ved å bruke "Legg til"-knappen vil vi legge til navnet på attributtet og typen til 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å den første siden av behandlingen, 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 redigeres igjen. 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!!!
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Jeg jobber konstant med spørringskonsollen min, og nylig kom jeg over et veldig interessant søk der midlertidige tabeller ikke var i den første spørringspakken, men i de neste - og her ble konsollen min litt deprimert... Jeg måtte lage en annen oppgradering.
Så Temporary Tables Manager i en spørring forstår ikke alltid at de jobber med det)) Derfor må du eksplisitt angi denne selve Temporary Tables Manager:
&På serverprosedyren Utfør spørring på serveren () //upgrade2 - eksplisitt definisjon av midlertidig tabellbehandling! ManagerVT=Ny TemporaryTablesManager; Request = Ny forespørsel; //upgrade2 - eksplisitt definisjon av den midlertidige bordbehandleren! Query.TemporaryTableManager = VTManager; Request.Text = Object.RequestText;
Denne versjonen av konsollen er i den tredje nedlastingen.
Et av de kraftigste verktøyene til 1C Enterprise 8, uten tvil, er Query Builder. Konstruktøren er et visuelt verktøy for å jobbe med spørringer i 1C-språket. Men konstruktøren har en stor ulempe - den viser ikke resultatet av å utføre spørringer. Denne ulempen merkes spesielt av nybegynnere av applikasjonsløsninger på plattformene 1C:Enterprise 8.3 og 8.2.
I tillegg står selv erfarne 1C-programmerere ofte overfor en situasjon der det er nødvendig å gjøre en "engangs"-analyse av informasjonsbasedata i ulike seksjoner, men de ønsker ikke å skrive en fullverdig rapport for skyld. av en slik "engangskonklusjon".
For alle disse og mange andre saker tilbyr vi deg gjerne ekstern behandling Spørringskonsoll med mulighet til å behandle resultater for 1C 8.3 og 1C 8.2!
Hovedfunksjoner i spørringskonsollen for 1C 8.3 og 1C 8.2:
Universell behandling, kjører på alle konfigurasjoner av 1C-plattformer: Enterprise 8.1 – 8.3;
- kjører i 1C:Enterprise-modus;
- spørringen kan skrives manuelt, eller du kan ringe spørringsbyggeren;
- viser resultatet av forespørselen;
- du kan spesifisere rapportparametere direkte i spørringskonsollen;
- kan lagre og laste forespørselsfiler.
For å starte Query Console, må du starte konfigurasjonen i 1C:Enterprise-modus og åpne ekstern prosesserings Query Console som alle andre filer som er lagret på disken. Denne behandlingen vil fungere nøyaktig på samme måte som om den var en del av en applikasjonsløsning.
Ekstern behandling Query Console gjentar det kjente grensesnittet og det meste av funksjonaliteten til standardverktøysettet for å komponere spørringer i 1C:Enterprise 8.3- og 8.2-systemet. Den lar deg også hente resultatene av spørringer, batch-spørringer og midlertidige tabeller.
Spørringskonsollen kjøres i både klient-server og fil-server driftsmoduser av systemet, både under tykke og tynne klienter! Query Console integrerer en standard Query Builder, som kan kalles opp via kontekstmenyen i spørringstekstfeltet.
VIKTIG! Spørringsdesigneren i tynnklienten fungerer ikke. Dette elementet i designeråpningsmenyen er ikke tilgjengelig. I den tykke klienten er Query Builder tilgjengelig!
I tynnklienten kan vi kun skrive forespørsler for hånd. Alle andre funksjoner fungerer uten endringer.
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 periodisk registrerer, 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 avkrysningsboksen - 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 et nytt. Vi går inn i dette skjemaet, og det er allerede et ubegrenset felt for kreativitet - du kan ordne de to detaljene du nettopp har 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 det venstre feltet for å redigere skjemaet, sørg for å sette "View"=Text Document Field i egenskapene.
I egenskapene til «Query Table»-attributtet kan du eventuelt spesifisere «Display Grid» og «Display Headers».
Deretter, i høyre skjemaredigeringsvindu, gå til "Kommandoer"-fanen og legg til en ny knapp, når du klikker på den, vil konsollen vår utføre en bestemt handling. La oss lage en knapp "Query Constructor", hvis du ønsker det, kan du legge til et ikon på knappen, det viktigste er å plassere selve knappen i det venstre skjemaredigeringsvinduet - slik at vi kan se det i høyre skjema 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 skal utføres, som vi vil tildele 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 preprosessorinstruksjonen #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, da" 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 opprette en annen knapp i konfiguratoren når vi redigerer konsollskjemaet vårt, la oss kalle det "Kjør spørring". 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 ModuleForms.
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ørringsbygger med behandling av resultater, se figur.":
Hvis du klikket på elementet "Spørringsdesigner med behandling av resultater", vil et modalt vindu "Spørringsteksten ble ikke funnet?", klikk ja på den første fanen "Behandler resultatet" - velg det første elementet "Omgå resultatet, vi trenger ikke noe annet fra denne konstruktøren, klikk på "Ok" -knappen - et modalt vindu vises: "Nei." felt er valgt i forespørselen, klikk "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;
Det er så enkelt, 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 "Verditabell"-attributtet er av typen "Tabelldokument", fordi ellers vil vi ikke se resultatene våre i brukermodus. Utdata fra tabelldata til brukeren håndteres alltid enten av et tabelldokument eller et layout. Jeg vil virkelig at det skal være 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( (opprettet 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 Opprett en enkel spørring (Du kan bruke Query Builder - den fungerer allerede for oss) og klikk på "Kjør spørring"-knappen:
Deretter vil du se nederst i meldingsvinduet - at Query Result-tabellen lagrer navnene på feltene som 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, skrive inn en enkel forespørsel uten parametere, klikk på "Kjør spørring" -knappen, se fig:
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å nøyaktig 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 løkke 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 vår konsoll under (jeg er personlig 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=tekst, 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 du begynte å utvikle din egen versjon av midlertidige tabeller i parameterne finner du på denne lenken https://forum.site/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) ASRemaiDataProduct 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 "Query Text", 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 en tom tabell på siden "Tidtabeller" - dette er tabellen over typer av vår fremtidige midlertidige tabell. Ved å bruke "Legg til"-knappen vil vi legge til navnet på attributtet og typen til 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å den første siden av behandlingen, 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 redigeres igjen. 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!!!
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Jeg jobber konstant med spørringskonsollen min, og nylig kom jeg over et veldig interessant søk der midlertidige tabeller ikke var i den første spørringspakken, men i de neste - og her ble konsollen min litt deprimert... Jeg måtte lage en annen oppgradering.
Så Temporary Tables Manager i en spørring forstår ikke alltid at de jobber med det)) Derfor må du eksplisitt angi denne selve Temporary Tables Manager:
&På serverprosedyren Utfør spørring på serveren () //upgrade2 - eksplisitt definisjon av midlertidig tabellbehandling! ManagerVT=Ny TemporaryTablesManager; Request = Ny forespørsel; //upgrade2 - eksplisitt definisjon av den midlertidige bordbehandleren! Query.TemporaryTableManager = VTManager; Request.Text = Object.RequestText;
Denne versjonen av konsollen er i den tredje nedlastingen.
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. Klikk på "Legg til"-knappen for å åpne 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 gjeldende versjonen av 1C 8.1 i ACS er det dessuten ubrukelig, når avkrysningsboksen er merket, 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, kan du 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 bli lagt til som ekstra betingelser 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 "Autofyll"-avmerkingsboksen, 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
1C-programmering består av mer enn bare å skrive et program. 1C er en blokk av brukerhandlinger og data som han arbeider med.
Dataene lagres i en database. 1C-spørringer er en måte å hente data fra en database for å vise dem til brukeren i et skjema eller behandle dem.
Den grunnleggende delen av rapporten er 1C-forespørselen. Når det gjelder en rapport, er ACS den største delen av rapporten.
Sitt ned. Ta en pust. Ro deg ned. Nå skal jeg fortelle deg nyhetene.
For å programmere i 1C er det ikke nok å kunne 1C-programmeringsspråket. Du må også kunne 1C-spørringsspråket.
1C-spørringsspråket er et helt eget språk som lar oss spesifisere hvilke data vi trenger å hente fra databasen.
Han er også tospråklig - det vil si at du kan skrive på russisk eller engelsk. Det er ekstremt likt SQL-spørringsspråket, og de som kan det kan slappe av.
Hvordan 1C-forespørsler brukes
Når en bruker starter 1C i Enterprise-modus, er det ikke et eneste gram data i den kjørende klienten. Derfor, når du trenger å åpne en katalog, ber 1C om data fra databasen, det vil si at den lager en 1C-forespørsel.
1C-spørsmål er:
- Automatiske spørringer 1C
Generert automatisk av systemet. Du har opprettet et dokumentlisteskjema. Lagt til en kolonne. Dette betyr at når du åpner dette skjemaet i Enterprise-modus, vil det være en spørring og dataene for denne kolonnen vil bli forespurt. - Halvautomatiske spørringer 1C
Det er mange metoder (funksjoner) i 1C-språket, når de åpnes, blir det gjort en spørring til databasen. For eksempel.GetObject() - Manuelle 1C-spørringer (skrevet av programmereren spesifikt som en spørring)
Du kan skrive en 1C-forespørsel selv i kode og utføre den.
Opprette og utføre 1C-spørringer
En 1C-forespørsel er den faktiske teksten til forespørselen på 1C-forespørselsspråket.
Teksten kan skrives med penner. Det vil si, ta det og skriv det (hvis du kan dette språket).
Siden 1C fremmer konseptet visuell programmering, der mye eller nesten alt kan gjøres uten å skrive kode for hånd, er det et spesielt Query Constructor-objekt som lar deg tegne teksten til en spørring uten å kunne spørringsspråket. Mirakler skjer imidlertid ikke - for dette må du vite hvordan du jobber med konstruktøren.
Når teksten til 1C-forespørselen er klar, må den utføres. For dette formålet er det et objekt i 1C-koden Request(). Her er et eksempel:
Request = Ny forespørsel();
Query.Text = "VELG
| Nomenklatur.Link
|FRA
| Directory.Nomenclature AS Nomenclature
|HVOR
| Nomenclature.Service";
Select = Query.Run().Select();
Rapport(Utvalg.Link);
EndCycle;
Som du kan se i eksemplet, etter å ha utført 1C-forespørselen, kommer resultatet til oss og vi må behandle det. Resultatet er en eller flere rader i tabellen (i en spesiell form).
Resultatet kan lastes opp til en vanlig tabell:
Hent = Query.Run().Unload(); //Resultat – verditabell
Eller bare gå rundt linje for linje.
Select = Query.Run().Select();
Mens Select.Next() Loop
//Gjør noe med søkeresultatene
EndCycle;
Arbeid med 1C-forespørsler
Grunnleggende prinsipper for 1C-spørringer
Grunnleggende prinsipper for å konstruere en 1C-forespørsel –
VELG Liste over felt FRA Tabelltittel WHERE-betingelser
Et eksempel på å konstruere en slik 1C-forespørsel:
VELGE
//liste over felt å velge
Link,
Navn,
Kode
FRA
//navn på tabellen som vi velger data fra
//liste over tabeller er en liste over objekter i konfiguratorvinduet
Directory.Nomenklatur
HVOR
//indikerer valg
Produkttype = &Service //utvalg etter ekstern verdi
Eller Service // «Service»-attributt av typen Boolean, utvalg etter verdi Sann
SORTER ETTER
//Sortering
Navn
Liste over 1C-tabeller
Du kan se tabellnavnene i konfiguratorvinduet. Du trenger bare å skrive "Katalog" i stedet for "Kataloger", for eksempel "Katalog.Nomenklatur" eller "Dokument.Salg av varer og tjenester" eller "Salgsregister".
Det er ekstra tabeller (virtuelle) for registre som lar deg få de endelige tallene.
Informasjonsregister.RegisterName.Last Slice(&Date) – 1C-forespørsel fra informasjonsregisteret, hvis det er periodisk, for en bestemt dato
Akkumuleringsregister.Registernavn.Saldo(&dato) – 1C-forespørsel fra saldoregisteret for en bestemt dato
Akkumuleringsregister.Registernavn.Omsetning (&Startdato, &Sluttdato) – 1C-forespørsel fra omsetningsregisteret for perioden fra startdato til sluttdato.
Ytterligere prinsipper
Når vi ber om en liste over noen data, fungerer de grunnleggende prinsippene. Men vi kan også be om tall og forespørselen kan telle dem for oss (f.eks. legge dem til).
VELGE
//Quantity(FieldName) – teller mengden
//Field AS OtherName – gir nytt navn til feltet
Antall (lenke) AS Antall dokumenter som er lagt inn
FRA
HVOR
Gjennomført
Denne 1C-forespørselen vil returnere det totale antallet dokumenter. Hvert dokument har imidlertid et organisasjonsfelt. La oss si at vi ønsker å telle antall dokumenter for hver organisasjon ved å bruke en 1C-spørring.
VELGE
//bare et dokumentfelt
Organisasjon,
//tell mengden
Quantity(Link) AS QuantityBy organisasjoner
FRA
Dokumenter salg av varer og tjenester
HVOR
Gjennomført
GRUPPE AV
Organisasjon
Denne 1C-forespørselen vil returnere oss antall dokumenter for hver organisasjon (også kalt "etter organisasjon").
La oss i tillegg beregne mengden av disse dokumentene ved å bruke en 1C-forespørsel:
VELGE
//bare et dokumentfelt
Organisasjon,
//tell mengden
//tell beløpet
FRA
Dokumenter salg av varer og tjenester
HVOR
Gjennomført
GRUPPE AV
//må brukes hvis listen over felt har en count() funksjon og ett eller flere felt samtidig - da må du gruppere etter disse feltene
Organisasjon
Denne 1C-forespørselen vil også returnere mengden dokumenter til oss.
VELGE
//bare et dokumentfelt
Organisasjon,
//tell mengden
Quantity(Link) AS QuantityBy organisasjoner,
//tell beløpet
Amount(DocumentAmount) AS Amount
FRA
Dokumenter salg av varer og tjenester
HVOR
Gjennomført
GRUPPE AV
//må brukes hvis listen over felt har en count() funksjon og ett eller flere felt samtidig - da må du gruppere etter disse feltene
Organisasjon
PO RESULTATER Generelt
1C-spørringsspråket er omfattende og komplekst, og vi vil ikke vurdere alle dets evner i én leksjon – les de neste leksjonene våre.
Kort om tilleggsfunksjonene til 1C-spørringsspråket:
- Sammenføyning av data fra flere tabeller
- Nestede søk
- Batchforespørsel
- Lag dine egne virtuelle bord
- Spørring fra verditabell
- Bruke innebygde funksjoner for å hente og manipulere verdier.
1C Query Builder
For ikke å skrive forespørselsteksten for hånd, er det en 1C request designer. Bare høyreklikk hvor som helst i modulen og velg 1C Query Designer.
Velg ønsket tabell til venstre i 1C-spørringsdesigneren og dra den til høyre.
Velg de nødvendige feltene fra tabellen i 1C-spørringsdesigneren og dra til høyre. Hvis du ikke bare vil velge et felt, men bruke en slags summeringsfunksjon på det, klikker du på feltet to ganger med musen etter å ha trukket det. På kategorien Gruppering må du deretter velge (dra) de nødvendige feltene for gruppering.
På fanen Betingelser i 1C-spørringsdesigneren kan du velge de nødvendige valgene på samme måte (ved å dra feltene du vil gjøre valget ved). Pass på å velge riktig tilstand.
På fanen Ordre er sortering angitt. På fanen Resultater – oppsummere resultatene.
Ved å bruke 1C spørringsdesigner kan du studere alle eksisterende spørringer. For å gjøre dette, høyreklikk på teksten til en eksisterende forespørsel og velg også 1C spørringsdesigner - og forespørselen åpnes i 1C spørringsdesigner.
