1s 8 cere reprezentare. Caracteristici de lucru cu câmpul Reprezentare și funcția Reprezentare() a limbajului de interogare

Să ne uităm la restul acum.

Funcții pentru lucrul cu șiruri în interogări 1C

Există puține funcții și operatori pentru a lucra cu date șiruri în interogări 1C.

În primul rând, pot fi adăugate șiruri în interogări. Operatorul „+” este folosit pentru aceasta:

Cerere. Text="SELECT
" "Linie: " " + Sursă.Nume
;

În al doilea rând, puteți selecta o parte din șir. Pentru a face acest lucru, utilizați funcția SUBSTRUCȚIE. Funcția este similară cu limbajul încorporat 1C. Are trei variante:

Șir sursă.
Numărul caracterului de la care ar trebui să înceapă șirul selectat.
Personaje.

Cerere. Text= "ALEGE
SUBSTRING(""Linie:" ", 4, 3) ca rezultat"; // Rezultat: ochi

Funcţie ISNULL

NULL este un tip de date special pe platforma 1C:Enterprise. Este, de asemenea, singura valoare posibilă de acest tip. NULL poate apărea în interogări în mai multe cazuri: la conectarea surselor de interogare, dacă nu a fost găsită o valoare corespunzătoare într-unul dintre tabele; la accesarea detaliilor unui obiect inexistent; dacă a fost specificat NULL în lista câmpurilor de interogare (de exemplu, la combinarea rezultatelor selecției din mai multe tabele), etc.

Pentru că NULL nu este nici nul, nici șirul gol, nici măcar o valoare Nedefinit, este adesea util să îl înlocuiți cu un tip de date mai util. Pentru asta este concepută funcția. ISNULL.

Are doi parametri:

Valoarea care se verifică.
Valoarea cu care trebuie înlocuit primul parametru dacă este NULL.

Cerere. Text= "ALEGE
ISNULL(Source.Remainder, 0) AS Remainder"; // Dacă în urma solicitării câmpul rest=NULL,
// apoi va fi înlocuit cu 0 și se vor putea efectua operații matematice cu acesta

Funcții PERFORMANŢĂȘi INTRODUCERE LEGĂTURĂ

Aceste funcții sunt concepute pentru a obține reprezentări în șir de diferite valori. Adică convertesc referințe, numere, booleeni etc. în text simplu. Diferența dintre ele este că funcția PERFORMANŢĂ convertește orice tip de date în text (șir) și funcția INTRODUCERE LEGĂTURĂ- numai linkuri și returnează valorile rămase așa cum sunt, neconvertite.

Cerere. Text= "ALEGE
REPREZENTARE(ADEVĂRAT) CA Boolean,
REPREZENTARE (4) ca număr,
REPREZENTARE (Source.Link) AS Link,
REPREZENTARE(DATETIME(2016,10,07)) AS Data";
// Boolean = „Da”, Număr = „4”, Legătură = „Document Comandă de primire numerar Nr.... de la...”
// Data="07.10.2016 0:00:00"

Cerere. Text= "ALEGE
REPRESENTATIONREFERENCE(TRUE) CA Boolean,
REPREZENTARE REFERINȚĂ(4) CA NUMĂR
PRESENTINGLINK(Source.Link) AS Link,
REPRESENTATIONREFERENCE(DATETIME(2016,10,07)) AS Data";
// Boolean = ADEVĂRAT, Număr = 4, Link = "Document Comandă de primire numerar Nr.... de la..."
// Data=07.10.2016 0:00:00

Funcții TIPȘi VALORI DE TIP

Funcţie TIP returnează tipul de date al platformei 1C:Enterprise.

Cerere. Text= "ALEGE
TIP (număr)
TYPE (șir),
TIP (Document. Ordin de numerar pentru cheltuieli)";

Funcţie VALORI DE TIP returnează tipul valorii transmise acestuia.

Cerere. Text= "ALEGE
VALORI TIP (5) AS Număr,
TIP (""Linia" ") AS String,
TYPE (Source.Link) AS Referință
Din Directory.Source AS Source";
//Număr=Număr, String=Șir, Director = DirectoryLink.Source

Aceste funcții sunt convenabile de utilizat, de exemplu, atunci când trebuie să aflați dacă un câmp primit într-o solicitare este o valoare de un anumit tip. De exemplu, să obținem informațiile de contact ale contrapărților din registrul de informații ContactInformation (acolo sunt stocate contactele nu numai ale contrapărților, ci și ale organizațiilor, persoanelor fizice etc.):

Cerere. Text= "ALEGE

DIN

UNDE
VALUES TYPE(ContactInformation.Object) = TYPE(Directory.Counterparties)";

Funcţie SENS

Funcţie Sens vă permite să utilizați obiecte de configurare 1C direct într-o solicitare, fără a utiliza .

Să mai adăugăm o condiție la exemplul anterior. Trebuie doar să obțineți numerele de telefon ale contrapărților dvs.

Cerere. Text= "ALEGE
Informații de contact.Introducere
DIN
Registrul de informații Informații de contact CUM Informații de contact
UNDE
VALUES TYPE(ContactInformation.Object) = TYPE(Directory.Counterparties)
AND ContactInfo.Type = VALUE(Enum.ContactInfoTypes.Phone)";

Trebuie remarcat faptul că această funcție poate fi utilizată numai cu valori predefinite, adică. cu valori care pot fi accesate direct din configurator. Adică funcția SENS nu poate fi folosit cu elemente de director create de utilizatori, dar poate lucra cu enumerari, cu elemente de director predefinite, cu valori EmptyLink.

Operator LEGĂTURĂ

Operator LEGĂTURĂ este conceput pentru a verifica valorile returnate de o solicitare pentru a vedea dacă aparțin unui anumit tip de referință. Aceeași sarcină poate fi îndeplinită folosind funcții TIPȘi VALORI DE TIP(care au un domeniu mai larg și au fost discutate mai sus).

De exemplu, sarcina de selectare a informațiilor de contact pentru contrapărți ar putea fi rezolvată astfel:

Cerere. Text= "ALEGE
Informații de contact.Introducere
DIN
Registrul de informații Informații de contact CUM Informații de contact
UNDE
ContactInformation.Object LINK Directory.Contrapartide";

Operator EXPRES

Operator EXPRES utilizat în interogări 1C în două cazuri:

când trebuie să modificați caracteristicile unui tip primitiv;
când este necesar să se realizeze un câmp cu un singur tip dintr-un câmp cu un tip de date compus.

Tipurile de date primitive includ: număr, șir, dată, boolean. Unele dintre aceste tipuri de date au caracteristici suplimentare. Tip Număr are lungime si precizie, tip linie - lungime sau nelimitat.

Operator EXPRES vă permite să schimbați nu tipul de date, ci caracteristicile suplimentare. De exemplu, el poate transforma un șir cu lungime nelimitată într-un șir cu lungime limitată. Acest lucru poate fi util dacă trebuie să grupați rezultatele interogării după un astfel de câmp. Nu puteți grupa după câmpuri cu o lungime nelimitată, așa că îl convertim într-un șir cu o lungime de 200 de caractere.

Cerere. Text= "ALEGE
CANTITATE (Sosire diferită de bunuri și servicii. Link) AS Link
DIN
Document.Recepția Bunurilor și Serviciilor CUM Primirea Bunurilor și Serviciilor
A SE GRUPA CU
EXPRESS(Primirea bunurilor și serviciilor. Comentariu AS ROW (200))";

În unele cazuri, interogările către câmpuri cu un tip de date compus pot să nu fie procesate optim de platforma 1C. Acest lucru are ca rezultat timpi de interogare mai lungi, deci poate fi util să convertiți în avans un tip compus într-un singur tip.

Cerere. Text= "ALEGE
EXPRESS(Mișcarea mărfurilor. Cifra de afaceri. Comanda ca document. Comanda clientului).Data AS Data comenzii,
Mişcarea mărfurilor Cifra de afaceri.Nomenclatură
DIN
Registrul de acumulare Mișcarea mărfurilor Cifra de afaceri AS Mișcarea Mărfurilor Cifra de afaceri
UNDE
Mișcarea rulajelor de mărfuri. Comanda LINK Document. Comanda Clientului";

Operatori ALEGEREȘi ESTE NUL

Operator ALEGERE similar cu operatorul DACĂîn limbajul 1C încorporat, dar are o funcționalitate oarecum trunchiată.

Să presupunem că dorim să primim informații de contact din registrul de informații ContactInformation și, în același timp, să indicăm într-un câmp separat de solicitare dacă aparține unei contrapărți sau unei persoane fizice.

Cerere. Text= "ALEGE
Informații de contact. Reprezentare,
ALEGERE
WHEN VALUE TYPE(ContactInformation.Object) = TYPE(Catalog.Accounts)
APOI " Contrapartidă "
ALTA ALEGERE
WHEN VALUES TYPE(ContactInformation.Object) = TYPE(Directory.Individuals)
APOI " Individual"
ELSE "Altul" "
Sfârşit
TERMINĂ CA PROPRIETAR
DIN
Registrul informațiilor. Informații de contact AS Informații de contact";

După cum se vede din exemplu, în design ALEGERE există întotdeauna o condiție după cuvânt CÂND; valoare aplicată dacă condiția este adevărată după cuvânt APOIși valoarea aplicată dacă condiția nu este îndeplinită, după cuvânt IN CAZ CONTRAR. Toate cele trei elemente de design ALEGERE sunt obligatorii. Omite element IN CAZ CONTRAR, la fel ca atunci când utilizați operatorul DACĂîn limbajul 1C încorporat, este imposibil. Tot de la operator ALEGERE nu există un analog al designului ELSEIF, dar poți investi unul ALEGEREîn altul, așa cum sa făcut în exemplul nostru.

Operator ESTE NUL folosit în proiectare ALEGERE pentru a compara un câmp de interogare cu tipul NULL.

Cerere. Text= "ALEGE
ALEGERE
CÂND VALOAREA ESTE NULĂ, atunci 0
ELSE Sens
SFÂRŞIT";

În plus, operatorul ESTE NUL poate fi folosit în condiții de interogare, de exemplu într-o propoziție UNDE.

Limbajul de interogare este unul dintre mecanismele fundamentale ale 1C 8.3 pentru dezvoltatori. Folosind interogări, puteți prelua rapid orice date stocate în baza de date. Sintaxa sa este foarte asemănătoare cu SQL, dar există unele diferențe.

Principalele avantaje ale limbajului de interogare 1C 8.3 (8.2) față de SQL:

dereferențiarea câmpurilor de referință (referirea unuia sau mai multor puncte la detalii despre obiect);
lucrul cu rezultate este foarte convenabil;
capacitatea de a crea tabele virtuale;
cererea poate fi scrisă atât în engleză, cât și în rusă;
capacitatea de a bloca datele pentru a evita blocajele.

Dezavantajele limbajului de interogare în 1C:

spre deosebire de SQL, interogările în 1C nu permit modificarea datelor;
lipsa procedurilor stocate;
imposibilitatea de a converti un șir într-un număr.

Să aruncăm o privire la mini-tutorialul nostru despre constructele de bază ale limbajului de interogare 1C.

Datorită faptului că interogările din 1C vă permit doar să primiți date, orice interogare trebuie să înceapă cu cuvântul „SELECT”. După această comandă sunt indicate câmpurile din care trebuie obținute datele. Dacă specificați „*”, toate câmpurile disponibile vor fi selectate. Locul din care vor fi selectate datele (documente, registre, directoare etc.) este indicat după cuvântul „DIN”.

În exemplul discutat mai jos, numele întregii nomenclaturi sunt selectate din directorul „Nomenclatură”. După cuvântul „CUM”, sunt indicate pseudonimele (numele) pentru tabele și câmpuri.

ALEGE
Nomenclatură Nume AS Numele Nomenclaturii
DIN
Director.Nomenclatura AS Nomenclatura

Lângă comanda „SELECT” puteți specifica cuvinte cheie:

VARIAT. Interogarea va selecta numai rânduri care diferă în cel puțin un câmp (fără duplicate).
Primul N, Unde n– numărul de rânduri de la începutul rezultatului care trebuie selectat. Cel mai adesea, această construcție este utilizată împreună cu sortarea (ORDER BY). De exemplu, atunci când trebuie să selectați un anumit număr de documente care sunt recente după dată.
PERMIS. Acest design vă permite să selectați din baza de date numai acele înregistrări care sunt disponibile utilizatorului curent. Pe baza utilizării acestui cuvânt cheie, utilizatorul va primi un mesaj de eroare atunci când încearcă să interogheze înregistrările la care nu are acces.

Aceste cuvinte cheie pot fi folosite împreună sau separat.

PENTRU SCHIMBARE

Această propunere blochează datele pentru a preveni conflictele reciproce. Datele blocate nu vor fi citite de la o altă conexiune până la încheierea tranzacției. În această clauză, puteți specifica anumite tabele care trebuie blocate. În caz contrar, toată lumea va fi blocată. Designul este relevant doar pentru modul de blocare automată.

Cel mai adesea, clauza „PENTRU SCHIMBARE” este folosită la primirea soldurilor. La urma urmei, atunci când mai mulți utilizatori lucrează în program simultan, în timp ce unul primește solduri, altul le poate schimba. În acest caz, restul rezultat nu va mai fi corect. Dacă blocați datele cu această propunere, atunci până când primul angajat primește soldul corect și efectuează toate manipulările necesare cu acesta, al doilea angajat va fi obligat să aștepte.

ALEGE
Acorduri reciproce. Salariat,
Decontări reciproce.Cuantumul decontărilor reciproce Sold
DIN
Registrul Acumulărilor.Decontări reciproce cu angajații.Solduri AS Decontări reciproce
PENTRU SCHIMBARE

UNDE

Designul este necesar pentru a impune un fel de selecție asupra datelor încărcate. În unele cazuri de obținere a datelor din registre, este mai rezonabil să se specifice condițiile de selecție în parametrii tabelelor virtuale. Când utilizați „UNDE”, toate înregistrările sunt preluate mai întâi și numai apoi se aplică selecția, ceea ce încetinește semnificativ interogarea.

Mai jos este un exemplu de solicitare de a obține persoane de contact pentru o anumită poziție. Parametrul de selecție are formatul: &ParameterName (numele parametrului este arbitrar).

SELECTARE (CAZ)

Designul vă permite să specificați condiții direct în corpul cererii.

În exemplul de mai jos, „AdditionalField” va conține text în funcție de dacă documentul este postat sau nu:

ALEGE
AdmitereT&U.Link,
ALEGERE
CÂND AdmitereaT&U.Efectuat
ATUNCI „Documentul a fost aprobat!”
ELSE „Documentul nu a fost postat...”
TERMINAȚI CA SuplimentarField
DIN
Document. Primirea Bunurilor și Serviciilor CUM Primirea T&C

A TE ALATURA

Îmbinările leagă două tabele pe baza unei anumite condiții de relație.

ALĂTURAȚI STÂNGA/DREAPTA

Esența îmbinării LEFT este că primul tabel specificat este luat în întregime, iar al doilea este atașat la acesta de condiția conexiunii. Dacă nu există înregistrări care să corespundă primului tabel din al doilea, atunci NULL este înlocuit ca valorile lor. Mai simplu spus, tabelul principal este primul tabel specificat, iar datele celui de-al doilea tabel (dacă există) sunt deja înlocuite cu datele acestuia.

De exemplu, trebuie să obțineți articole din documentele „Recepție de bunuri și servicii” și prețuri din registrul de informații „Prețuri articole”. În acest caz, dacă prețul oricărei poziții nu este găsit, înlocuiți NULL. Toate articolele din document vor fi selectate indiferent dacă au un preț sau nu.

ALEGE
Nomenclatură de primire,
Preturi.Pret
DIN
Document. Primirea Bunurilor și Serviciilor. Bunuri CUM Primirea T&C
INNER JOIN
Software Receipt&U.Nomenclature = Prices.Nomenclature

ÎN DREPT totul este exact invers.

CONEXIUNE COMPLETA

Acest tip de îmbinare diferă de cele anterioare prin faptul că toate înregistrările primului tabel și ale celui de-al doilea vor fi returnate ca rezultat. Dacă nu se găsesc înregistrări în primul sau al doilea tabel pentru condiția de legătură specificată, va fi returnat NULL.

Când utilizați îmbinarea completă în exemplul anterior, vor fi selectate toate articolele din documentul de primire a bunurilor și serviciilor și toate cele mai recente prețuri din registrul prețurilor articolelor. Valorile înregistrărilor negăsite, atât în primul, cât și în cel de-al doilea tabel, vor fi NULL.

INNER JOIN

Diferența dintre o îmbinare INNER și o îmbinare COMPLETĂ este că, dacă o înregistrare nu este găsită în cel puțin unul dintre tabele, atunci interogarea nu o va afișa deloc. Ca urmare, vor fi selectate doar acele articole din documentul de Primire Bunuri și Servicii pentru care există înregistrări în registrul de informații Prețuri Articole, dacă în exemplul anterior înlocuim FULL cu INTERN.

A SE GRUPA CU

Gruparea în interogări 1C vă permite să restrângeți rândurile de tabel (câmpuri de grupare) conform unei anumite caracteristici comune (câmpuri de grupare). Câmpurile de grupare pot fi afișate numai folosind funcții de agregare.

Rezultatul următoarei interogări va fi o listă de tipuri de articole cu prețurile lor maxime.

ALEGE
,
MAX(Preț.Preț) AS Preț
DIN

A SE GRUPA CU
Preturi.Nomenclatura.Tipul Nomenclatorului

REZULTATE

Spre deosebire de grupare, atunci când se utilizează totaluri, toate înregistrările sunt afișate și rândurile totale sunt deja adăugate la acestea. Gruparea afișează numai înregistrări generalizate.

Rezultatele pot fi rezumate pentru întregul tabel (folosind cuvântul cheie „GENERAL”), pentru mai multe câmpuri, pentru câmpuri cu structură ierarhică (cuvinte cheie „IERARHIE”, „NUMAI IERARHIE”). La rezumarea rezultatelor, nu este necesar să folosiți funcții agregate.

Să ne uităm la un exemplu similar cu cel de mai sus folosind gruparea. În acest caz, rezultatul interogării va returna nu numai câmpuri grupate, ci și înregistrări detaliate.

ALEGE
Prețuri.Nomenclatură.Tip de nomenclatură AS Tip de nomenclatură,
Preturi.Pret AS Pret
DIN
Registrul de informații Prețurile Nomenclatorului Instantaneu al celor mai recente prețuri AS
REZULTATE
MAXIMUM(Preț)
DE
TypeNomenclature

AVÂND

Acest operator este similar cu operatorul WHERE, dar este folosit doar pentru funcții agregate. Câmpurile rămase, cu excepția celor utilizate de acest operator, trebuie grupate. Operatorul WHERE nu este aplicabil funcțiilor agregate.

În exemplul de mai jos, prețurile maxime ale unui articol sunt selectate dacă depășesc 1000, grupate după tipul articolului.

ALEGE

MAX(Preț.Preț) AS Preț
DIN
Registrul de informații Prețurile Nomenclatorului Instantaneu al celor mai recente prețuri AS
A SE GRUPA CU
Preturi.Nomenclatura.Tipul Nomenclatorului
AVÂND
MAXIM(Prețuri.Preț) > 1000

FILTREAZĂ DUPĂ

Operatorul ORDER BY sortează rezultatul unei interogări. Pentru a vă asigura că înregistrările sunt afișate într-o ordine consecventă, se utilizează COMANDA AUTOMATĂ. Tipurile primitive sunt sortate după regulile obișnuite. Tipurile de referință sunt sortate după GUID.

Un exemplu de obținere a unei liste de angajați sortați după nume:

ALEGE
Angajații.Nume AS Nume
DIN
Director.Angajați CUM Angajații
FILTREAZĂ DUPĂ
Nume
COMANDA AUTOMATA

Alte constructe de limbaj de interogare 1C

COMBINA– rezultatele a două interogări într-una.
COMBINA TOTUL– similar cu COMBINE, dar fără a grupa rânduri identice.
MASĂ GOLĂ– folosit uneori la alăturarea interogărilor pentru a specifica un tabel imbricat gol.
LOC– creează un tabel temporar pentru a optimiza interogările complexe 1C. Astfel de solicitări se numesc solicitări în lot.

Caracteristicile limbajului de interogare

SUBSTRING trunchiază un șir dintr-o poziție specificată la un număr specificat de caractere.
AN... AL DOILEA vă permit să obțineți valoarea selectată a unui tip numeric. Parametrul de intrare este data.
ÎNCEPUTUL PERIOADEI și sfârșitul perioadei utilizat atunci când se lucrează cu date. Tipul perioadei (ZI, LUNA, AN etc.) este indicat ca parametru suplimentar.
ADDKDATE vă permite să adăugați sau să scădeți o oră specificată de un anumit tip dintr-o dată (SECOND, MINUT, DAY etc.).
DATA DIFERENTATA determină diferența dintre două date, indicând tipul valorii de ieșire (ZI, AN, LUNA etc.).
ISNULLînlocuiește valoarea lipsă cu expresia specificată.
REPREZENTARE și REPRESENTATIONLINKS obține o reprezentare șir a câmpului specificat. Aplicați oricăror valori și, respectiv, numai valorilor de referință.
TIP, TIP VALOARE sunt utilizate pentru a determina tipul parametrului de intrare.
LEGĂTURĂ este un operator logic de comparare pentru tipul de valoare de atribut.
EXPRES folosit pentru a converti o valoare în tipul dorit.
DATA ORA primește o valoare de tip „Data” din valorile numerice (Anul, Luna, Ziua, Ora, Minutul, Secunda).
SENSîntr-o solicitare 1C, este folosit pentru a specifica valori predefinite - directoare, enumerari, planuri pentru tipuri de caracteristici. Exemplu de utilizare: " Unde Persoană juridică = Valoare (Enumerare. Persoană juridică. Persoană fizică)«.

Generator de interogări

Pentru a crea interogări cu 1C, există un mecanism încorporat foarte convenabil - designerul de interogări. Conține următoarele file principale:

„Tabele și câmpuri” - conține câmpurile care trebuie selectate și sursele acestora.
„Conexiuni” - descrie condițiile pentru structura CONEXIUNE.
„Gruparea” - conține o descriere a construcțiilor grupărilor și câmpurile rezumate după acestea.
„Condiții” - este responsabil pentru selectarea datelor din cerere.
„Avansat” - parametri suplimentari de interogare, cum ar fi cuvintele cheie ale comenzii „SELECT” etc.
„Joins / Aliases” - sunt indicate posibilitățile de îmbinare a tabelelor și sunt setate aliasuri (constructia „CUM”).
„Comanda” este responsabil pentru sortarea rezultatului interogărilor.
„Totale” - similar cu fila „Grupare”, dar este folosit pentru construcția „TOTALURI”.

Textul cererii în sine poate fi vizualizat făcând clic pe butonul „Solicitare” din colțul din stânga jos. În acest formular, poate fi corectat manual sau copiat.

Consola de interogări

Pentru a vizualiza rapid rezultatul unei interogări în modul „Enterprise” sau pentru a depana interogări complexe, utilizați . Textul de interogare este scris în el, parametrii sunt setați și rezultatul acestuia este afișat.

Puteți descărca consola de interogări pe discul ITS sau prin .

Programarea 1C constă în mai mult decât scrierea unui program. 1C este un lingot de acțiuni ale utilizatorului și date cu care lucrează.

Datele sunt stocate într-o bază de date. Interogările 1C sunt o modalitate de a prelua date dintr-o bază de date pentru a le arăta utilizatorului într-un formular sau pentru a le procesa.

Partea fundamentală a raportului este cererea 1C. În cazul unui raport, ACS este cea mai mare parte a raportului.

Aşezaţi-vă. Ia o pauza. Calma. Acum o să vă spun vestea.

Pentru a programa în 1C, nu este suficient să cunoașteți limbajul de programare 1C. De asemenea, trebuie să cunoașteți limbajul de interogare 1C.

Limbajul de interogare 1C este un limbaj complet separat care ne permite să specificăm ce date trebuie să obținem din baza de date.

El este și bilingv - adică poți scrie în rusă sau engleză. Este extrem de asemănător cu limbajul de interogare SQL și cei care îl cunosc se pot relaxa.

Cum sunt utilizate cererile 1C

Când un utilizator lansează 1C în modul Enterprise, nu există niciun gram de date în clientul care rulează. Prin urmare, atunci când trebuie să deschideți un director, 1C solicită date din baza de date, adică face o cerere 1C.

Interogările 1C sunt:

Interogări automate 1C
Generat automat de sistem. Ați creat un formular de listă de documente. S-a adăugat o coloană. Aceasta înseamnă că atunci când deschideți acest formular în modul Enterprise, va exista o interogare și datele pentru această coloană vor fi solicitate.
Interogări semi-automate 1C
Există multe metode (funcții) în limbajul 1C, atunci când este accesat, se face o interogare la baza de date. De exemplu.GetObject()
Interogări manuale 1C (scrise de programator special ca interogare)
Puteți scrie singur o solicitare 1C în cod și o puteți executa.

Crearea și executarea interogărilor 1C

O solicitare 1C este textul real al cererii în limba de solicitare 1C.
Textul poate fi scris cu pixuri. Adică ia-l și scrie-l (dacă știi această limbă).

Deoarece 1C promovează conceptul de programare vizuală, unde se poate face mult sau aproape totul fără a scrie codul manual, există un obiect special Query Constructor care vă permite să desenați textul unei interogări fără a cunoaște limbajul de interogare. Cu toate acestea, miracolele nu se întâmplă - pentru aceasta trebuie să știți cum să lucrați cu constructorul.

Odată ce textul cererii 1C este gata, acesta trebuie să fie executat. În acest scop există un obiect în codul 1C Request(). Iată un exemplu:

După cum puteți vedea în exemplu, după executarea cererii 1C, rezultatul vine la noi și trebuie să-l procesăm. Rezultatul este unul sau mai multe rânduri ale tabelului (într-o formă specială).

Rezultatul poate fi încărcat într-un tabel obișnuit:
Preluare = Query.Run().Unload(); //Rezultat – tabel de valori

Sau pur și simplu ocolește rând cu rând.
Selectare = Query.Run().Select();
While Select.Next() Loop
//Fă ceva cu rezultatele interogării
EndCycle;

Lucrul cu solicitări 1C

Principiile de bază ale interogărilor 1C

Principii de bază ale construirii unei cereri 1C -
SELECTAȚI Lista câmpurilor din Titlul tabelului WHERE Condiții

Un exemplu de construire a unei astfel de cereri 1C:

ALEGE
//lista de câmpuri de selectat
Legătură,
Nume,
Cod
DIN
//numele tabelului din care selectăm datele
//lista de tabele este o listă de obiecte din fereastra configuratorului
Director.Nomenclatură
UNDE
//indică selecția
Tip produs = &Serviciu //selectare după valoare externă
Sau Serviciu // Atributul „Service” de tip Boolean, selecție după valoare True
FILTREAZĂ DUPĂ
//Triere
Nume

Lista tabelelor 1C

Puteți vedea numele tabelelor în fereastra configuratorului. Trebuie doar să scrieți „Directoar” în loc de „Directoare”, de exemplu „Directoar.Nomenclatură” sau „Document.Vânzări de bunuri și servicii” sau „Registrul de acumulare.Vânzări”.

Există tabele suplimentare (virtuale) pentru registre care vă permit să obțineți numerele finale.

Informații Register.RegisterName.Last Slice(&Date) – Solicitare 1C din registrul de informații, dacă este periodic, pentru o anumită dată

Registrul de acumulare.Nume registru.Solduri(&Data) – Solicitare 1C din registrul soldurilor pentru o anumita data

Registrul de acumulare. Nume registru. Cifra de afaceri (&Data de începere, &Data de încheiere) – Solicitare 1C din registrul cifrei de afaceri pentru perioada de la data de început până la data de încheiere.

Principii suplimentare

Când solicităm o listă cu unele date, principiile de bază funcționează. Dar putem solicita și numere și solicitarea le poate număra pentru noi (adăugați-le, de exemplu).

ALEGE
//Quantity(FieldName) – numără cantitatea
//Field AS OtherName – redenumește câmpul
Cantitate (Link) AS Cantitatea de documente postate
DIN

UNDE
Dirijată

Această solicitare 1C ne va returna numărul total de documente. Cu toate acestea, fiecare document are un câmp Organizație. Să presupunem că vrem să numărăm numărul de documente pentru fiecare organizație folosind o interogare 1C.

ALEGE
//doar un câmp de document
Organizare,
//numărați cantitatea
Cantitate(Link) AS CantitateBy Organizations
DIN
Document.Vânzări de Bunuri și Servicii
UNDE
Dirijată
A SE GRUPA CU

Organizare

Această solicitare 1C ne va returna numărul de documente pentru fiecare organizație (numită și „pe organizație”).

Să calculăm suplimentar suma acestor documente folosind o solicitare 1C:

ALEGE
//doar un câmp de document
Organizare,
//numărați cantitatea

//numărați suma

DIN
Document.Vânzări de Bunuri și Servicii
UNDE
Dirijată
A SE GRUPA CU
//trebuie folosit dacă lista de câmpuri are o funcție count() și unul sau mai multe câmpuri în același timp - atunci trebuie să grupați după aceste câmpuri
Organizare

Această solicitare 1C ne va returna și cantitatea de documente.

ALEGE
//doar un câmp de document
Organizare,
//numărați cantitatea
Cantitate(Link) AS CantitateBy Organizations,
//numărați suma
Amount(DocumentAmount) AS Sumă
DIN
Document.Vânzări de Bunuri și Servicii
UNDE
Dirijată
A SE GRUPA CU
//trebuie folosit dacă lista de câmpuri are o funcție count() și unul sau mai multe câmpuri în același timp - atunci trebuie să grupați după aceste câmpuri
Organizare
REZULTATE PO General

Limbajul de interogare 1C este extins și complex și nu vom lua în considerare toate capacitățile sale într-o lecție - citiți următoarele lecții.

Pe scurt despre caracteristicile suplimentare ale limbajului de interogare 1C:

Unirea datelor din mai multe tabele
Interogări imbricate
Solicitare lot
Crearea propriilor tabele virtuale
Interogare din tabelul de valori
Utilizarea funcțiilor încorporate pentru obținerea și manipularea valorilor.

1C Query Builder

Pentru a nu scrie manual textul cererii, există un designer de solicitări 1C. Doar faceți clic dreapta oriunde în modul și selectați 1C Query Designer.

Selectați tabelul dorit din stânga în designerul de interogări 1C și trageți-l la dreapta.

Selectați câmpurile necesare din tabel în designerul de interogări 1C și trageți spre dreapta. Dacă doriți nu numai să selectați un câmp, ci să îi aplicați un fel de funcție de însumare, după glisare, faceți clic pe câmp de două ori cu mouse-ul. În fila Grupare, va trebui apoi să selectați (trageți) câmpurile necesare pentru grupare.

Pe fila Condiții din designerul de interogări 1C, puteți selecta selecțiile necesare în același mod (prin tragerea câmpurilor prin care veți face selecția). Asigurați-vă că selectați condiția corectă.

În fila Comandă este indicată sortarea. Pe fila Rezultate – însumând rezultatele.

Folosind designerul de interogări 1C, puteți studia orice interogare existentă. Pentru a face acest lucru, faceți clic dreapta pe textul unei cereri existente și selectați, de asemenea, 1C query designer - iar cererea va fi deschisă în 1C query designer.

Am decis să-mi aduc contribuția și să descriu acele trăsături ale limbajului care nu au fost discutate în articolele de mai sus. Articolul se adresează dezvoltatorilor începători.

1. Design „IZ”.

Pentru a obține date din baza de date nu este deloc necesară utilizarea construcției „FROM”.
Exemplu: Trebuie să selectăm toate informațiile despre bănci din directorul băncilor.
Cerere:

SELECT Director.Bănci.*

Selectează toate câmpurile din directorul Bănci. Și este similar cu cererea:

SELECT Bănci.* FROM Directory.Bănci AS Bănci

2. Ordonarea datelor după câmpul de referință

Când trebuie să organizăm datele de interogare pe tipuri primitive: „Șir”, „Număr”, „Data”, etc., atunci totul este rezolvat folosind constructul „ORDER BY” dacă trebuie să ordonați datele după un câmp de referință? Câmpul de referință este o legătură, un identificator unic, adică În linii mari, un set arbitrar de caractere și o ordine obișnuită pot produce un rezultat care nu este în întregime așteptat. Pentru a comanda câmpuri de referință se folosește construcția „AUTO ORDER”. Pentru a face acest lucru, trebuie mai întâi să ordonați datele direct după tipul de referință folosind constructul „ORDER BY”, apoi constructul „AUTO ORDER”.

În acest caz, pentru documente comanda se va face în ordinea „Data->Număr”, pentru cărțile de referință în „Vizualizarea principală”. Dacă comandarea nu are loc prin câmpuri de referință, atunci nu se recomandă utilizarea construcției „COMANDĂ AUTOMATĂ”.

În unele cazuri, constructul „AUTO ORDER” poate încetini procesul de selecție. În mod similar, puteți rescrie fără comandă automată pentru documente:

3.Obținerea unei reprezentări text de tip referință. Design „PRESENTARE”.

Când trebuie să afișați un câmp de tip de referință, de exemplu, câmpul „Bancă”, care este o legătură către un element din directorul „Bănci”, trebuie să înțelegeți că atunci când afișați acest câmp, o subinterogare către „ Directorul „Bănci” va fi executat automat pentru a obține o vizualizare a directorului. Acest lucru va încetini producția de date. Pentru a evita acest lucru, trebuie să utilizați construcția „PRESENTARE” în cerere pentru a obține imediat o reprezentare a obiectului și apoi afișat-o pentru vizualizare.

În sistemul de compunere a datelor, acest mecanism este utilizat în mod implicit, dar atunci când creați machete în celule, ar trebui să specificați reprezentarea câmpului de referință și, de exemplu, să plasați legătura în sine în transcriere.

4. Condiție pentru eșantionarea datelor conform unui șablon.

De exemplu, trebuie să obțineți telefoane mobile ale angajaților din formular (8 -123-456-78-912). Pentru a face acest lucru, trebuie să setați următoarea condiție în cerere:

SELECTEAZĂ Employee.Name, Employee.Phone AS Phone FROM Directory.Employees AS Angajati WHERE Phone LIKE "___-_-___-__-__"

Caracterul „_” este un caracter de serviciu și înlocuiește orice caracter.

5. Utilizarea simultană a totalurilor și grupărilor.

Totalurile sunt adesea folosite împreună cu grupările; în acest caz, funcțiile agregate pot să nu fie specificate în totaluri.

SELECT Prestare de servicii.Organizare AS Organizație, Furnizare de servicii.Nomenclatură AS Nomenclatură, SUM(Furnizare de servicii.Sumă document) AS Sumă document FROM Document.Prestare de servicii AS Prestare de servicii GROUP BY Prestare de servicii.Organizare, Furnizare de Servicii.Nomenclator REZULTATE PE GENERAL, Organizare, Nomenclator

În acest caz, interogarea va returna aproape la fel ca următoarea interogare:

SELECT Prestare de servicii.Organizație AS Organizație, Furnizare de servicii.Nomenclator AS Nomenclator, Furnizare de servicii.Suma de document AS Cantitatea de document FROM Document.Prestare de servicii AS Furnizare de servicii REZULTATE SUMA (Suma de document) BY GENERAL, Organizație, Nomenclatură

Doar prima interogare va restrânge înregistrările cu aceeași nomenclatură.

6. Dereferențiarea câmpurilor.

Referirea la câmpuri printr-un punct se numește operația de dereferențiere a câmpurilor de referință. De exemplu Plata.Organizarea.Unitatea Administrativa. În acest caz, în câmpul de referință „Organizație” din documentul „Plată” se referă la un alt tabel „Organizații”, în care se va obține valoarea atributului „Unitate administrativă”. Este important să înțelegeți că atunci când accesați câmpuri printr-un punct, platforma creează implicit o subinterogare și se alătură acestor tabele.

Cerere:

Poate fi reprezentat ca:

SELECTAȚI Payment.Link, Payment.Organization, Payment.Organization, Organizations. AdministrativeUnit FROM Document.Payment AS Payment LEFT JOIN Directory.Organizations AS Organizations Software Payment.Organization = Organizations.Link

Când dereferențează câmpurile de referință de tip compus, cadrul încearcă să creeze îmbinări implicite la toate tabelele care fac parte din tipul acelui câmp. În acest caz, interogarea nu va fi optimă.Dacă se știe clar ce tip de câmp este, este necesar să se limiteze astfel de câmpuri după tip cu un construct EXPRES().

De exemplu, există un registru de acumulare „Plăți nedistribuite”, unde mai multe documente pot acționa ca registrator. În acest caz, este incorect să obțineți valorile detaliilor registratorului în acest fel:

SELECTAȚI Plăți nealocate.Data.Înregistrare, ..... FROM RegisterAcumulare.Plăți nealocate AS Plăți nealocate

ar trebui să restricționați tipul câmpului compus la logger:

SELECTAȚI EXPRESS(Plăți nealocate.Înregistrați ca document.Plată).Data, ..... FROM RegisterAcumulare.Plăți nealocate AS Plăți nealocate

7. Construcție „UNDE”

Cu o îmbinare la stânga a două tabele, când impuneți o condiție „UNDE” pe masa din dreapta, vom obține un rezultat similar cu rezultatul cu o îmbinare interioară a meselor.

Exemplu. Este necesar să se selecteze toți Clienții din Directorul Clienți iar pentru acei clienți care au un document de plată cu valoarea atributului „Organizație” = &Organizare, să se afișeze documentul „Plată”, pentru cei care nu au, să nu-l afișeze.

Rezultatul interogării va returna înregistrări numai pentru acei clienți care au avut plata prin organizație în parametru și va filtra alți clienți. Prin urmare, trebuie să primiți mai întâi toate plățile pentru „un astfel de” organizație într-un tabel temporar și apoi să o conectați la directorul „Clienți” folosind o alăturare stângă.

SELECT Plata.Link AS Plata, Plata.Acţionar AS Client PLACE laPlăţi FROM Document.Plata AS Plata WHERE Plata.Sucursala = &Branch; //////////////////////////////////////////////////////////////////// ////////////////////////// SELECT Clients.Link AS Client, ISNULL(tPayment.Payment, "") AS Payment FROM Directory .Clients AS Clienții LEFT CONNECTION topayments AS topayments SOFTWARE Clients.Link = topayments.Client

Puteți ocoli această afecțiune într-un alt mod. Este necesar să se impună o condiție „UNDE” direct relației dintre cele două tabele. Exemplu:

SELECT Clients.Link, Payment.Link FROM Directory.US_Subscribers AS US_Subscribers LEFT CONNECTION Document.Payment AS Payment Software (Clients.Link = Payment.Client AND Payment.Client.Name LIKE "Sugar Packet") GROUP BY Clients.Link, Payment. Legătură

8. Uniri cu tabele imbricate și virtuale

Interogări imbricate adesea necesar pentru a prelua date pe baza unei anumite condiții. Dacă apoi le utilizați împreună cu alte tabele, acest lucru poate încetini critic execuția interogării.

De exemplu, trebuie să obținem suma soldului de la data curentă pentru unii clienți.

SELECT UnallocatedPaymentsBlances.Customer, UnallocatedPaymentsBalances.AmountBalance FROM (SELECT Clients.Link AS Link FROM Directory.Clients AS Clients WHERE Clients.Link B(&Clients)) AS NestedQuery LEFT JOIN RegisterAccumulations.UnallocatedPayments. ymentsSolduri. Client

La executarea unei astfel de interogări, optimizatorul DBMS poate face erori la alegerea unui plan, ceea ce va duce la o execuție suboptimă a interogării. La unirea a două tabele, optimizatorul DBMS selectează un algoritm de îmbinare a tabelelor pe baza numărului de înregistrări din ambele tabele. Dacă există o interogare imbricată, este extrem de dificil să se determine numărul de înregistrări pe care le va returna interogarea imbricată. Prin urmare, ar trebui să utilizați întotdeauna tabele temporare în loc de interogări imbricate. Deci, să rescriem cererea.

SELECTARE Clienți.Link AS Link PLACE tClienți DIN Director.Clienți AS Clienți WHERE
Clienți.Link B (&Clienți) ; //////////////////////////////////////////////////////////////////// /////////////////////////// SELECTAȚI tClients.Link, UnalocatedPaymentsRemains.AmountRemaining, FROM tClients AS tClients LEFT JOIN RegisterAccumulations.UnallocatedPayments.Balances (, Client IN (SELECTARE tClients.Link FROM tClients)) AS UnallocatedPaymentsBalances tClients.Link = UnallocatedPaymentsBalances.Clients

În acest caz, optimizatorul va putea determina câte înregistrări folosește tabelul temporar tClients și va putea selecta algoritmul optim pentru unirea tabelelor.

Mesele virtuale , vă permit să obțineți date practic gata făcute pentru majoritatea sarcinilor aplicate (Slice of the First, Slice of the Last, Remains, Turnovers, Remains și Turnovers) Cuvântul cheie aici este virtual. Aceste tabele nu sunt fizice, ci sunt compilate de sistem din mers, adică. Când primește date de la tabele virtuale, sistemul colectează date din tabelele de registru finale, le asamblează, le grupează și le transmite utilizatorului.

Acestea. Când vă conectați la o tabelă virtuală, se face o conexiune la o subinterogare. În acest caz, optimizatorul DBMS poate alege și un plan de conexiune neoptimal. Dacă interogarea nu este generată suficient de rapid și interogarea folosește îmbinări în tabele virtuale, atunci se recomandă să mutați accesul la tabelele virtuale într-un tabel temporar și apoi să faceți o îmbinare între două tabele temporare. Să rescriem cererea anterioară.

SELECTAȚI Clienți.Link AS Link PLACE tClienți DIN Director.Clients AS Clients INDEX BY Link WHERE
Clienți.Link B (&Clienți) ; //////////////////////////////////////////////////////////////////// ////////////////////////// SELECTAȚI Plăți Nealocate.SoldBalance, Plăți Nealocate.Client AS Client PLACE solduri FROM RegisterAccumulations.UnallocatedPayments.Balances(, Client B ( SELECTAȚI tClients. Link FROM tClients)) AS UnallocatedPaymentsBalances; //////////////////////////////////////////////////////////////////// /////////////////////////// SELECTAȚI tClients.Link, toRemainders.AmountRemaining AS AmountRemaining FROM tClients AS tClients LEFT JOIN toRemainders AS Remainders BY tClients.Link = tRemainings.Client

9.Verificarea rezultatului cererii.

Rezultatul interogării poate fi gol; pentru a verifica valorile goale, utilizați următorul construct:

ResRequest = Request.Execute(); Dacă resQuery.Empty() Apoi Return; endIf;

Metodă Gol() trebuie folosit înainte de metode Alege() sau Descărca(), deoarece recuperarea colecției necesită timp.

Nu este o revelație pentru nimeni că este extrem de nedorit să folosești interogări într-o buclă. Acest lucru poate afecta în mod critic timpul de funcționare al unei anumite funcții. Este foarte de dorit să primiți toate datele din cerere și apoi să procesați datele într-o buclă. Dar uneori există cazuri când devine imposibil să mutați cererea în afara buclei. În acest caz, pentru optimizare, puteți muta crearea interogării în afara buclei, iar în buclă, înlocuiți parametrii necesari și executați interogarea.

Acest lucru va salva sistemul de la verificarea sintaxei cererii într-o buclă.

11. Construcție „AVÂND”.

Un design destul de rar la solicitari. Vă permite să impuneți condiții asupra valorilor funcțiilor agregate (SUMA, MINIM, MEDIE etc.). De exemplu, trebuie să selectați numai acei clienți a căror sumă de plată în septembrie a fost mai mare de 13.000 de ruble. Dacă utilizați condiția „UNDE”, va trebui mai întâi să creați un tabel temporar sau o interogare imbricată, să grupați înregistrările acolo după suma de plată și apoi să aplicați condiția. Construcția „HAVING” va ajuta la evitarea acestui lucru.

SELECT Plata.Client, SUMA(Suma.Plată) AS Sumă FROM Document.Plata AS Plată WHERE MONTH(Data.Plată) = 9 GROUP BY Plată.Client HAVING AMOUNT(Suma.Plata) > 13000

În constructor, pentru a face acest lucru, trebuie doar să accesați fila „Condiții”, adăugați o nouă condiție și bifați caseta de selectare „Personalizat”. Atunci doar scrie Sumă (Plată. Sumă) > 13000

12. Valoare NULL

Nu voi descrie aici principiile logicii cu trei valori din baza de date; există multe articole pe această temă. Doar pe scurt despre cum NUL poate afecta rezultatul interogării. Valoarea NULL nu este de fapt o valoare, iar faptul că valoarea este nedefinită este necunoscut. Prin urmare, orice operație cu NULL returnează NULL, fie că este adunare, scădere, împărțire sau comparație. O valoare NULL nu poate fi comparată cu o valoare NULL deoarece nu știm ce să comparăm. Acestea. ambele aceste comparații sunt: NULL = NULL, NULL<>NULL nu este adevărat sau fals, este necunoscut.

Să ne uităm la un exemplu.

Pentru acei clienți care nu au plăți, trebuie să afișăm câmpul „Semnați” cu valoarea „Fără plăți”. Mai mult, știm sigur că avem astfel de clienți. Și pentru a reflecta esența a ceea ce am scris mai sus, să o facem astfel.

SELECTAȚI „Fără plăți” AS Atribut, NULL AS Document PLACE la plăți; //////////////////////////////////////////////////////////////////// ///////////////////////// SELECT Clients.Link AS Client, Payment.Link CUM PUNE Payment tClientPayment FROM Directory.Clients AS Clients LEFT CONNECTION Document. Payment AS Payment Software Clients.Link = Payment.Shareholder; //////////////////////////////////////////////////////////////////// ////////////////////////// SELECTAȚI tClientPayment.Client FROM tClientPayment AS tClientPayment INTERNAL JOIN tPayment AS tTopay BY tClientPayment.Payment = tPayment. Document

Acordați atenție celui de-al doilea tabel temporar tCustomerPayment. Cu alăturarea din stânga, selectez toți clienții și toate plățile pentru acești clienți. Pentru acei clienți care nu au plăți, câmpul „Plată” va fi NULL . Urmând logica, în primul tabel temporar „tPayments” am desemnat 2 câmpuri, unul dintre ele NULL, a doua linie „Nu are plăți”. În al treilea tabel, conectez tabelele „tClientPayment” și „tPayment” folosind câmpurile „Plată” și „Document” cu o îmbinare internă. Știm că în primul tabel câmpul „Document” este NULL, iar în al doilea tabel, cei care nu au plăți în câmpul „Plată” sunt și NULL. Ce ne va returna o astfel de conexiune? Dar nu va returna nimic. Deoarece comparația NULL = NULL nu se evaluează la True.

Pentru ca interogarea să ne returneze rezultatul așteptat, o rescriem:

SELECTAȚI „Fără plăți” AS Atribut, VALUE(Document.Payment.EmptyLink) AS Document PLACE to Payments; ////////////////////////////////////////////////////////////////////// ///////////////////////////// SELECT Clients.Link AS Client, ISNULL(Payment.Link, VALUE(Document.Payment.EmptyLink ) ) CUM PLATA PUN tClientPayment FROM Directory.Clients AS Clients LEFT CONNECTION Document.Payment AS Payment BY Clients.Link = Payment.Shareholder; ////////////////////////////////////////////////////////////////////// ///////////////////////////// SELECTAȚI tClientPayment.Client FROM tClientPayment AS tClientPayment INTERNAL JOIN tPayment AS tTopay BY tClientPayment.Payment = tPayment. Document.

Acum, în cel de-al doilea tabel temporar, am indicat că dacă câmpul „Plată” este NULL, atunci acest câmp = un link gol către documentul de plată. În primul tabel am înlocuit, de asemenea, NULL cu o referință goală. Acum conexiunea implică câmpuri non-NULL și cererea va returna rezultatul așteptat.

Toate cererile cuprinse în articol reflectă situațiile pe care aș dori să le iau în considerare și nimic mai mult. DESPRE Ele pot să nu fie delirante sau suboptimale, principalul lucru este că reflectă esența exemplului.

13. O caracteristică nedocumentată a designului „ALEGE CÂND... ATUNCI... Sfârșit”.

În cazul în care este necesar să descriem construcția „Condiții” în cerere, folosim sintaxa standard:

SELECTAȚI SELECTAREA CÂND Utilizatori.Nume = „Vasya Pupkin” APOI „Angajatul nostru preferat” ELSE „Nu știm asta” END AS Field1 FROM Directory.Users AS Users

Dar dacă, de exemplu, trebuie să obținem numele lunii într-o solicitare? Scrierea unei construcții uriașe într-o solicitare este urâtă și necesită timp, așa că această formă de scriere de mai sus ne poate ajuta:

SELECTAȚI LUNA (US_CalculationConsumption_ScheduleTurnover.CalculationPeriod) WHEN 1 THEN "Ianuarie" WHEN 2 APOI "Februarie" WHEN 3 UP "March" WHEN 4 THEN "APRILIE" WHEN 5 APOI "MAI" WHEN THUN THE 6N" CÂND 8 APOI "August" CÂND 9 APOI "Septembrie" CÂND 10 APOI "Octombrie" CÂND 11 APOI "Noiembrie" CÂND 12 APOI "Decembrie" SE SFÂRȘTEȘTE CA O LUNĂ

Acum, designul pare mai puțin greoi și este ușor de înțeles.

14. Executarea interogării pe lot.

Pentru a nu multiplica cererile, puteți crea o cerere mare, o puteți împărți în pachete și puteți lucra cu ea.
De exemplu, trebuie să obțin următoarele câmpuri din directorul „Utilizatori”: „Data nașterii” și rolurile disponibile pentru fiecare utilizator. încărcați acest lucru în diferite părți tabelare din formular. Desigur, puteți face acest lucru într-o singură solicitare, apoi va trebui să repetați înregistrările sau să le restrângeți, sau puteți face acest lucru:

SELECT Users.Link AS Nume complet, Users.Date of Birth, Users.Role PUT vtUsers FROM Directory.Users AS Users; ////////////////////////////////////////////////////////////////////// ///////////////////////////// SELECT tueUsers.Nume complet, tueUsers.Data nașterii FROM tueUsers AS tueUsers GROUP BY tueUsers.nume complet , tueUsers. Data nașterii; ////////////////////////////////////////////////////////////////////// ///////////////////////////// SELECT wUsers.Full Name, wUsers.Role FROM wUsers AS wUsers GROUP BY wUsers.Full Name, wUsers Data nașterii

tPackage = Request.ExecutePackage();

TP_BirthDate = tPackage.Unload();
TP_Roles = tPackage.Unload();

După cum putem vedea, interogarea poate fi executată într-un lot, iar rezultatul poate fi procesat ca o matrice. În unele cazuri, foarte convenabil.

15. Condiții într-o cerere de lot

De exemplu, avem o cerere de lot, unde mai întâi primim câmpurile: „Nume, Data nașterii, Cod” din directorul „Utilizatori” și dorim să obținem înregistrări cu condiții pentru aceste câmpuri din directorul „Persoane fizice”.

SELECT Users.Individual.Name AS Nume, Users.Individual.Date of Birth AS Data of Birth, Users.Individual.Code AS Cod PLACE vtUsers FROM Directory.Users AS Users; ////////////////////////////////////////////////////////////////////// ////////////////////////////// SELECTAȚI Persoane.Link AS Individ FROM Director.Persoane AS Persoane

Puteți aplica condiții ca aceasta:

WHERE Persoane fizice.Cod la (SELECT TueUsers.Code FROM TuUsers) AND Individuals.Name La (SELECT TueUsers.Code FROM TuUusers) AND Individuals.Date of Birth La (SELECT TueUsers.Date of Birth FROM TuUsers)

Și poți face așa:

WHERE (Persoane.Cod, Nume persoane fizice, Persoane fizice.Data nașterii) AT (SELECT TueUsers.Code, TueUsers.Name, TueUsers.Data nașterii FROM TueUsers)

Și asigurați-vă că urmați regulile.

16. Apelați Query Builder pentru „Condiție” în Batch Query

Când trebuie să impuneți o condiție, ca în exemplul de mai sus, puteți uita cum este numit acest sau acel câmp în tabelul virtual.
De exemplu, trebuie să impuneți o condiție câmpului „Data nașterii”, iar în tabelul virtual acest câmp se numește „Data nașterii debitorului”, iar dacă ați uitat numele, va trebui să părăsiți editarea condiția fără a salva și uitați-vă la numele câmpului. Pentru a evita acest lucru, puteți folosi următorul truc.

Este necesar să puneți paranteze după Construcția „B” și să lăsați un spațiu gol (spațiu) între paranteze, selectați acest loc și apelați constructorul de interogare. Constructorul va avea acces la toate tabelele de interogări batch. Recepția funcționează atât pe tabele virtuale de registre, cât și pentru fila „Condiții”. În acest din urmă caz, este necesar să bifați caseta de selectare „A (condiție arbitrară)” și să intrați în modul de editare „F4”.

Interogările sunt adesea făcute din mers și servesc doar pentru a afișa „trucurile” pe care le-am luat în considerare.

Am vrut să mă uit la utilizarea indecșilor în interogări, dar acesta este un subiect foarte larg. Îl voi pune într-un articol separat sau îl voi adăuga aici mai târziu.

upd1. Punctele 11,12
upd2. Punctele 13,14,15,16

Cărți folosite:
Limbajul de interogare „1C:Enterprise 8” - E.Yu. Khrustaleva
Dezvoltare profesională în sistemul 1C:Enterprise 8.”

Articolul oferă trucuri utile atunci când lucrați cu interogări 1C v.8.2, precum și informații care nu sunt atât de bine cunoscute despre limbajul de interogare. Nu încerc să ofer o descriere completă a limbajului de interogare, dar vreau să mă opresc doar asupra unor puncte care pot fi utile cuiva.

Deci, să începem. O cerere este un obiect special în 1C 8.2 A care este utilizat pentru a forma și executa interogări împotriva tabelelor bazei de date din sistem. Pentru a executa o interogare, trebuie să compuneți un text de interogare care să descrie ce tabele vor fi folosite ca surse de date pentru interogare, ce câmpuri să selectați, ce sortări și grupări să aplicați etc. Puteți citi mai multe despre interogări în cartea „1C 8.2 Developer’s Guide”. Limbajul de interogare 1C 8.2 este foarte asemănător ca sintaxă cu alte limbaje de interogare a bazei de date SQL, dar există și diferențe. Printre principalele avantaje ale limbajului de interogare încorporat, merită remarcată dereferința câmpurilor, prezența tabelelor virtuale, lucrul convenabil cu totaluri și câmpurile netipizate în interogări. Dezavantajele sunt că nu puteți utiliza o interogare ca câmp de ieșire, nu puteți utiliza proceduri stocate și nu puteți converti un șir într-un număr.

Voi oferi informații și recomandări cu privire la limbajul de interogare punct cu punct:
1. Pentru a crește lizibilitatea cererii și a reduce numărul de parametri de cerere, puteți utiliza un literal pentru a accesa datele de configurare predefinite în cerere VALOARE (REPREZENTAREA VALORII). Ca reprezentare a valorilor, valorile enumerarilor, date predefinite ale directoarelor, planuri de tipuri de calcul, planuri de tipuri de caracteristici, planuri de conturi, link-uri goale, valori ale punctelor de traseu, valori ale transferurilor de sistem ( de exemplu, tipul de mișcare de acumulare, tipul de cont) pot fi utilizate.
Exemple:

WHERE City = VALUE(Directory.Cities.Moscow)
WHERE City = VALUE(Directory.Cities.EmptyLink)
WHEREProductType = VALUE(Enumeration.ProductTypes.Service)
WHEREMovementType = VALUE(MovementTypeAccumulation.Incoming)
UNDE este Route Point =
Valoare

Expresia dintre paranteze începe întotdeauna cu un cuvânt singular (Director, Enumerare etc.) care se potrivește cu tipul valorii predefinite.

2. Comanda automată într-o interogare poate încetini foarte mult procesul. Dacă nu este necesară sortarea, este mai bine să nu o folosiți deloc. În multe cazuri, este mai eficient să scrieți sortarea folosind un cuvânt cheie FILTREAZĂ DUPĂ.

3. Trebuie să vă asigurați că atunci când utilizați aliasuri, nu apare un câmp ambiguu. În caz contrar, sistemul nu va înțelege ce obiect ar trebui accesat.
Un exemplu de interogare cu un câmp ambiguu:
ALEGE
Nomenclatură.Link,
Bunuri rămase rămase Cantitate rămasă
DIN
Director.Nomenclatura AS Nomenclatura
CONEXIUNEA STÂNGA Înregistrați acumulări Mărfuri rămase Restul AS Bunuri rămase rămase
Rămășițe de produse software.
Este necesar să corectați alias-ul tabelului, de exemplu, astfel: „Directory.Nomenclature AS Nomenclature1” și „Nomenclature.Link” ar trebui corectate în consecință cu „Nomenclature1.Link”.

4.Uneori este util să obțineți o reprezentare a câmpurilor de referință folosind un cuvânt cheie PERFORMANŢĂîmpreună cu un link astfel încât să nu existe re-acces la baza de date. Acest lucru este util când se afișează rezultatul unei interogări într-un tabel.
Exemplu:
ALEGE
REPREZENTARE(Document.Cont) CA Destinatar,
REPREZENTARE(Document.Base)
DIN
Document.Factura AS Document

5. Utilizați într-o cerere EXPRESS(Tipul AS de câmp) vă permite să eliminați tabelele inutile din conexiunea cu câmpul tipului de date compus. Acest lucru va grăbi executarea cererii.
Exemplu (registrar este un câmp cu tip compozit pentru tabelul fizic al registrului de acumulare a bunurilor rămase, în cerere se selectează Data și Numărul documentelor Primirea mărfurilor, în timp ce la accesarea detaliilor documentului Data și Numărul prin Registrator, nu există o conexiune multiplă a tabelului de registru cu tabelele de documente care sunt registratori pentru registrul de rămășițe de bunuri):
SELECTAȚI DIVERSE[b] EXPRESS(Mărfuri rămase.Registrul AS Document.Recepția mărfurilor).Număr AS NUMĂR DE PRESTAȚIE,
[b] EXPRESS(Mărfuri rămase.Registrul AS Document.Recepția mărfurilor).Date AS RECEIPT DATE
[b]DIN Registrul de acumulări Bunuri rămase AS Bunuri rămase UNDE (EXPRESS(Mărfuri rămase. Înregistrare ca document. Primire a mărfurilor) NU ESTE NUL)

6. Când în configurația 1C există utilizatori care au drepturi limitate asupra anumitor obiecte de configurare, cuvântul cheie trebuie utilizat în cererea către astfel de obiecte PERMIS astfel încât cererea să fie executată fără eroare (Selectați Permis...)

7. Când îmbinați tabele care conțin tabele imbricate (de exemplu, un document cu o parte tabelară), cuvântul cheie poate fi util TABUL GOLIT când, de exemplu, unul dintre documente nu are o parte tabelară.
Exemplu:
SELECT Link.Number, EMPTY TABLE.(Nr., Articol, Cantitate) AS Compoziție

COMBINA TOTUL
SELECT Link.Number, Composition.(LineNumber, Nomenclatură, Cantitate)
DIN Document.Factură

8. Când lucrați cu îmbinări de tabele care conțin câte un rând fiecare, poate fi necesară îmbinarea rândurilor de tabele (în ambele tabele nu există niciun câmp prin care acestea să poată fi unite). Acest lucru se poate realiza prin utilizarea construcției " FULL CONNECTION Tabel de TRUE" Dacă tabelele au mai multe rânduri, rezultatul va fi un număr de rânduri egal cu produsul dintre numărul de rânduri din ambele tabele. Dacă există O rânduri într-un tabel, atunci numărul de rânduri din tabelul rezultat va fi egal cu numărul de rânduri din al doilea tabel. De asemenea, pentru a conecta astfel de tabele, puteți utiliza produsul cartezian al tabelelor, în care toate combinațiile de rânduri din ambele tabele vor apărea în tabelul rezultat. Trebuie să ne amintim că dacă există 0 rânduri într-unul dintre tabele, atunci produsul cartezian va fi 0, deci o îmbinare completă va fi mai bună. În general, în loc de o conexiune completă PRIN ADEVĂRAT Puteți folosi orice alt tip de îmbinare, dar în acest caz este posibil și ca tabelul rezultat să aibă 0 rânduri, chiar dacă unul dintre tabele are un număr de rânduri diferit de zero. În cazul unei îmbinări complete, această situație va apărea doar într-un singur caz, dacă numărul de rânduri din ambele tabele este 0. Dacă știți că există exact cel puțin un rând în tabel, atunci puteți utiliza CONEXIUNEA STÂNGA cu o alta masa cu conditie PRIN ADEVĂRAT.
Exemplu (desigur, conceput, pentru Full Join):
ALEGE
Primul 1
Gender.Link,
K.Contractant
DIN
Enumerare.Sex AS Gen
CONEXIUNE COMPLETĂ (Selectați primul 1 D. Contraparte DIN Document. Vânzări de bunuri CUM D Aranjați după D. Momentul de timp) CUM SE
ACTIVAT (ADEVĂRAT)

9. Pentru a obține înregistrări unice pentru un anumit câmp, este mai corect să folosiți un cuvânt cheie în loc să grupați VARIATîn cerere, deoarece această construcție este mult mai clară și cuvântul cheie A SE GRUPA CU are o aplicație mai largă și este adesea folosit dacă este suplimentar necesar să se calculeze funcții agregate pe grupări. În unele cazuri, este necesar să ieșiți un număr limitat de linii. Pentru a face acest lucru, ar trebui să specificați cuvântul cheie în descrierea cererii PRIMUL iar după el - numărul necesar de linii.
Exemplu pentru PRIMUL:
Selectați Primele 5
Directory.Nomenclature.Name,
Director.Nomenclatură.PurchasingPrice
Filtrează după
Director.Nomenclatură.PurchasePrice Descendent
Exemplu pentru VARIAT:
Selectați Diverse
Document.Consumabil.Contraparte

10. Funcțiile de agregare dintr-o interogare pot fi utilizate fără un cuvânt cheie GRUP. În acest caz, toate rezultatele vor fi grupate într-o singură linie.
Exemplu:
Alege
Sumă (Factură. Sumă) Ca Sumă
Din
Document.Factură.Compoziție Ca Factură

11.În interogările din câmpurile de selecție, puteți accesa liber detaliile câmpurilor de selecție. Această caracteristică se numește select field dereferencing. Dacă sursa de date este un tabel imbricat (partea tabelară a documentului), atunci în câmpurile de selecție vă puteți referi și la câmpurile tabelului principal (de exemplu, prin câmpul Link, accesați câmpul tabelului principal Counterparty)
Exemplu:
ALEGE[b] Primirea Bunurilor si Serviciilor Bunuri Cantitate AS Cantitate, Primirea Bunurilor și Serviciilor Bunuri.Link.Contraparte DIN UNDE
Există o particularitate a utilizării dereferențării câmpurilor dacă există grupări în cerere. În orice interogări cu grupări în listele de câmpuri de interogare, puteți accesa liber detaliile câmpurilor de grupare.
Exemplu:
ALEGE
Recepția Bunurilor și Bunurilor Servicii. Nomenclator,
Recepție Bunuri și Servicii Bunuri. Nomenclator. Cod,
SUM (Recepția Bunurilor și Serviciilor Bunuri. Cantitate) AS Cantitate,
Primirea Bunurilor și Serviciilor Bunuri.Link.Contraparte,
Primirea Bunurilor și Serviciilor Bunuri.Link.Data
DIN
Document.Recepția de Bunuri și Servicii.Bunuri CUM Primirea de Bunuri și Servicii Bunuri
UNDE
Primirea de Bunuri și ServiciiGoods.Link = &Link
A SE GRUPA CU
Recepția Bunurilor și Bunurilor Servicii. Nomenclator,
Primirea Bunurilor și Serviciilor Bunuri.Link
Ajutorul 1C spune că, dacă există grupare, numai câmpurile de grupare și funcțiile de agregare pentru câmpurile de selecție pot participa la câmpurile de selecție a interogării. Există un caz excepțional când funcțiile agregate sunt aplicate câmpurilor unui tabel imbricat. În acest caz, în lista câmpurilor de selecție, este posibilă accesarea câmpurilor din tabelul de nivel superior, fără a grupa rezultatele după aceste câmpuri.
Exemplu:
ALEGE
Primirea de bunuri și servicii, bunuri (SUMA (cantitate), nomenclatură),
Primirea Bunurilor și Serviciilor. Link,
Primirea Bunurilor și Serviciilor Contraparte
DIN
Document.Recepția Bunurilor și Serviciilor CUM Primirea Bunurilor și Serviciilor
A SE GRUPA CU
Primirea de bunuri și servicii, bunuri (nomenclatură)

12. Uneori, în loc să specificați orice câmp din grupare, este util să includeți următorul parametru în câmpurile de selecție a interogării:
ALEGE DocProducts.Nomenclature, &Contraparte, &Perioadă, SUM(DocProducts.Quantity * DocProducts.K) AS Cantitate, SUM(DocProducts.Amount) AS Sumă DIN Document.Admitere.Produse AS DocProducts UNDE DocProducts.Link = &Link
A SE GRUPA CU DocProducts.Nomenclatură
Și apoi setați parametrul în corpul cererii:
Request.SetParameter("&Cont", SelectAccount);
Query.SetParameter("&Period", Data);

13. În interogările universale, parametrii pot fi utilizați în descrierea surselor de date de interogare, în condiții UNDE,în condiţiile unirii tabelelor şi parametrilor tabelelor virtuale. Există două tehnici pentru a crea interogări generice:
A) folosind mecanismul de concatenare a șirurilor de caractere, adăugarea de variabile la textul interogării;
Exemplul 1:

OrderingType = ?(UNE VARIABILE,"","DESC");
Query.Text = "Selectați... Aranjați BY Field1 " + OrderType + "...";
Exemplul 2:
Query.Text = "Selectați Câmp1...";

Dacă UNELE VARIABILE = 1 Atunci
Request.Text = Request.Text + ",Field2 ...";
endIf;
B) utilizați parametrii în diferite părți ale interogării (de exemplu, în secțiunea surse de date a interogării), apoi metoda limbajului încorporat - STREPLACE(). Când se proiectează interogări generice, este util să se facă referire la o proprietate a obiectelor METADATE(), cu care puteți determina numele tabelului pentru un link (de exemplu, pentru un document va fi ceva de genul acesta - Link . METADATA().NAME), trecut printr-un parametru la o procedură universală.
Exemplu:
Alege
DocTch.Nomenclatura,
...
DIN
&Unele DocTC AS DocTC
Și apoi setați parametrul în corpul solicitării
Request.Text = StrReplace(Request.Text, "&SomeDocTCH", "Document."+Link.Metadata().Name+".Products");

Parametrii pot fi utilizați în condiții de interogare pentru a activa o condiție opțională &Parametru SAU NU SomeProperty:
Request.SetParameter(“&Parameter”, “Counterparty.Name="”Ivanov”””);
Folosind un literal ADEVĂRAT puteți elimina anumite filtre din cerere
Request.SetParameter("&Parametru", True);

14. Foarte utilă în designerul de interogări este comanda meniului contextual al tabelului - " Redenumiți tabelul...", cu care puteți veni cu un nume generalizat pentru sursa de date. Pentru a crea interogări pentru tabele de același tip, similare ca structură, poate fi util ca al doilea tabel să copieze textul de interogare al primului tabel, mergeți la fereastra de proiectare de interogări și selectați elementul din meniul contextual al tabelului - Înlocuiește masa...și selectați al doilea tabel.

15. Când lucrați cu crearea de interogări imbricate în secțiunile de condiții sau parametri ai tabelelor virtuale ale designerului de interogări, se folosește tehnica de evidențiere a unui spațiu între paranteze, apoi elementul „Query Designer” apare în meniul contextual și la editarea unei interogări imbricate, întreaga interogare între paranteze este evidențiată în condiție.
Exemplu de interogare imbricată:
Produs B (Selectați produsul...)

16. La proiectarea rapoartelor ACS în interogări de echilibrare a registrelor, este mai convenabil și mai corect să folosiți expresia ca parametru Perioadă AddToDate(EndPeriod(Period,DAY),SECOND,1), deoarece soldurile virtuale se obțin la începutul perioadei, fără a include ultima secundă. Tehnica +1 secundă nu poate fi utilizată cu documente: conform noii metode de înregistrare a documentelor, soldurile de registru trebuie să fie primite pentru Perioada specificată de obiectul Limită cu momentul în care documentul include (și nu la data document +1 secundă!), și conform vechii metode de postare - la momentul documentului (și nu la data documentului!). Când analizați cifra de afaceri sau datele pentru o perioadă, este convenabil să adăugați un parametru cu tipul Perioada standard(în acest caz nu este necesară furnizarea ultimei date a intervalului la sfârșitul zilei). Pentru câmpul standard „Începutul perioadei”, în câmpul „Expresie” trebuie să introduceți „&Perioada.Data de începere" Și pentru câmpul standard „Sfârșitul perioadei” în câmpul „Expresie” scrieți „ &Perioada.Data de încheiere”. O mulțime de informații utile despre limbajul de interogare pot fi găsite nu în asistentul de sintaxă, ci în ajutorul complet al configuratorului 1C 8.2 (butonul F1)

17.Funcția de interogare Nul(este mai convenabil să scrieți versiunea în limba engleză EsteNull) este de obicei folosit pentru a scăpa de valorile nule pentru câmpurile de interogare numerică. În unele cazuri, de exemplu, o îmbinare completă a două tabele, funcția IsNull (Parametrul 1, Parametrul 2) poate înlocui cu succes designul ALEGERE CÂND... ATUNCI..ALTĂ....Sfârșit, când pentru orice câmp valorile NULL pot fi atât în primul tabel, cât și în al doilea (această construcție vă permite să obțineți o valoare non-Null pentru câmp). Dar trebuie să ne amintim că, spre deosebire de operatorul condiționat ALEGERE funcţie Nul convertește tipul celui de-al doilea argument în tipul primului argument, care trebuie luat în considerare dacă tipurile de argument sunt diferite!
Exemplu:
IsNull(Reg.Remaining,0)
IsNull(Doc.Product, Doc1.Item)

18. La construcţia condiţionată ALEGERE Există o sintaxă alternativă pentru cazul simplu de testare a egalității la o anumită valoare, dar este, totuși, nedocumentată:
Alegere expresie Când 1 Apoi „Ridicat” Când 2 Apoi „Mijloc” Altfel „Scăzut” Final

19. Operator de verificare a valorii NULL Da Null(Putem recomanda utilizarea versiunii în limba engleză Este nul). Această construcție a apărut deoarece orice operație care compară două valori, dintre care cel puțin una este Nulă, este întotdeauna falsă. Scrie Unde Nume = Null gresit. Interesantă este și forma de negație a acestui operator Nu Null- greșit, dar corect Da, nu nul sau formă Nu (Câmpul 1 este nul)- aceasta este o diferență semnificativă față de toți operatorii utilizați împreună cu operatorul He.

20. Uneori formularul operator este util ÎN pentru a verifica dacă există o potrivire cu una dintre valorile enumerate.
Exemplu:
...Unde este produsul.Numele B („Electrocasnice”, „Computere”)
Pentru cărțile de referință, formularul de operator poate fi util ÎN verificări de apartenență la ierarhie.
Exemplu:
...Unde este Nomenclatura ÎN IERARHIE (&Grup)
Operator ÎN adesea folosit pentru a verifica dacă o valoare este inclusă în rezultatul unei subinterogări.
Exemplu:
...Unde Nomenclature.Link B (Selectați Nomenclature.Link...).
Într-o subinterogare, puteți accesa câmpurile de interogare exterioare într-o condiție.
Exemplu:
// Selectați numele produselor care au fost prezente
// în facturi
ALEGE
Produse.Nume
DIN
Director.Nomenclator CUM Produse
UNDE
Produse.Link B
(ALEGE
FacturăCompoziție.Nomenclatură
DIN
Document.Invoice.Composition AS InvoiceComposition
UNDE
InvoiceContent.Nomenclature = Products.Link)
Operațiune ÎN poate fi folosit cu matrice, liste de valori, tabele de valori, interogări imbricate. În acest caz, este posibil să se reducă condițiile
Sintaxă pentru o subinterogare
(expresia1, expresia2,...,expresiaN) În (Selectați expresia1, expresia2,...,expresiaN...)
Sintaxa pentru tabelul de valori
(expresie1, expresie2,...,expresieN) În (&TK), unde primele N coloane sunt utilizate în tabelul cu valorile TK

20. Există o glumă pe internet despre cum continuă să se descurce generatorul de interogări STÂNGA alăturarea meselor (și schimbarea lor), indiferent de modul în care specificăm DREAPTA:
1C: Întreprinderea iubește „în stânga”.

21. Este convenabil să depanați interogări complexe în consola de interogări. Sunt multe dintre ele pe Internet. După depanarea unei interogări, aceasta poate fi copiată și există un buton minunat în constructorul de interogări " Cerere”, unde îl puteți lipi în aceeași formă și îl puteți salva (anterior era posibil doar să îl copiați în configurator și să formatați cererea folosind un caracter de întrerupere de linie). În fereastra care se deschide când faceți clic pe butonul „Solicitare”, puteți edita cererea și puteți vizualiza rezultatul execuției, ceea ce este destul de convenabil.

22. Când proiectați rapoarte ACS, trebuie să vă amintiți că, dacă trebuie să furnizați filtrarea după un anumit câmp, nu este necesar să adăugați un parametru la textul solicitării. Generatorul de interogări are o filă „ Compoziția datelor", unde puteți adăuga parametri la condiții. În plus, la nivelul raportului ACS există o filă de condiții în care puteți adăuga condiții arbitrare și le puteți salva în setări rapide. În acest caz, condițiile vor fi universale (egalitate, inegalitate, apartenență, includere în listă etc.).

23. Când lucrați cu documente, poate fi necesar să adăugați sortarea după un câmp de tabel virtual MOMENT DE TIMP, dar ghinion - în interogările imbricate, sortarea după acest câmp nu funcționează corect. Dansul cu tamburine ajută: sortarea după câmp virtual MOMENT DE TIMP se înlocuiește cu două sortări: după dată și după link. De asemenea, puteți rezolva problema printr-un tabel temporar mutând interogarea imbricată într-o interogare separată. Pentru multe versiuni, această caracteristică sau eroare nu a fost remediată.
Un exemplu de solicitare defectuoasă care primește ultimul document postat pentru contrapartea specificată (sau, mai degrabă, partea tabelară a documentului):

ALEGE
ConsumableProducts.Link,
Consumabile.Număr linie,
ConsumableProducts.Product,
Articole consumabile.Cantitate,
Produse consumabile.Pret,
Articole consumabile.Cant
DIN

UNDE
Produse consumabile. Link B
(SELECTARE TOP 1
D. Link
DIN
Document.Consumabil AS D
UNDE
D. Link. Realizat

COMANDA DE D. Link. Momentul timpului DESCENDENT)

Solutii posibile:
A) Înlocuiți cu FILTREAZĂ DUPĂ pe
COMANDA PENTRU D.Data DESC.
COMANDĂ PRIN D.Link DESCENDENT

B) Puteți muta interogarea imbricată într-un tabel temporar:
SELECTARE TOP 1
D. Link
PUNEȚI TZLink
DIN
Document.Consumabil AS D
UNDE
D. Link. Realizat
Și D.Counterparty = &Counterparty

FILTREAZĂ DUPĂ
D. Link. Momentul timpului DESCENDENT
;

////////////////////////////////////////////////////////////////////////////////
ALEGE
ConsumableProducts.Link,
Consumabile.Număr linie,
ConsumableProducts.Product,
Articole consumabile.Cantitate,
Produse consumabile.Pret,
Articole consumabile.Cant
DIN
Document.Consumabil.Bunuri AS ConsumabileBunfuri
UNDE
Produse consumabile. Link B
(ALEGE
T.Link
DIN
TZLink AS T)
C) Vă puteți referi la tabelul principal al documentului și abia apoi la partea tabulară
SELECTARE TOP 1
Consumabile.Link,
Consumabile.Marfuri.(
Legătură,
Numărul de linie,
Produs,
Cantitate,
Preț,
Sumă
)
DIN
Document.Consumabile AS Consumabile
UNDE
Expense.Counterparty = &Contraparte
Și Consumabile.Realizat

FILTREAZĂ DUPĂ
Consumabil.Momentul Timpului SCADĂ

24. La accesarea tabelului principal al unui document (director), puteți accesa și datele din tabelul subordonat (partea tabelară). Această oportunitate se numește dereferențierea câmpurilor de tabel. Un exemplu de sarcină este sarcina de a căuta documente care conțin un anumit produs în secțiunea tabelară.
Exemplu:
Selectați Receipt.Link FROM Document.Receipt Unde Receipt.Goods.Nomenclature = &Nomenclatură.

Avantajul acestei interogări față de o interogare pe tabelul imbricat Receipt.Goods este că, dacă există duplicate în documente, rezultatul interogării va returna doar documente unice fără a utiliza cuvântul cheie. VARIAT.
Comparaţie:
Selectați diverse produse.Link FROM Document.Receipt.Products ca produse unde Products.Nomenclature = &Nomenclatură.
Acesta este, probabil, tot ceea ce există. Este clar că există încă multe întrebări în limbajul de interogare pe care nu le-am acoperit. Pentru a scrie acest articol, am folosit informațiile primite după finalizarea cursului de bază 1C 8.2 spec8.ru, precum și din cartea „Ghidul dezvoltatorului 1C 8.2” și pe Internet.
Mulțumiri tuturor!