Antrenament pentru proiectant de interogări 1C 8.2. Lucrul cu designerul de interogări cu rezultate într-un document de foaie de calcul

Designerul de interogări din 1C 8.3 și 8.2 este un instrument de dezvoltare puternic. Vă permite să compuneți un text de solicitare folosind un mediu vizual special. Astfel, pentru a crea o cerere 1C, nu este necesar să cunoașteți limbajul de interogare încorporat este suficient să navigați prin interfața simplă și intuitivă a designerului.

Generatorul de interogări este un set de file, fiecare dintre acestea fiind responsabilă pentru propria sa parte a interogării. Deci completând fila Tabele și câmpuri Selectăm tabele din care interogarea 1C va primi datele și câmpurile acestor tabele necesare pentru a rezolva o anumită problemă. Umplerea zidăriei Termeni impunem condiții tabelelor selectate pentru a selecta dintre ele doar datele de care avem nevoie și așa mai departe.

Descrierea designerului de interogări pe site-ul oficial 1C 8: v8.1c.ru

Tabele și câmpuri; ; ; ; ; ; Interogări imbricate (în dezvoltare).

Pentru a apela proiectantul de interogări 1s 8 în codul programului, trebuie să:

Creați o nouă cerere

Solicitare = Solicitare nouă;

Setați o linie de text de solicitare goală

Solicitare.Text = "";

Plasați cursorul mouse-ului între ghilimele și apăsați butonul dreapta al mouse-ului. În meniul contextual care se deschide, selectați elementul Constructor de interogări si raspunde Da la întrebarea despre crearea unei noi cereri. Dacă textul solicitării a fost deja notat, atunci trebuie să faceți clic oriunde în el și să apelați constructorul ;

Să ne uităm la toate filele principale ale generatorului de interogări folosind exemple mici de complexitate crescândă. Această abordare va permite unui programator începător 1C să studieze mai eficient constructorul și toate capacitățile acestuia. Pentru exemple vom folosi configurația Contabilitate 3.0.

Lecția #1. Generatorul de interogări este cel mai simplu caz de utilizare.

Sarcină: scrieți o solicitare în directorul de nomenclatură, selectați întreaga nomenclatură a directorului.

File noi: Tabele și câmpuri.

Noi mecanisme: vizualizarea și editarea textului solicitării folosind butonul „Solicitare”.

Pentru a începe să creați o cerere, să creăm o nouă cerere și să apelăm constructorul (așa cum este scris câteva paragrafe mai sus). După aceasta, fereastra designerului se va deschide pe filă Tabele și câmpuri.

Partea teoretică a lecției nr. 1

Tab Tabele și câmpuri constă din trei secțiuni:

Baza de date. Această secțiune prezintă toate tabelele bazei de date care pot fi folosite pentru a construi o interogare;

Mesele. În această secțiune, sunt selectate tabelele necesare pentru această interogare. Pentru a le muta apoi din secțiune baza de date trebuie să:

Sau faceți dublu clic pe tabel;
Sau folosiți butoanele „>” sau „>>”.

Secțiunea de deasupra Mesele Există o serie de butoane. Cele mai multe dintre ele vor fi discutate mai detaliat în lecțiile următoare. Deocamdată voi da doar explicații scurte.

Creați o subinterogare(linie roșie). Proiectat pentru a crea o nouă subinterogare;
Creați o descriere temporară a tabelului(linia galbenă). Vă permite să specificați numele unui tabel temporar care se află în afara acestei interogări, poate fi folosit și pentru a trece un tabel de valori la interogare;
Schimbați elementul curent(linia verde). Vă permite să săriți la subinterogarea, tabelul temporar sau descrierea tabelului temporar selectat;
Eliminați elementul curent(linie albastră). Elimina tabelul selectat din tabelele selectate;
Înlocuiți masa(linie albastră). Deschide caseta de dialog pentru înlocuirea tabelului selectat. Util dacă ați selectat greșit tabelul virtual de înregistrare, deoarece poziționarea are loc pe tabelul selectat curent din listă.
Opțiuni de masă virtuală(linie violetă). Deschide parametrii tabelului de registru virtual.

Câmpuri. Această secțiune selectează câmpuri de tabel din secțiunea anterioară. Aceste câmpuri vor fi coloanele tabelului sau ale selecției obținute ca urmare a interogării. Acestea sunt necesare în primul rând pentru a obține din tabelele selectate doar informațiile necesare într-un anumit caz. Pentru a le muta din secțiune Mesele necesare:

Sau faceți dublu clic pe câmp;
Sau utilizați butoanele „>” sau „>>”;
De asemenea, puteți adăuga un câmp nou, folosind o expresie arbitrară din câmpurile tabelelor selectate și ale funcțiilor limbajului de interogare.

Secțiunea de deasupra Câmpuri Există o serie de butoane. Crearea câmpurilor folosind expresii arbitrare va fi discutată mai detaliat în lecțiile următoare. Deocamdată voi da doar explicații scurte.

Adăuga(linia verde). Proiectat pentru a adăuga un câmp nou folosind editorul de expresii libere;
Schimbați elementul curent(linie roșie). Vă permite să modificați câmpul selectat folosind editorul;
Ștergeți curentul(linie albastră). Îndepărtează câmpul selectat din listă.

Partea practică a lecției nr. 1

Ne-am ocupat de teoria necesară îndeplinirii sarcinii prevăzute în această lecție. Permiteți-mi să vă reamintesc cum sună: scrieți o solicitare în directorul nomenclatorului, selectați întreaga nomenclatură a directorului.

Să începem să creăm o solicitare pentru articole:

Să creăm o nouă cerere și să deschidem constructorul folosind metoda specificată la începutul lecției;
In sectiunea Baza de date, hai sa deschidem un thread Directoareși vom găsi un ghid acolo Nomenclatură;
Selectează-l și folosește butonul „>” pentru a-l muta în secțiune Mese;
In sectiunea Mesele deschideți directorul nomenclaturii folosind pictograma „+”;
În lista de câmpuri care se deschide, găsiți câmpul Legăturăși mutați-l în secțiune Câmpuri folosind butonul „>”.
Solicitarea articolului este gata, faceți clic pe butonul „OK” din partea de jos a ferestrei de proiectare.

Deci, să începem cu ceva simplu: creați o Procesare nouă în configurator, denumiți-o Consola de interogări sau Generator de interogări, după cum doriți.

Putem adăuga imediat un tabel în „Date” pentru parametrii viitori de care avem nevoie, astfel încât în Consola noastră să rulăm nu cea mai primitivă cerere, ci cu parametri și legături, de exemplu, pentru munca noastră vom crea o solicitare la registrele periodice , dar aici fără Parameter instructions=&Date nicăieri.

Pentru a crea tabelul nostru de parametri, în fila „Date” din „partea tabulară” vom adăuga un nou tabel, să-l numim Parametri de interogare, aici vom adăuga coloanele acestui tabel: 1) NumeParametru, tastați șir = 25 de caractere ; ParameterValue, aici este un tip de date compus, vezi Fig:

Prin urmare, așa cum se arată în imagine, selectăm un tip compus pentru coloana Valoare parametru: în meniul tip care se deschide, bifați caseta de selectare „Tip compus”, selectați numărul, șirul (specificați 20 de caractere), data, boolean și bifați caseta de selectare de jos – AnyLink – înseamnă ceea ce urmează, Când specificăm Parametrii solicitării noastre, ne putem referi la orice obiect al configurației noastre, de exemplu, directoare sau documente.

Acum trebuie să creăm forma viitoarei noastre Console de interogări. În procesare, să mergem la fila „Formulare” și să adăugăm unul nou. Introducem acest formular și aici există deja un câmp nelimitat pentru creativitate - puteți aranja cele două detalii pe care tocmai le-ați creat și o placă cu parametrii după cum doriți! Pentru a face acest lucru, puteți utiliza elemente de formular standard, cum ar fi un grup sau o pagină cu pagini (dacă preferați să răsturnați paginile.

Principalul lucru aici este un lucru: după ce trageți atributul „TextValues” în câmpul din stânga al editării formularului, asigurați-vă că setați „View”=Text Document Field în proprietățile sale.

În proprietățile atributului „Tabel de interogări”, puteți specifica opțional „Grilă de afișare” și „Afișare anteturi”.

Apoi, în fereastra din dreapta pentru editarea formularului, mergeți la fila „Comenzi” și adăugați un buton nou, atunci când faceți clic, Consola noastră va efectua o anumită acțiune. Să creăm un buton „Query Designer”, dacă doriți, puteți adăuga o pictogramă la buton, principalul lucru este să plasați butonul însuși în fereastra din stânga pentru editarea formularului - astfel încât să îl putem vedea apoi în fereastra din dreapta pentru editarea formularului, faceți clic dreapta pe butonul nostru și selectați proprietăți – în proprietăți, faceți clic pe elementul „Acțiune”, va apărea o fereastră modală care vă va întreba unde exact va fi executat codul programului nostru, pe care îl vom atribui butonul – selectați „Pe client”.

Modulul formular se va deschide cu o procedură goală gata făcută „Constructor de interogare de procedură (comandă)”. În această procedură vom descrie apelul la standardul 1c8 Query Builder. Este foarte usor: Constructor = New Request Constructor; Dar există capcane aici - Constructorul de interogări încorporat în platformă funcționează în modul utilizator NUMAI sub un client gros! Prin urmare, vom introduce condiția instrucțiunii de preprocesor #Dacă, dar aici decideți singur, în funcție de platforma dvs., sau aveți formulare obișnuite, apoi selectați „ FatClientRegularApp” sau aveți o platformă bazată pe formulare gestionate, apoi ” ThickClientManagedApplication„.vezi fig.

Acum rămâne să adăugăm la această procedură o condiție pentru înregistrarea textului cererii, pe care Generatorul de interogări o va genera pentru noi în detaliile formularului nostru „Text de solicitare”:

Dacă Constructor.OpenModal()=True, atunci Object.RequestText=Constructor.Text;

endIf;

Dar putem schimba manual ceva în textul solicitării (în modul utilizator - în fereastra de atribut „Text solicitat”), astfel încât modificările noastre să intre în Constructorul de interogări atunci când este apelat din nou - vom adăuga o condiție simplă aici:

Dacă nu EmptyString(Object.QueryText) atunci Constructor.Text = Object.QueryText;

endIf;

Deci, rulăm Constructorul de interogări, putem începe să punem împreună interogarea viitoare în el, dar suntem interesați să vedem cum va funcționa interogarea pe care am creat-o! Și pentru a face acest lucru, trebuie să creăm un alt buton în configurator atunci când edităm formularul consolei noastre, să-l numim „Run Query”. În proprietățile butonului „Run Query”, faceți clic pe „Acțiune”, apare din nou un meniu în care suntem întrebați unde va fi procesat codul programului nostru, în acest caz selectăm „Atât pe client, cât și pe server”, din nou ne regăsim în Modulul Forme.

În procedura Execute Query(), pe care o avem pe client, vom scrie o condiție dacă utilizatorul nu a introdus textul de interogare, dar cere să îl execute:

If EmptyString(Object.QueryText) Then report("Introduceți textul interogării!");

endIf;

Sistemul a generat deja automat o legătură către procedura Execute RequestOnServer() ; – asta e bine, să trecem la această procedură, care se execută pe server, și să scriem aici codul pentru executarea cererii noastre introduse.

Există opțiuni aici: Puteți scrie singur toate expresiile legate de crearea interogărilor, de ex. manual, dar există o opțiune și mai simplă - în cadrul procedurii, faceți clic dreapta și în meniul derulant selectați „Generator de interogări cu procesarea rezultatelor, vezi figura”:

Dacă ați făcut clic pe elementul „Generator de interogări cu procesare a rezultatelor”, va apărea o fereastră modală „Textul de interogare nu a fost găsit?”, faceți clic pe Da, în care din prima filă se va deschide „Procesarea rezultatelor” - selectați primul element „Ocolirea rezultatului”. Asta este, nu avem nevoie de nimic altceva de la acest constructor, faceți clic pe butonul „Ok” - va apărea o fereastră modală „Nu sunt selectate câmpuri în cerere, faceți clic pe „Ok”.

După aceasta, următorul șablon gata făcut va apărea în cadrul procedurii noastre ExecuteRequestOnServer():

Să trecem la expresia construită de constructor:

Solicitare.Text = "";

Așa este de simplu, butonul nostru „Execute Request” de pe formularul de procesare este deja practic funcțional, până acum poate procesa doar cereri simple fără parametri, dar principalul lucru este că funcționează! Tot ce rămâne este să afișam vizual rezultatele solicitării noastre în atributul „Tabelul de valori” din formularul de procesare. Permiteți-mi să vă reamintesc că atributul nostru „Tabel de valori” este de tip „Document tabelar”, deoarece altfel nu vom vedea rezultatele noastre în modul utilizator. Afișarea datelor tabulare către utilizator se face întotdeauna fie printr-un document tabelar, fie printr-un Layout. Mi-ar plăcea foarte mult să fie posibilă afișarea datelor printr-un tabel de valori - deoarece este foarte ușor de utilizat și familiar, dar. , din păcate, un tabel de valori este doar un instrument de care are nevoie un dezvoltator, nu puteți afișa date pe ecran folosindu-l...

Să aruncăm o privire mai atentă la ce este un document de foaie de calcul - este ca o foaie Excel - poți ajunge la o înregistrare într-o anumită celulă doar folosind celulele tabelului, aici le numim o zonă, dar noi înșine putem selecta intervalul acestei zone într-o singură celulă specifică:

Deci, ne-am dat seama ce este un document de foaie de calcul și am stabilit pentru noi înșine că va trebui să definim datele din interogarea noastră într-o anumită celulă a acestui document de foaie de calcul. Dar să ne gândim: care este „Rezultatul interogării” pe care designerul l-a generat atât de repede pentru noi? Deschideți ajutorul - Rezultatul interogării este un tabel care are proprietățile corespunzătoare! vezi fig.

Și dacă scriem acum după expresia Query Result = Query.Execute( (creat de constructor), iată un ciclu atât de simplu pentru Colecții:

Pentru fiecare ColumnName Din Interogare Result.Columns Loop report(ColumnName.Name);

EndCycle;

După acest ciclu, deocamdată, notează toate expresiile construite automat de constructor. Și rulați 1C:Enterprise8 sub clientul gros Creați orice interogare simplă (puteți utiliza Generatorul de interogări - funcționează deja pentru noi) și faceți clic pe butonul „Run Query”:

Veți vedea în partea de jos a ferestrei de mesaj că tabelul Rezultatele interogării stochează numele câmpurilor pe care tocmai le-am selectat prin crearea unei interogări simple.

Acum să afișăm aceste nume ale câmpurilor suferinței noastre într-un document de calcul:

Pentru a afișa detaliile datelor interogării, să analizăm expresiile create automat de designer și să introducem în bucla de sortare „SelectionDetailedRecords” a interogării în sine exact aceeași buclă pe care am folosit-o pentru a afișa numele coloanelor, doar că acum trebuie să transferăm nu datele din tabelul „Rezultatul interogării” în textul celulei și datele selecției în sine, să vedem în ajutor cum puteți accesa câmpul Selecție detaliată al cererii:

SelectionDetailRecords = QueryResult.Select();

În timp ce SelectionDetailedRecords.Next() Loop //în prima linie avem deja scrise numele coloanelor din tabel, așa că încărcăm datele sub prima lineDocRowNumber=Object.QueryTable.TableHeight+1;

Pentru fiecare ColumnName din Query Result.Columns Cycle Cell=Object.QueryTable.Area(DocRowNumber,QueryResult.Columns.Index(ColumnName)+1);

Cell.Text = SelectionDetailedRecords[ColumnName.Name];

EndCycle;

Totul, putem verifica, încărcați întreprinderea sub un client gros, introduceți o cerere simplă fără parametri, faceți clic pe butonul „Run Query”, vezi fig:

Ura, totul merge!!!

Descărcarea conține o mostră a Consolei de interogări pe care tocmai am creat-o.

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Upgrade la Query Console:

1) Acum, Consola noastră de interogări de casă, cu un Generator de interogări încorporat, va rula sub orice client: sub un client gros de formulare obișnuite și gestionate și sub un client subțire și web.

p.s. Forma și aspectul Generatorului de interogări încorporat sunt diferite - în funcție de clientul în care am lansat Consola (eu personal sunt mai familiar și mai convenabil cu forma Generatorului de interogări sub un client gros)

&Pe Client Procedure Query Constructor (Comandă) //apelarea standard Query Constructor este posibilă numai sub un client gros #If ThickClientManagedApplication sau ThickClientNormalApplication Then Constructor=New Query Constructor;

Dacă nu EmptyString(Object.QueryText) atunci Constructor.Text = Object.QueryText;

endIf;

Dacă Constructor.OpenModal()=True, atunci Object.RequestText=Constructor.Text;

SELECTAȚI ExternalData.Product, ExternalData.Quantity PLACE ExternalData FROM &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 Register Accumulations.Remaining Products.Remainings(&Date, Product IN (SELECT ExternalData.Product FROM ExternalData AS ExternalData)) =Remaining Products Remaining Products.Data ca produs extern RemainingProductRemainingProduct

Pe baza exemplului și asemănării codului de interogare de mai sus, vă puteți crea propria interogare complexă, ținând cont de obiectele dvs. de date.

Deci, în designerul de interogări am creat interogarea de mai sus, închizând Constructorul - textul interogării va intra în câmpul consolei „Text interogare”, faceți clic pe butonul „Găsiți parametri”, vedem că în tabelul Parametri a apărut o linie = „Date externe”, Tip valoare = „Tabel de valori”, vezi fig.

În acest tabel de parametri - introduceți parametrul Data, de exemplu, data de astăzi, apoi faceți clic pentru a încerca să editați parametrul temporar al tabelului „Date externe”, faceți clic în câmpul cu „Tabel de valori” pe trei puncte - o selecție de tipuri va apare, faceți clic pe Rând, mecanismul nostru ne întoarce pagina din formular, unde trebuie să introducem manual acest tabel foarte temporar.

Rețineți aici că, în acest caz, pe pagina „Orare” din partea de jos a câmpului „Nume tabel temporar în parametri”, va apărea numele tabelului nostru temporar (este copiat din tabelul Parametri).

Până acum, pe pagina „Tabele de timp” vedem un singur tabel gol - acesta este tabelul Tipurilor viitorului nostru tabel temporar. Folosind butonul „Adăugați”, vom adăuga numele detaliilor și tipul tabelului viitor . Fiți atenți - numele și tipul trebuie să corespundă cu ceea ce am specificat în cererea pentru &ExternalData:

Acum apăsăm butonul „Actualizați tabelul temporar” - și vom avea aici un al doilea tabel - îl vom completa direct cu date temporare ale tabelului prin butonul „Adăugați”.

Gata, ne putem verifica încă o dată dacă am introdus datele primitive ale parametrilor de interogare în tabelul de parametri de pe prima pagină de procesare și faceți clic pe butonul „Run Query” - totul este calculat și selectat în consecință cu limitarea datelor trecute în parametrul tabelului nostru temporar

p.s. Dacă ați făcut o greșeală când ați introdus numele detaliilor și tipurile acestora (în primul tabel) - doar închideți Consola și deschideți-o din nou - tabelul de date temporar va fi șters - și tabelul Tipuri poate fi editat din nou. noul tabel de date poate fi creat din nou.

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Asta e tot, putem crea un instrument de lucru foarte puternic cu propriile noastre mâini, în plus, consola noastră este încă foarte rapidă în comparație cu cele profesionale - și acesta este un avantaj foarte mare pentru dezvoltatori! Și, desigur, acum consola noastră funcționează sub orice client! Succes în dezvoltările tale creative!!!

Deci, să începem cu ceva simplu: creați o Procesare nouă în configurator, denumiți-o Consola de interogări sau Generator de interogări, după cum doriți.

Pentru a crea tabelul nostru Parametri, în fila „Date” din „partea tabulară” vom adăuga un nou tabel, numim Parametri de interogare, aici vom adăuga coloanele acestui tabel: 1) ParameterName, tastați șir = 25 de caractere; ParameterValue, aici este un tip de date compus, vezi Fig:

Prin urmare, așa cum se arată în imagine, selectăm un tip compus pentru coloana Valoare parametru: în meniul tip care se deschide, bifați caseta de selectare „Tip compus”, selectați numărul, șirul (specificați 20 de caractere), data, boolean și bifați caseta de selectare de jos - AnyLink - înseamnă ceea ce urmează, Când specificăm Parametrii solicitării noastre, ne putem referi la orice obiect al configurației noastre, de exemplu, directoare sau documente.

Acum trebuie să creăm forma viitoarei noastre Console de interogări. În procesare, să mergem la fila „Formulare” și să adăugăm unul nou. Introducem acest formular și există deja un câmp nelimitat pentru creativitate - puteți aranja cele două detalii pe care tocmai le-ați creat și o placă cu parametrii după cum doriți! Pentru a face acest lucru, puteți utiliza elemente de formular standard, cum ar fi un grup sau o pagină cu pagini (dacă preferați să răsturnați paginile.

În proprietățile atributului „Tabel de interogări”, puteți specifica opțional „Grilă de afișare” și „Afișare anteturi”.

Apoi, în fereastra de editare a formularului din dreapta, mergeți la fila „Comenzi” și adăugați un buton nou, când faceți clic, Consola noastră va efectua o anumită acțiune. Să creăm un buton „Constructor de interogări”, dacă doriți, puteți adăuga o pictogramă la buton, principalul lucru este să plasați butonul în sine în fereastra de editare a formularului din stânga - astfel încât să-l putem vedea apoi în forma corectă fereastra de editare, faceți clic dreapta pe butonul nostru și selectați proprietăți - în proprietăți, faceți clic pe elementul „Acțiune”, va apărea o fereastră modală care vă va întreba unde exact va fi executat codul programului nostru, pe care îl vom atribui butonului - selectați „ Pe client”.

Modulul formular se va deschide cu o procedură goală gata făcută „Constructor de interogare de procedură (comandă)”. În această procedură vom descrie apelul la standardul 1c8 Query Builder. Este foarte usor: Constructor = New Request Constructor; Dar există capcane aici - Constructorul de interogări încorporat în platformă funcționează în modul utilizator NUMAI sub un client gros! Prin urmare, vom introduce condiția instrucțiunii preprocesorului #Dacă, dar aici decideți singur, în funcție de platforma dvs., sau aveți formulare obișnuite, apoi selectați „ FatClientRegularApp„sau aveți o platformă bazată pe formulare gestionate, atunci” ThickClientManagedApplication„.vezi fig.

Dacă Constructor.OpenModal()=True, atunci Object.RequestText=Constructor.Text;

Gata, am conectat Constructorul de interogări încorporat în platforma 1c8, să ne uităm la munca noastră. Pentru a face acest lucru, lansați 1C:Enterprise în modul client gros folosind una dintre următoarele metode: 1) meniul principal al Configuratorului - Depanare - Pornire depanare - Client gros; 2) sau dacă aveți aceste taste pe panoul de control în configurator - doar apăsați butonul cu un cerc galben cu un punct gros, vezi figura:

Modul de utilizator al 1cEnterprise8 începe, găsim procesarea noastră, o lansăm, facem clic pe butonul nostru „Query Designer” și vedem cum se deschide designerul încorporat în platformă. vezi fig.

Deci, avem Constructorul de interogări care rulează, putem începe să punem împreună interogarea viitoare în el, dar suntem interesați să vedem cum va funcționa interogarea pe care am creat-o! Și pentru a face acest lucru, trebuie să creăm un alt buton în configurator atunci când edităm formularul consolei noastre, să-l numim „Run Query”. În proprietățile butonului „Run Query”, faceți clic pe „Acțiune”, apare din nou un meniu în care suntem întrebați unde va fi procesat codul programului nostru, în acest caz selectăm „Atât pe client, cât și pe server”, din nou ne găsim în ModuleForms.

În procedura Execute Query(), pe care o avem pe client, vom scrie o condiție dacă utilizatorul nu a introdus textul de interogare, dar cere să îl execute:

If EmptyString(Object.QueryText) Then report("Introduceți textul interogării!");

Sistemul a generat deja automat o legătură către procedura Execute RequestOnServer() ; - asta e bine, să trecem la această procedură, care se execută pe server, și să scriem aici codul pentru executarea cererii noastre introduse.

Există opțiuni aici: Puteți scrie singur toate expresiile legate de crearea interogărilor, de exemplu. manual, dar există o opțiune și mai simplă - în cadrul procedurii, faceți clic dreapta și în meniul derulant selectați „Proiectant de interogări cu procesarea rezultatelor, vezi figura.”:

Dacă ați făcut clic pe elementul „Proiectare de interogări cu procesare a rezultatelor”, atunci va apărea o fereastră modală „Textul de interogare nu a fost găsit”, faceți clic pe Da, în care se va deschide pe prima filă „Procesarea rezultatului” - selectați primul element „Ocolirea rezultatului, nu avem nevoie de nimic altceva de la acest constructor, faceți clic pe butonul „Ok” - va apărea o fereastră modală: „Nu”. câmpurile sunt selectate în cerere, faceți clic pe „OK”.

După aceasta, următorul șablon gata făcut va apărea în cadrul procedurii noastre ExecuteRequestOnServer():

Să trecem la expresia construită de constructor:

Solicitare.Text = "";

Este atât de simplu, butonul nostru „Execută cererea” de pe formularul de procesare este deja practic operațional, până acum poate procesa doar cereri simple fără parametri, dar principalul lucru este că funcționează! Tot ce rămâne este să afișam vizual rezultatele solicitării noastre în atributul „Tabelul de valori” din formularul de procesare. Permiteți-mi să vă reamintesc că atributul nostru „Tabelul de valori” este de tip „Document tabelar”, deoarece altfel nu vom vedea rezultatele noastre în modul utilizator. Ieșirea datelor tabulare către utilizator este întotdeauna gestionată fie de un document tabelar, fie de un Layout. Aș dori foarte mult să fie posibilă afișarea datelor printr-un tabel de valori - deoarece este foarte ușor de utilizat și familiar, dar. , din păcate, un tabel de valori este doar un instrument de care are nevoie un dezvoltator, nu puteți afișa date pe ecran folosindu-l...

Și dacă scriem acum după expresia Query Result = Query.Execute( (creat de constructor), iată un ciclu atât de simplu pentru Colecții:

Pentru fiecare ColumnName Din Interogare Result.Columns Loop report(ColumnName.Name);

Apoi veți vedea în partea de jos a ferestrei de mesaj - că tabelul Rezultatele interogării stochează numele câmpurilor pe care tocmai le-am selectat prin crearea unei interogări simple.

Veți vedea în partea de jos a ferestrei de mesaj că tabelul Rezultatele interogării stochează numele câmpurilor pe care tocmai le-am selectat prin crearea unei interogări simple.

Acum să afișăm aceste nume ale câmpurilor suferinței noastre într-un document de calcul:

SelectionDetailRecords = QueryResult.Select();

Gata, putem verifica, încărca întreprinderea sub un client gros, introduceți o cerere simplă fără parametri, faceți clic pe butonul „Run Query”, vezi figura:

Pentru fiecare ColumnName din Query Result.Columns Cycle Cell=Object.QueryTable.Area(DocRowNumber,QueryResult.Columns.Index(ColumnName)+1);

Este foarte convenabil când, la deschiderea/închiderea Consolei noastre de interogări, textul de interogare, cu care am lucrat înainte de a închide consola, este din nou scris în câmpul „Text de interogare”. Pentru a face acest lucru, trebuie doar să activați proprietatea formularului = Salvare automată, vezi fig:

Gata, consola noastră funcționează. Pentru a putea scrie interogări mai complexe cu parametri specificați în ele, trebuie să creăm un alt buton „Găsiți parametri”, precum și codul pentru butonul „Run Query” - va fi executat codul pentru butonul „Găsiți parametri”. pe client și pe server. Apoi, în procedura serverului, lansăm solicitarea exact în același mod cu textul trecut în ea din fereastra „Request Text”, folosind expresia „Request.FindParameters()” găsim parametrii trecuți și pur și simplu îi introducem în o buclă în partea tabelară a formularului „Parametri de solicitare”. Nu uitați să le transferați apoi din tabelul de parametri completat în procedura „Run Query”.

EndCycle;

Totul, putem verifica, încărcați întreprinderea sub un client gros, introduceți o cerere simplă fără parametri, faceți clic pe butonul „Run Query”, vezi fig:

Ura, totul merge!!!

Descărcarea conține o mostră a Consolei de interogări pe care tocmai am creat-o.

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Upgrade la Query Console:

2) S-a adăugat posibilitatea la Consola noastră de interogări simplă de a introduce interogări complexe cu un tabel temporar transmis la parametri!!! Mecanismul s-a dovedit a fi foarte simplu și elegant - fără a utiliza cod XML, așa cum se face în consolele profesionale.

endIf;

Dacă Constructor.OpenModal()=True, atunci Object.RequestText=Constructor.Text;

Folosind exemplul și asemănarea codului de interogare de mai sus, vă puteți crea propria interogare complexă, ținând cont de obiectele dvs. de date.

Deci, în designerul de interogări am creat interogarea de mai sus, închizând Constructorul - textul interogării va intra în câmpul consolei noastre „Text interogare”, faceți clic pe butonul „Găsiți parametri”, vedem că în tabelul Parametri a apărut o linie = "Date externe", Value type="Value Table" ,vezi fig.

În acest tabel de parametri - introduceți parametrul Data, de exemplu, data de astăzi, apoi faceți clic pentru a încerca să editați parametrul nostru temporar de tabel „Date externe”, faceți clic în câmpul cu „Tabel de valori” pe trei puncte - o selecție de tipuri va apare, faceți clic pe Rând, mecanismul nostru ne întoarce pagina din formular, unde trebuie să introducem manual acest tabel foarte temporar.

Rețineți aici că, în acest caz, pe pagina „Orare” din partea de jos a câmpului „Numele tabelului temporar în parametri”, va apărea numele tabelului nostru temporar (este copiat din tabelul Parametri).

Până acum, pe pagina „Tabele de timp” vedem un singur tabel gol - acesta este tabelul Tipurilor viitorului nostru tabel temporar. Folosind butonul „Adăugați”, vom adăuga numele atributului și tipul tabelului viitor . Fiți atenți - numele și tipul trebuie să corespundă cu ceea ce am specificat în cererea pentru &ExternalData:

Acum apăsăm butonul „Actualizați tabelul temporar” - și vom avea aici un al doilea tabel - îl vom completa direct cu date temporare ale tabelului prin butonul „Adăugați”.

Gata, ne putem verifica încă o dată dacă am introdus datele primitive ale parametrilor de interogare în tabelul cu parametri de pe prima pagină de procesare și faceți clic pe butonul „Run Query” - totul este calculat și selectat în consecință cu limitarea datelor trecute în parametrul tabelului nostru temporar

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Lucrez constant cu Consola mea de interogări, iar recent am dat peste o interogare foarte interesantă în care tabelele temporare nu se aflau în primul pachet de interogări, ci în următoarele - și aici consola mea a devenit puțin deprimată... A trebuit să fac un alt upgrade.

Deci, Managerul de tabele temporare dintr-o interogare nu înțelege întotdeauna că lucrează cu ea)) Prin urmare, trebuie să setați în mod explicit acest Manager de tabele temporare:

&Pe server Procedura Executare interogare pe server () //upgrade2 - definiție explicită a managerului de tabele temporare!

ManagerVT=New TemporaryTablesManager;

Solicitare = Solicitare nouă;

//upgrade2 - definiție explicită a managerului tabelului temporar!

Query.TemporaryTableManager = VTManager;

Request.Text = Object.RequestText;

Această versiune a consolei se află la a treia descărcare.

Capacitatea de a scrie textul interogării „manual” nu a fost niciodată „superfluă”, dar este mai convenabil să utilizați un designer de interogări.

Comentariu.

Procedura Executare interogare (comandă)

ExecuteRequestServer();

EndProcedure

&OnServer

EndProcedure

Intrăm în procedura apelată pe server și apelăm „Constructor de interogare cu procesare rezultat” din meniul contextual (Figura 2.65).

Figura 2.65 Constructor de interogări cu procesarea rezultatelor

Setați tipul de procesare la „Ieșire într-un document de foaie de calcul” și faceți clic fie pe butonul „Următorul”, fie pe fila „Tabele și câmpuri”.

În fila „Tabele și câmpuri” a designerului, puteți vizualiza tabelele existente în sistem (partea din stânga este intitulată „Bază de date”) (Figura 2.66).

Figura 2.67 Constructor de interogare

Tabelele din care interogarea va obține date sunt transferate în zona „Tabele” câmpurile solicitate de interogare sunt transferate în zona „Câmpuri”.

Să o facem ca în Figura 2.68.

Fig 2.68 Constructor de interogare

Aici am eliminat câmpul de vizualizare implicit creat - „PREZENTARE (Recepția BunurilorProduse.Nomenclatură)”

În orice moment în timp ce lucrați cu designerul, puteți vizualiza textul de solicitare rezultat.

Pentru a efectua această sarcină, trebuie să faceți clic pe butonul „Solicitare” situat în colțul din stânga jos al formularului de proiectant (Figura 2.69).

Puteți edita manual textul solicitării făcând clic pe butonul „Editați”.

Practica. Faceți clic pe butonul „OK” și verificați procesarea noastră în modul utilizator.

Dacă analizați datele primite în timpul executării cererii, puteți găsi „repetări” articolelor articolului (dacă acest lucru nu funcționează pentru dvs., atunci puteți copia și posta orice document „Primire de bunuri”).

Revenim la procedura ExecuteRequestServer() din procesarea „Constructor de interogare” și din meniul contextual apelăm din nou „Constructor de interogare cu procesare rezultat”.

Dacă doriți să „restrângeți” rezultatul unei interogări, atunci în acest scop puteți utiliza fila „Grupare” a designerului de interogări.

Atunci când definiți grupările, trebuie să respectați următoarea regulă: toate câmpurile de selecție a interogărilor sunt împărțite în câmpuri după care se realizează gruparea (convoluția), câmpuri de tabele imbricate (câmpuri care sunt însumate în raport cu cele prin care se realizează gruparea) și agregate. funcții. Să definim grupările (Figura 2.70).

Vă rugăm să rețineți că dacă condiția este definită în același mod ca în figură, cererea nu va fi executată.

Există două moduri de a corecta situația:

Prin redefinirea condiției prin bifarea steagului „P...”;

Profitând de oportunitatea de a schimba textul solicitării în sine (obținut făcând clic pe butonul „Editare cerere”).

Schimbarea manuală în sine va consta în faptul că este necesară eliminarea simbolului „&” înaintea numărului „10”. Acest simbol în textul solicitării definește parametrii solicitării, în care unele valori trebuie să fie scrise ulterior (dar înainte de a executa cererea). Faceți clic pe butonul „Editați interogarea” și editați (Figura 2.72).

Figura 2.73 Editarea unei interogări

În fila „Avansat”, puteți verifica o serie de steaguri (legate de cuvântul cheie „Selectare” al limbajului de interogare) și puteți determina compoziția tabelelor destinate modificării interogării (Figura 2.74).

Figura 2.74 Funcții suplimentare de interogare

În fila „Alături/Aliasuri”, puteți modifica numele câmpurilor setând „Aliasuri”, dar nu vom face acest lucru.

În fila „Comandă”, puteți defini ordinea de sortare a înregistrărilor ca rezultat al interogării (Figura 2.75).

Figura 2.75 Ordinea de sortare a înregistrărilor

Acordați atenție indicatorului „Comandă automată”, acesta poate fi folosit pentru a ordona după câmpuri de tip referință.

Când definiți secțiunea „Totale”, ar trebui să fiți pregătit pentru faptul că înregistrările totale „suplimentare” vor apărea ca rezultat al interogării. Împreună cu aceste înregistrări, rezultatul interogării devine ierarhic (Figura 2.76).

Figura 2.76.Rezultatele constructorului de interogare.

Se pot specifica mai multe tipuri de totaluri:

Elemente (selectia rezultatului interogarii contine totaluri de grupare si inregistrari detaliate);

Ierarhie (în selecția rezultatului interogării, în cazul general, există înregistrări sumar pe ierarhie, înregistrări sumar pe grupare și înregistrări detaliate);

Numai ierarhie (în selecția rezultatelor interogării, în general, există înregistrări rezumative pe ierarhie).

După ce faceți clic pe butonul „Ok” al constructorului, va fi generat un „Layout” și codul pentru procedura ExecuteRequestServer() va fi scris în modulul formular:

&OnServer

Procedura ExecuteRequestServer()

//((QUERY_CONSTRUCTOR_WITH_RESULT_PROCESSING

// Acest fragment este construit de constructor.

// La reutilizarea constructorului, modificările făcute manual se vor pierde!!!

Layout = Processing.QueryConstructor.GetLayout("Layout");

Solicitare = Solicitare nouă;

Cerere.Text =

| Nomenclatura de primire a mărfurilor.

| SUM (primirea mărfurilor, mărfurilor. Cantitate) AS Cantitate,

| SUM(Recepția BunurilorMarfurilor.Suma) AS Sumă

| Document.Recepția Bunurilor.Marfa

| CUM SĂ PRIMIȚI PRODUSE

| Recepție Bună Cantitate > 1

|GRUPA DE

| Recepția Mărfurilor.Nomenclatura

|COMANDA DE

| Cantitate,

| Suma REDUCERE

| SUM(Cantitate),

| SUM(Suma)

| Nomenclatura IERARHIE”;

Rezultat = 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("Nomenclatura");

TabDoc.Clear();

TabDoc.Output(AreaHeader);

TabDoc.Output(TableHeadArea);

TabDoc.StartAutoGroupingRows();

SelectionNomenclature = Result.Select(BypassQueryResult.ByGrouping);

While SelectionNomenclature.Next() Loop

Dacă SelectionNomenclature.RecordType() = RequestRecordType.TotalByHierarchy, atunci

Area = AreaNomenclatureHierarchy;

Regiune = RegionNomenclature;

endIf;

Area.Parameters.Fill(SelectionNomenclature);

TabDoc.Output(Area, SelectionNomenclature.Level());

EndCycle;

TabDoc.FinishAutoGroupingRows();

TabDoc.Output(TableFooterArea);

TabDoc.Output(AreaFooter);

//))CONSTRUCTOR_QUERY_WITH_RESULT_PROCESSING

Deci, să începem cu ceva simplu: creați o Procesare nouă în configurator, denumiți-o Consola de interogări sau Generator de interogări, după cum doriți.

Prin urmare, așa cum se arată în imagine, selectăm un tip compus pentru coloana Valoare parametru: în meniul tip care se deschide, bifați caseta de selectare „Tip compus”, selectați numărul, șirul (specificați 20 de caractere), data, boolean și bifați caseta de selectare de jos - AnyLink - înseamnă ceea ce urmează, Când specificăm Parametrii solicitării noastre, ne putem referi la orice obiect al configurației noastre, de exemplu, directoare sau documente.

În proprietățile atributului „Tabel de interogări”, puteți specifica opțional „Grilă de afișare” și „Afișare anteturi”.

Modulul formular se va deschide cu o procedură goală gata făcută „Constructor de interogare de procedură (comandă)”. În această procedură vom descrie apelul la standardul 1c8 Query Builder. Este foarte usor: Constructor = New Request Constructor; Dar există capcane aici - Constructorul de interogări încorporat în platformă funcționează în modul utilizator NUMAI sub un client gros! Prin urmare, vom introduce condiția instrucțiunii preprocesorului #Dacă, dar aici decideți singur, în funcție de platforma dvs., sau aveți formulare obișnuite, apoi selectați „ FatClientRegularApp„sau aveți o platformă bazată pe formulare gestionate, atunci” ThickClientManagedApplication„.vezi fig.

Dacă Constructor.OpenModal()=True, atunci Object.RequestText=Constructor.Text;

În procedura Execute Query(), pe care o avem pe client, vom scrie o condiție dacă utilizatorul nu a introdus textul de interogare, dar cere să îl execute:

If EmptyString(Object.QueryText) Then report("Introduceți textul interogării!");

După aceasta, următorul șablon gata făcut va apărea în cadrul procedurii noastre ExecuteRequestOnServer():

Să trecem la expresia construită de constructor:

Solicitare.Text = "";

Și dacă scriem acum după expresia Query Result = Query.Execute( (creat de constructor), iată un ciclu atât de simplu pentru Colecții:

Pentru fiecare ColumnName Din Interogare Result.Columns Loop report(ColumnName.Name);

Apoi veți vedea în partea de jos a ferestrei de mesaj - că tabelul Rezultatele interogării stochează numele câmpurilor pe care tocmai le-am selectat prin crearea unei interogări simple.

Veți vedea în partea de jos a ferestrei de mesaj că tabelul Rezultatele interogării stochează numele câmpurilor pe care tocmai le-am selectat prin crearea unei interogări simple.

Acum să afișăm aceste nume ale câmpurilor suferinței noastre într-un document de calcul:

SelectionDetailRecords = QueryResult.Select();

Gata, putem verifica, încărca întreprinderea sub un client gros, introduceți o cerere simplă fără parametri, faceți clic pe butonul „Run Query”, vezi figura:

Pentru fiecare ColumnName din Query Result.Columns Cycle Cell=Object.QueryTable.Area(DocRowNumber,QueryResult.Columns.Index(ColumnName)+1);

EndCycle;

Totul, putem verifica, încărcați întreprinderea sub un client gros, introduceți o cerere simplă fără parametri, faceți clic pe butonul „Run Query”, vezi fig:

Ura, totul merge!!!

Descărcarea conține o mostră a Consolei de interogări pe care tocmai am creat-o.

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Upgrade la Query Console:

Puteți vedea codul în sine și procedurile pentru mecanismul de transfer la parametrii tabelelor temporare în al doilea fișier atașat. Cum am început să dezvolt propria mea versiune a tabelelor temporare din parametrii poate fi găsit la acest link https://forum.site/forum9/topic183700/

Dacă Constructor.OpenModal()=True, atunci Object.RequestText=Constructor.Text;

Folosind exemplul și asemănarea codului de interogare de mai sus, vă puteți crea propria interogare complexă, ținând cont de obiectele dvs. de date.

Până acum, pe pagina „Tabele de timp” vedem un singur tabel gol - acesta este tabelul Tipurilor viitorului nostru tabel temporar. Folosind butonul „Adăugați”, vom adăuga numele atributului și tipul tabelului viitor . Fiți atenți - numele și tipul trebuie să corespundă cu ceea ce am specificat în cererea pentru &ExternalData:

Acum apăsăm butonul „Actualizați tabelul temporar” - și vom avea aici un al doilea tabel - îl vom completa direct cu date temporare ale tabelului prin butonul „Adăugați”.

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Deci, Managerul de tabele temporare dintr-o interogare nu înțelege întotdeauna că lucrează cu ea)) Prin urmare, trebuie să setați în mod explicit acest Manager de tabele temporare:

&Pe server Procedura Executare interogare pe server () //upgrade2 - definiție explicită a managerului de tabele temporare!

ManagerVT=New TemporaryTablesManager;