Interogări imbricate în constructor. Constructori de interogări Condițiile constructorului de interogări 1c
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) 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ă, atunci 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. Intrăm în acest formular și există deja un câmp nelimitat pentru creativitate - poți aranja cele două detalii pe care tocmai le-ai creat și o placă cu parametri după cum vrei! 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 singur 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. Vezi Fig:
Î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 în sine în fereastra de editare a formularului din stânga - astfel încât să-l putem vedea. Apoi, în forma din dreapta 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 ușor: 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;
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, 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. Creați unul nou?”, faceți clic pe Da. Se va deschide designerul de interogări încorporat, în care se află prima filă. „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 = "";
Request.Text = Object.RequestText;
Așa este 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 „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. Chiar mi-ar plăcea 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, notați deocamdată toate expresiile create automat de constructor. Și rulați 1C:Enterprise8 sub clientul gros. Creați orice interogare simplă (puteți folosi Query Builder - 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 fiecare ColumnName din Query Result.Columns Loop Cell=Object.QueryTable.Area(1,QueryResult.Columns.Index(ColumnName)+1); Cell.Text=ColumnName.Name; EndCycle;
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ă a 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; EndCycle;
Asta este tot, putem verifica, încărca întreprinderea sub un client gros, introduce o cerere simplă fără parametri, faceți clic pe butonul „Run Query”, vezi figura:
Ura, totul merge!!!
Este foarte convenabil când, la deschiderea/închiderea Consolei noastre de interogări, textul nostru 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” - codul pentru butonul „Găsiți parametrii” va fi executat pe client și pe server. Apoi, în procedura serverului, lansăm cererea î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 într-un treceți în 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”.
De asemenea, puteți adăuga câteva butoane la Consola noastră care vor șterge fereastra Parametri și fereastra Solicitare text în modul utilizator.
Query Console este gata de utilizare, vă doresc soluții creative de succes folosind un instrument atât de simplu și puternic precum Query Console!
Această procesare este scrisă pe platforma 1c8.3 (formulare gestionate) și rulează sub un client gros. Poate fi scris și pe platforma 1c8.2, atât sub forme obișnuite, cât și sub cele gestionate.
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. (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; endIf; // #Else // Report("Apelarea Generatorului de interogări este posibilă numai sub un client gros"); // Întoarcere; //# EndIf #Else Report("Executați Query Builder sub un client subțire - diferă ușor în formă și viteza de performanță!"); Constructor = New QueryConstructor(); Dacă nu EmptyString(Object.QueryText) atunci Constructor.Text = Object.QueryText; endIf; Alerta constructor = New AlertDescription("RunAfterClosingConstructor", ThisForm); Constructor.Show(Alerta constructor); # EndIf End of Procedure &On the Client Procedure ExecuteAfterClosingConstructor(Result, ConstructorParameters) Export //Result=text, dacă Constructorul a fost închis folosind butonul ok Object.RequestText = AbbreviatedLP(Result); //lucrări!!! Sfârșitul procedurii
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.
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.infostart.ru/forum9/topic183700/
Acum, cum să utilizați Consola pentru o interogare complexă atunci când un tabel temporar este trecut la parametrii săi. De exemplu, puteți lua codul acestei solicitări;
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 Înregistrați Acumulări.Remaining Products.Remainings(&Data, Product IN (SELECT ExternalData.Product FROM ExternalData AS ExternalData) =Remaining Remaining ProductsRemaining Products. . Produs
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 noastre „Text interogare”, faceți clic pe butonul „Găsiți parametri”, vedem că în tabelul Parametri a apărut o linie = „Date externe”, Tipul valorii = „Tabelul 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 „Numele tabelului temporar în parametri”, va apărea numele tabelului nostru temporar (este copiat din tabelul Parametri).
Până acum, pe pagina „Tabele orare” 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 viitorului tabel. . 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 din nou editat și un 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!!!
Să vedem cum putem uni aceste două tabele după câmp Codul produsului folosind
constructor de interogări (codul pentru crearea tabelelor temporare este dat ca exemplu
Nu voi. O puteți lua de la linkul de mai sus).
Deschideți fereastra designerului, accesați fila „Tabele și câmpuri”, la secțiune
"Mese" selectați ambele tabele noastre și în secțiune "Câmpuri" -
acele câmpuri din ambele tabele pe care dorim să le vedem ca rezultat al interogării.
Accesați marcajul "Conexiuni". Adăugați o linie nouă. În câmp tabelul 1
din lista derulantă selectați tabelul cu produse, iar în câmp masa 2 Masa
cu tarile.
Pentru Tabelele 1 bifeaza casuta Toate. Pentru
Tabelele 2 Nu bifam aceasta caseta. Aceasta înseamnă că de la Tabelele 1
toate înregistrările vor fi selectate și din Tabelele 2 numai cele pentru care se realizează
starea de conectare, adică cu o astfel de combinație de steaguri obținem
CONEXIUNEA STÂNGA. În continuare trebuie să completați Condiția de comunicare.
Aici selectăm câmpurile tabelului din listele derulante și semnul de comparație tot din meniul derulant
listă. 
Ca urmare a acestei conexiuni, obținem următorul text de solicitare:
SELECT VT_Product.Product Code, VT_Product.Name, VT_Country.Country FROM VT_Product AS VT_Product LEFT JOIN VT_Country AS VT_Country BY VT_Product.Product Code = VT_Country.Product Code
Acum să aruncăm o privire mai atentă asupra unor puncte.
Să încercăm să schimbăm caseta de selectare Toate.
S-ar părea că până la urmă ar trebui să iasă ÎNSCRIEȚI DREPT, dar dacă noi
Să ne uităm la textul de interogare generat de constructor, vom vedea că tabelele
a schimbat locurile, dar conexiunea a rămas încă rămasă:
SELECT VT_Product.Product Code, VT_Product.Name, VT_Country.Country FROM VT_Country AS VT_Country LEFT JOIN VT_Product AS VT_Product BY VT_Product.Product Code = VT_Country.Product Code
Să vedem ce se întâmplă dacă debifăm ambele casete 
Drept urmare, obținem o conexiune internă.
SELECT VT_Product.Product Code, VT_Product.Name, VT_Country.Country FROM VT_Product AS VT_Product INTERNAL JOIN VT_Country AS VT_Country BY VT_Product.Product Code = VT_Country.Product Code
În cele din urmă, dacă ambele casete de selectare sunt bifate 
obținem o conexiune completă
SELECT VT_Product.Product Code, VT_Product.Name, VT_Country.Country FROM VT_Product AS VT_Product FULL CONNECTION VT_Country AS VT_Country BY VT_Product.Product Code = VT_Country.Product Code
Puteți specifica mai multe linii pe un marcaj Conexiuni. În acest caz, mai multe
rândurile sunt conectate prin condiție ȘI. În plus, liniile nu sunt necesare
conduce din nou de fiecare dată. Ele pot fi copiate folosind cheia F9.
Și în noua linie, schimbați doar condiția de conectare. Acest lucru accelerează semnificativ dezvoltarea.
De asemenea, în condiția linkului nu este necesar să folosiți doar câmpurile predefinite de la
liste derulante. Puteți folosi o expresie arbitrară care satisface
Limbajul de interogare 1C. Pentru a face acest lucru, trebuie să bifați caseta gratuit
și introduceți condiția direct în câmp sau deschideți o fereastră auxiliară
unde puteți utiliza șabloane cu funcții de limbaj de interogare. 
Desigur, în practică există interogări mult mai complexe unde
mai multe tabele cu diverse legături între ele. Dar în generatorul de interogări
pot fi reproduse conexiuni de orice complexitate.
Designerul de interogări este format din următoarele file:
1. „Tabele și câmpuri” - există trei liste ierarhice pe filă:
A. „Bază de date” - listează toate obiectele disponibile la care se poate face o interogare. De asemenea, butonul „Afișează tabele de schimb”, cu care puteți accesa tabele de modificări ale obiectelor de securitate a informațiilor dacă acestea sunt înregistrate pentru orice plan de schimb.
b. „Tabele” - o listă de tabele selectate la care va fi executată interogarea. De asemenea, în această fereastră puteți șterge un tabel, redenumi sau înlocui un tabel și adăugați o interogare internă.
Puteți aloca parametri pentru tabele virtuale făcând clic pe butonul „Parametri tabele virtuale”:
Se recomandă utilizarea activă a parametrilor tabelelor virtuale pentru selecția după anumite dimensiuni, deoarece acest lucru crește viteza de execuție a interogărilor. Puteți utiliza variabile externe în parametri, ale căror nume sunt precedate de semnul „&”.
c. „Câmpuri” - o listă de câmpuri care sunt selectate din tabele. De asemenea, puteți adăuga câmpuri calculate; pentru a face acest lucru, făcând clic pe butonul „Adăugați” se deschide constructorul de expresii personalizate:
În stânga este o fereastră cu câmpurile disponibile în expresie. În dreapta este un indiciu al funcțiilor utilizate. Mai jos este o expresie arbitrară construibilă. Puteți utiliza parametri externi în expresii; aceștia sunt notați prin semnul „&”, de exemplu: &Period, &StartDate
Trebuie să fiți atenți, dacă în fereastră este introdusă o expresie lungă și complexă, care conține o mică eroare de sintaxă, atunci după ce faceți clic pe butonul „OK”, sistemul va emite un avertisment și va închide fereastra. Tot codul tastat se va pierde, așa că vă recomand ca, dacă nu sunteți sigur de corectitudinea expresiei, să salvați întotdeauna conținutul în clipboard (Ctrl-C) înainte de a închide constructorul.
2. „Relații” - pe filă sunt indicate conexiunile între tabele.
Tabelul indică tabelele care trebuie legate, relația dintre tabelele care trebuie legate și starea conexiunii. Dacă condiția de conectare este complexă, atunci puteți specifica o anumită expresie calculată și se va deschide constructorul de câmp personalizat.
3. „Grupare” - fila indică ce câmpuri sunt grupate și care sunt agregate (însumate).
4. Fila „Condiții” - listează condițiile care sunt impuse cererii.
În condiții, puteți scrie și expresii complexe folosind constructorul de expresii simple și folosind variabile externe:
5. „Avansat”
Parametri suplimentari impusi cererii
6. „Asociații și pseudonime”
În această filă puteți atribui aliasuri pentru câmpuri, precum și gestionați interogări care sunt conectate prin constructele „UNITE” sau „UNITE ALL”.
7. „Comanda”
În ce ordine vor fi afișate rezultatele interogării?
Atenţie! În partea de jos a marcajului, puteți vedea o bifă "Comandă automată"- în versiunea actuală a 1C 8.1 în ACS, este inutil; în plus, atunci când caseta de selectare este bifată, la înregistrare, ACS dă o eroare, deci nu ar trebui să-l folosești.
8. „Compoziția datelor”
Fila în care sunt definite câmpurile de servicii pentru sistemul de control acces. Joacă aproximativ același rol ca fila „Generator de rapoarte” într-un designer de rapoarte obișnuit.
A. În fila „Tabele” - sunt listate tabelele utilizate în interogare, puteți indica dacă tabelul trebuie inclus în interogare bifând caseta de selectare „Necesar”. Acestea. dacă nu sunt incluse câmpuri în selecție, atunci acest tabel nu participă deloc la interogare. De asemenea, puteți specifica parametrii pentru tabele.
În procesul de configurare a sistemului de control al accesului, specificăm orice selecție, apoi toate valorile de selecție vor fi înlocuite în parametrii tabelelor virtuale, ceea ce din nou ne va ajuta să optimizăm și să accelerăm interogarea.
b. În fila „Câmpuri”, sunt listate câmpurile și aliasurile lor care vor fi adăugate la lista câmpurilor ACS.
c. „Condiții” - dacă selecțiile sunt specificate în setările ACS, toate valorile de selecție vor fi adăugate ca condiții suplimentare; expresii complexe pot fi, de asemenea, adăugate la condiții.
9. „Caracteristici”
Un marcaj care nu are analog în constructorul obișnuit al formei de ieșire.
Această filă vă permite să extindeți activitatea interogărilor cu caracteristici. Tabelul din filă este format din mai multe câmpuri:
A. „Tipul valorii” - tipul pentru care vor fi selectate caracteristicile. De exemplu, dacă specificați „Directory Link.Nomenclature”, atunci toate caracteristicile pentru nomenclatură vor fi selectate în interogare.
b. „Sursă” - sursa pentru proprietățile tipurilor caracteristice, poate fi o interogare sau un tabel. În acest câmp putem scrie o solicitare pentru a selecta doar acele proprietăți de care avem nevoie.
c. „Lista de caracteristici” - un câmp în care este indicată sursa proprietăților caracteristicilor. Cel mai adesea acesta este un plan de tipuri caracteristice sau o cerere. De asemenea, trebuie să specificați câmpurile care sunt responsabile pentru „Identificatorul”, „Numele” și „Tipul” proprietății.
d. „Sursa” este următorul câmp în care indicăm sursa valorilor caracteristice, care poate fi, de asemenea, fie un tabel, fie o interogare.
e. „Valoare caracteristică” este un tabel sau o interogare care primește valori caracteristice. De exemplu, registrul de informații „ObjectPropertyValues” poate servi ca un tabel cu valorile caracteristicilor. De asemenea, trebuie să indicăm acele câmpuri din tabel (sau interogare) care sunt responsabile pentru „Obiect”, „Proprietate” și „Valoare” caracteristicii.
După editarea cererii, textul solicitării poate fi văzut în fereastra de sub lista de câmpuri. Mai jos, cu caseta de selectare „Completare automată”, putem reglementa completarea parametrilor suplimentari pentru câmpurile specificate în cerere. Vă rugăm să rețineți că componența câmpurilor este determinată doar în cererea în sine.
Informatii preluate de pe site
Astăzi vom vorbi despre cum se face interogări imbricate folosind generator de interogări. Să trecem direct la un exemplu.
Să presupunem că avem acest registru simplu de informații, în care prețurile sunt stocate de mărfuri și furnizori:
Dorim să solicităm să primim toate produsele care au mai mult de un furnizor. Acest lucru poate fi implementat folosind următoarea interogare:
SELECTARE Număr de Furnizori.Produs CA Produs FROM (SELECT Preț.Produs CA Produs, CANTITATE(Preț DIFERIT.Furnizor) CA Furnizori FROM RegisterInformation.Preț AS Preț GROUP BY Preț.Produs) AS Număr de Furnizori WHERE Număr de Furnizori.Furnizori > 1
Formarea unei interogări imbricate în constructor
Să creăm cererea de mai sus folosind constructorul.
Pentru a face acest lucru, în panoul de comandă de deasupra câmpului Mese apasa butonul Creați o subinterogare:
După care se va deschide o fereastră cu o altă instanță a constructorului de interogare: 
Și în această nouă fereastră construim o interogare imbricată: 
Făcând clic pe butonul CerereÎn colțul din stânga jos putem vedea textul subinterogării: 
După ce facem clic pe butonul OK din constructorul auxiliar, obținem următoarea imagine în fereastra principală: 
Din moment ce fraza NestedQuery nu foarte convenabil pentru percepție, să folosim butonul drept al mouse-ului pentru a redenumi tabelul în Numărul de furnizori, selectați un câmp din acesta Produs iar pe marcaj Condiții Să notăm condiția necesară: 
Și după toate aceste manipulări, primim cererea dorită. Dacă este necesar, puteți crea interogări cu mai multe niveluri de imbricare.
Cum se face o interogare imbricată dintr-o interogare obișnuită în constructor
Foarte des apare o situație când începi să faci o cerere în constructor și la un moment dat realizezi că trebuie imbricată. Desigur, în exemplul nostru nu există nicio problemă - puteți pur și simplu să ștergeți totul și să reemiteți cererea. Dar, în practică, există exemple mult mai complexe, de exemplu, cu mai multe niveluri de cuibărit, când s-au petrecut câteva ore pentru a face cererea. Și în acest caz există o cale de ieșire destul de simplă. Puteți utiliza editorul de text de interogare încorporat în designer. Trebuie să folosiți un buton Cerere obțineți textul solicitării (vezi imaginea de mai sus) și copiați-l în clipboard. Apoi, creați o nouă interogare imbricată și apăsați din nou butonul Cerere, lipiți textul din buffer, faceți clic pe OK. În consecință, ștergem vechea cerere la nivelul superior. În acest fel, dacă este necesar, putem crea cu ușurință interogări imbricate pe mai multe niveluri din mers.
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.
Cometariu.
Din păcate, într-o aplicație gestionată, nu puteți utiliza designerul de interogări în procesarea „Fă cunoștință cu interogarea”. Îl puteți folosi în această procesare trecând la modul normal, dar nu vom face acest lucru.
Să creăm procesarea „Constructor de solicitări” și să o definim în subsistemul „Rapoarte și procesare”.
Să creăm un formular de procesare și să adăugăm în el atributul formularului „TabDoc” de tip „Document tabelar”, precum și comanda „Run Query” cu acțiunea „Run Query”. Apoi, trageți-le în formular.
În modulul formular, pentru ca comanda să funcționeze, scriem o procedură:
&OnClient
Procedura Executare interogare (comandă)
ExecuteRequestServer();
Sfârșitul procedurii
&Pe server
Sfârșitul procedurii
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 - „PREPRESENTATION (Product ReceiptProducts.Nomenclature)”
Î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”.
Practică. Faceți clic pe butonul „OK” și verificați procesarea noastră în modul utilizator. Dacă analizați datele primite la executarea 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.
La definirea grupărilor, 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).
Figura 2.70 Generatorul de interogări
Dacă datele primite prin cerere trebuie selectate în funcție de o anumită condiție, atunci în acest caz poate fi necesar să folosiți fila „Condiții”. Să selectăm Buns ReceiptGoods.Quantity=10 (Figura 2.71).
Figura 2.71 Condiția constructorului de interogare.
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 schimba numele câmpurilor setând „Aliasuri”, dar nu vom face acest lucru.
În fila „Comandă”, puteți determina 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.
Este posibil să se specifice 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:
&Pe server
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 =
| Recepția mărfurilor Mărfuri Nomenclatura AS Nomenclatura,
| 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
| Primirea mărfurilor Mărfuri. 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
