Acasă Instagram

1c solduri de masă virtuală și cifra de afaceri. Fila Lot de interogări

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.Nomenclatura REZULTATE PENTRU GENERAL, Organizare, Nomen klatura

Î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 UnallocatedPaymentsRemains.Customer, UnallocatedPaymentsRemains.AmountRemaining FROM (SELECT Clients.Link AS Link FROM Directory.Clients AS Clients WHERE Clients.Link IN(&Clients)) AS NestedQuery LEFT JOIN RegisterAccumulations.UnallocatedPayments.BaquestedPayments. lăncile. 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 PENTRU Plata 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 tClientPayment. 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 întoarce o astfel de conexiune? Dar nu va returna nimic. Deoarece comparația NULL = NULL nu se evaluează la True.

Pentru ca cererea să returneze rezultatul așteptat, să 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 Payment PUT 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) CÂND 1 APOI „Ianuarie” CÂND 2 APOI „Februarie” CÂND 3 APOI „Martie” CÂND 4 APOI „Aprilie” CÂND 5 APOI „Mai” CÂND 7 IUNIE CÂND 6 IUNIE 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 TERMINĂ 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 de Naștere

tPackage = Request.ExecutePackage();

TP_BirthDate = tPackage.Upload();
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 este 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. Legătură ca persoană fizică din director. Persoane ca persoane fizice

Puteți impune condiții ca aceasta:

WHERE Individuals.Code IN (SELECT vtUsers.Code FROM vtUsers) AND Individuals.Name IN (SELECT vtUsers.Code FROM vtUsers) AND Individuals.BirthDate IN (SELECT vtUsers.DateBirth FROM tvUsers)

Și poți face așa:

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

Mai mult, este necesară menținerea ordinii.

16. Apelarea generatorului de interogări pentru „condiție” într-o cerere de lot

Când este necesar să se impună 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ă uitați numele, va trebui să părăsiți editarea condiției fără salvând și uită-te la numele câmpului. Pentru a evita acest lucru, puteți utiliza următoarea tehnică.

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 spațiu și apelați constructorul de interogare. Proiectantul va avea acces la toate tabelele interogării lot. Tehnica funcționează atât pe tabele de registre virtuale, cât și pe fila „Condiții”. În acest din urmă caz, trebuie să bifați caseta „P (condiție arbitrară)” și să intrați în modul de editare „F4”.

Interogările au fost adesea făcute din mers și servesc pur și simplu pentru a ilustra „tehnicile” pe care le aveam în vedere.

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.”

La organizarea probelor în probleme reale, în marea majoritate a cazurilor, selecția datelor este organizată în conformitate cu anumite criterii.

În cazul în care selecția se face dintr-un tabel real, nu apar dificultăți. Datele sunt prelucrate absolut banal:

În cazul în care sursa din interogare este un tabel virtual, situația devine ceva mai complicată.

Limbajul de interogare vă permite să impuneți o condiție unei selecții din tabelele virtuale în două moduri: în clauza WHERE și folosind parametrii tabelului virtual. Ambele metode vor duce la același rezultat (cu excepția unor cazuri specifice), dar, cu toate acestea, sunt departe de a fi echivalente.

Știm deja că tabelele virtuale se numesc virtuale deoarece nu se află de fapt în baza de date. Se formează numai în momentul în care li se face o cerere. În ciuda acestui fapt, este convenabil pentru noi (adică cei care scriem interogarea) să considerăm tabelele virtuale ca fiind reale. Ce se va întâmpla în sistemul 1C Enterprise 8 când interogarea pe care am compilat-o încă mai accesează tabelul virtual?

În primul pas, sistemul va construi un tabel virtual. În al doilea pas, vor fi selectate înregistrări din tabelul rezultat care îndeplinesc condiția specificată în clauza WHERE:
Se vede clar că eșantionul final nu va include toate înregistrările din tabelul virtual (și, prin urmare, din baza de date), ci doar pe cele care îndeplinesc condiția dată. Și înregistrările rămase vor fi pur și simplu excluse din rezultat.

Astfel, sistemul nu va face doar o muncă inutilă, ci va dubla munca inutilă! În primul rând, resursele vor fi cheltuite pentru construirea unui tabel virtual bazat pe date inutile (în figură sunt marcate ca „zonele de date A și B”), iar apoi se va lucra pentru a filtra aceste date din rezultatul final.

Parametrizând un tabel virtual, limităm imediat cantitatea de date care va fi procesată de interogare.

Care este diferența dintre valorile parametrului tabelului virtual „Metoda de adăugare”?
Când Metoda de adăugare este setată la „mișcări”, atunci vor fi returnate numai acele perioade în care au existat mișcări. Când este setat „Mișcări și limite de perioadă”, la mișcările de mai sus vor fi adăugate 2 înregistrări: mișcări la începutul și sfârșitul perioadei specificate în parametrii VT. Câmpul „Registrar” va fi gol pentru aceste 2 înregistrări.

Informatii preluate de pe site

La organizarea probelor în probleme reale, în marea majoritate a cazurilor, selecția datelor este organizată în conformitate cu anumite criterii.

În cazul în care selecția se face dintr-un tabel real, nu apar dificultăți. Datele sunt prelucrate absolut banal:

În cazul în care sursa din interogare este un tabel virtual, situația devine ceva mai complicată.

În primul pas, sistemul va construi un tabel virtual. În al doilea pas, vor fi selectate înregistrări din tabelul rezultat care îndeplinesc condiția specificată în clauza WHERE:

Se vede clar că eșantionul final nu va include toate înregistrările din tabelul virtual (și, prin urmare, din baza de date), ci doar pe cele care îndeplinesc condiția dată. Și înregistrările rămase vor fi pur și simplu excluse din rezultat.

Este posibil să încetați imediat, în etapa de construire a unui tabel virtual, să nu mai folosiți date inutile? Se dovedește că este posibil. Exact pentru asta sunt proiectați parametrii tabelului virtual:

Parametrizând un tabel virtual, limităm imediat cantitatea de date care va fi procesată de interogare.

Să apelăm dialogul pentru introducerea parametrilor tabelului virtual PriceSliceLast și să indicăm că perioada va fi trecută în parametrul ReportDate. Pentru a face acest lucru, selectați acest tabel din lista Tabele și faceți clic pe butonul Opțiuni tabel virtual. Apoi selectați următoarele câmpuri din tabele:

SprNomenclatura. Mamă,

PreturiSlice of Latest.Price.

Alăturarea mesei din stânga

- Pe marcaj Conexiuni: în câmpul Condiție link, valoarea dimensiunii Nomenclatură a registrului de informații trebuie să fie egală cu referința la elementul director Nomenclatură. De asemenea, debifați caseta de selectare Toate pentru tabelul de înregistrare și verificați-o pentru tabelul de căutare, setând astfel tipul de conexiune ca conexiune din stânga pentru tabelul de căutare:

Orez. 13.15. Relația dintre tabelele dintr-o interogare

- Pe marcaj Condiții să setăm condiția de selectare a elementelor din directorul Nomenclatură - elementele selectate trebuie să corespundă tipului de nomenclatură trecut în parametrul de solicitare Tip de nomenclatură:

Orez. 13.16. Conditii de selectare a elementelor

- Pe marcaj Sindicate/Alias-uri: specificați alias-ul câmpului Parent = Service Group și al câmpului Link = Service. - Faceți clic pe OK–

După aceasta, trebuie să editați schema de aspect al datelor, pentru a face acest lucru în filă Resurse, faceți clic pe butonul adăugași selectați o resursă - Preț

- Pe marcaj Opțiuni setați valoarea parametrului Nomenclature Type - Enumeration.Nomenclature Types.Service. În plus, vom elimina restricția de disponibilitate pentru parametrul ReportDate. În câmpul Tipul acestui parametru, setați compoziția datei - Data. Pentru parametrul Perioadă, dimpotrivă, am stabilit o restricție de disponibilitate:

Orez. 13.17. Opțiuni de schemă de aspect

Setări

- Să mergem la marcaj Setări: Să creăm o grupare bazată pe câmpul Grup de servicii, specificând tipul de grupare Ierarhie.

Există următoarele tipuri de ierarhie pentru grupările de rapoarte: Fără ierarhie - numai înregistrările non-ierarhice sunt afișate în grupare. Ierarhie - atât înregistrările neierarhice, cât și cele ierarhice sunt afișate în grupare. Numai ierarhie - numai înregistrările ierarhice (părinte) sunt afișate în grupare. În cadrul acestui grup vom crea altul, fără a specifica câmpul grupului. Pe sub-fila Câmpuri selectate: specificați câmpurile de ieșire Serviciu și Preț:

Orez. 13.18. Structura și câmpurile raportului

Pe sub-fila Alte setări vom efectua următorii pași:

Orez. 13.19. Setări pentru afișarea totalurilor generale pentru gruparea „Grup de servicii”.

Orez. 13.20. Configurarea și afișarea rezultatelor pentru un raport global

În cele din urmă, să includem parametrul Data raportului în setările utilizatorului și să setăm modul său de editare la Acces rapid. Să închidem designerul schemei de compoziție a datelor și în fereastra de editare a obiectului Listă de servicii, mergeți la fila Subsisteme. În lista subsistemelor de configurare, notați subsistemele Furnizare de servicii și Contabilitate.

În 1C: modul Enterprise

Sa lansam 1C:Enterprise in modul depanare si in primul rand deschidem registrul periodic Preturi. Apoi vom testa raportul.

Folosind acest raport ca exemplu, am studiat modul în care sistemul de compunere a datelor obține cele mai recente valori din registrul de informații periodice și cum sunt afișate grupările în funcție de ierarhia directoarelor.

Dacă publicația mea vă este de folos, nu uitați să-i acordați un plus :-)

Iată un rubricator pentru toate sarcinile din colecție(o pagină care conține link-uri către fire de forum pentru fiecare sarcină)
http://chistov.spb.ru/forum/16-969-1

Ei bine, acum evoluțiile și notele mele pe care le-am creat în timpul procesului de pregătire.
Voi încerca să repet cât mai puțin cu cele două menționate mai sus ultimul publicații.

Asadar, haideti sa începem:

Dacă o luați de la distanță, ar trebui să aveți două obiecte pe desktop la sfârșitul examenului:

1. Încărcarea finală a bazei de informații (fișier dt)
2. Notă explicativă

Nu ar trebui să existe nimic altceva, fără copii intermediare etc.

Asigurați-vă că scrieți o notă explicativă!
În cazul unei sarcini vag formulate, asigurați-vă că scrieți acolo că ați ales exact așa și o variantă de soluție.
De asemenea, în locurile cheie din cod, este mai bine să lăsați comentarii scurte, fără fanatism, dar acolo unde examinatorul poate avea întrebări, este mai bine să scrieți.

Dar despre acest lucru vi se va spune în instrucțiunile pe care vi se vor da să le citiți înainte de examen.
Este mai bine să știi dinainte)

Utilizarea caracterului ampersand în interogări.

Uneori este mai rapid să tastați de pe o tastatură suplimentară decât să comutați aspectul înainte și înapoi, economisind timp
& = Alt+38

*************************************************************************************************
Utilizarea TimePoint() în Interogări

În interogările la registrele de acumulare și contabilitate, este necesar să se folosească nu data documentului ca parametru tabel virtual (perioada), ci parametrul Moment, care este definit în cod după cum urmează:

Moment = ?(Mod de trecere = Modul de înregistrare a documentului. Operațional, Nedefinit, Moment de timp());

*************************************************************************************************
La generarea deplasărilor documentului prin registru, chiar la începutul procedurii de procesare a detașării, este necesară ștergerea mișcărilor documentului curent prin registru.

Codul este:

Movement.RegisterName.Write = Adevărat; Movements.RegisterName.Clear();

Este posibil ca în timpul procesului să fie necesară analizarea înregistrărilor din acest registru.
Deci, pentru ca atunci când analizați înregistrările curente (cele vechi, înainte ca documentul să fie schimbat) cu siguranță să nu fie incluse în eșantion, puteți adăuga încă o linie la cele două rânduri de mai sus:

Movement.RegisterName.Write();

Sau, atunci când analizați înregistrările, indicați în mod explicit o limită care nu include momentul în timp al documentului curent.

Dar peste tot am indicat pur și simplu construcția acestor trei linii:

Movement.RegisterName.Write = Adevărat; Movements.RegisterName.Clear(); Movement.RegisterName.Write();

*************************************************************************************************
Există două moduri de a bloca datele, alegerea dintre ele depinde de metoda utilizată - veche sau nouă:

1) Blocare controlată regulată, metodă veche de procesare a documentelor (obiect de blocare a datelor)

Setați dacă soldurile sunt verificate mai întâi și apoi anulate.
În cazul în care trebuie să avem niște informații din registru pentru a forma o mișcare.

Exemplu:

În document - cantitate, în registru - cantitate și sumă (cost)
Deci, știm cantitatea de mărfuri din document - cât de mult ștergem, dar costul - nu.
O putem afla doar din registru, dar pentru a ne asigura că nimeni nu schimbă registrul între momentul primirii soldurilor și momentul înregistrării mișcărilor, trebuie să blocăm registrul chiar înainte de a citi soldurile.
Deci, în acest caz, este utilizat obiectul Data Locking. Și la crearea acestuia, este mai corect să indicăm prin ce dimensiuni blocăm registrul (de exemplu, în cazul nostru - doar după articolul specificat în document) - astfel încât să nu existe încuietori inutile și un alt utilizator să poată vinde altul articol.

1. Setați o blocare utilizând obiectul Blocare date
2. Citiți restul
3. Verificăm posibilitatea de anulare
4. Creăm mișcări, de exemplu, anulăm bunuri
5. După postarea documentului, blocarea este eliminată automat (blocarea este valabilă ca parte a tranzacției de înregistrare și este eliminată automat de către sistem). Adică, nu este nevoie să deblochezi obiectul în mod special.

2) Noua metodologie de prelucrare a documentelor (folosind proprietatea LockForChange = True)

Se folosește dacă nu avem nevoie de informații din registre pentru a forma mișcări și putem verifica dacă am intrat în negativ la anulare dacă, după înregistrare, ne uităm la soldurile din registru și vedem că sunt negative. . În acest caz, vom înțelege că am anulat prea mult și vom anula operațiunea de anulare.

Exemplu:
Să luăm în considerare operațiunea de vânzare a unui produs.
În document - cantitate, în registru - doar cantitate
Deci, știm cantitatea de mărfuri din document.
Formăm mișcări cu cantitatea specificată în document și le înregistrăm. Apoi, citim registrul, ne uităm la solduri și analizăm dacă există unele negative. Dacă există, afișați o eroare și setați Refuz = Adevărat.

Adică, secvența este astfel:
1. Pentru a vă deplasa prin registru, setați proprietatea BlockForChange = True
2. Creăm mișcări - anulăm bunurile
3. Înregistrați mișcările
4. Citiți registrul și asigurați-vă că nu există solduri negative. Dacă există, atunci au anulat excesul, dacă nu, atunci totul este în regulă.

Deci, în acest caz, nu este nevoie să indicăm după ce dimensiuni trebuie să blocăm registrul.
Pur și simplu setăm proprietatea BlockForChange la True înainte de a ne înregistra mișcările, de a forma mișcările și de a înregistra.
Sistemul în sine va bloca registrul în momentul înregistrării în funcție de măsurătorile necesare, după ce am analizat ceea ce am înregistrat.
Odată finalizată, blocarea va fi eliminată.

Această opțiune (a doua) este mai simplă, se numește „noua metodologie de procesare a documentelor” și 1C recomandă utilizarea ei dacă este posibil și scade puncte dacă se folosește prima opțiune, dar în unele cazuri pur și simplu nu poate fi aplicată, iar prima opțiune cu este utilizat obiectul Data Locking (vezi. exemplul de mai sus).

Mai remarc ca indiferent de metoda aleasa miscarile trebuie curatate inainte de a lucra cu ele (vezi sfaturile anterioare)

*************************************************************************************************
Blocarea datelor (metoda de blocare nr. 1 din descrierea de mai sus)

Blocarea controlată este necesară atunci când datele sunt citite și mișcările sunt efectuate pe baza acestor date
Cea mai rapidă modalitate de a obține codul de blocare gestionat este să introduceți „Data Locking”, să apelați Syntax Assistant și să copiați pur și simplu exemplul de cod de acolo. Apoi pur și simplu schimbați-l cu numele registrului și dimensiunile dvs.

Arata cam asa:

Blocare = NewDataLock; Element de blocare = Locking.Add("Registrul de acumulare.MarfaInDepozite"); LockElement.Mode = DataLockMode.Exclusive; BlockingElement.DataSource = PM; Blocare Element.UseFromDataSource("Nomenclatură", "Nomenclatură"); Lock.Lock();

*************************************************************************************************
Este mai bine să numiți partea tabelară a documentelor pur și simplu „TC”

Există doar o singură parte tabelară în 99% din documente. Un astfel de nume unificat pentru părțile tabulare va ajuta foarte mult la economisirea de timp, deoarece:
1) Foarte scurt - scrie repede
2) La fel pentru toate documentele, nu trebuie să vă amintiți cum se numește atunci când scrieți codul

*************************************************************************************************
Rezultatul interogării ar trebui verificat pentru a nu exista gol înainte de preluare sau încărcare în specificația tehnică.

În general, am folosit eșantionarea în toate sarcinile.

Eșantionarea este mai optimă pentru sistem în ceea ce privește performanța, deoarece este „ascuțită” doar pentru citirea datelor (spre deosebire de TK).

Dar, în orice caz, înainte de metoda Select(), este mai bine să verificați rezultatul interogării pentru gol, acest lucru va reduce și mai mult încărcarea sistemului.

Rezultat = Query.Run(); If Not Result.Empty() Then Select = Result.Select(TravelQueryResult.ByGrouping); ... EndIf;

Și în cazul în care trebuie să obținem o singură valoare din cerere
(de exemplu, doar metoda de anulare în conformitate cu politica contabilă stabilită pentru acest an):

Rezultat = Query.Run(); If Not Result.Empty() Then Select = Result.Select(); Selection.Next(); Metoda de anulare a costurilor = Sample.Cost Write-off Method; endIf;

*************************************************************************************************
Document „Operațiune” pentru o sarcină contabilă

Este necesar să se creeze un document de operare pentru sarcinile contabile.

Dezactivăm total postarea pentru aceasta (în proprietățile „Posting = Deny”), indicăm că face mișcări în registrul contabil și tragem mișcările în formular.

*************************************************************************************************
Prelucrarea promptă a documentelor:

Trebuie să fie inclus:
În operațional și contabil. contabilizarea documentelor trebuie să fie activată (cu excepția documentului „Operare”, vezi mai jos).

Trebuie să fie oprit:
în sarcinile de calcul nu are sens pentru un document de salarizare.

Pentru documentul „Funcționare”, postarea ar trebui să fie complet dezactivată (în proprietățile documentului „Posting = Interzice”),
deoarece scrie pur și simplu scrie date direct în registru atunci când scrie.

*************************************************************************************************
Condiție într-o cerere de forma „Fie nomenclatura specificată sau oricare, dacă nu este specificată”

În interogări, apare următoarea sarcină: de exemplu, trebuie să selectați documentele cu o nomenclatură specificată sau toate documentele dacă nomenclatorul nu este specificat.
Se rezolvă prin următoarea condiție din cererea însăși:

Nomenclatură = &Nomenclatură SAU &Nomenclatură = Valoare(Directory.Nomenclature.EmptyLink)

Dar ar fi mai optim și mai corect să transformăm această condiție (mulțumesc Yukon):

Request.Text = Request.Text + "WHERE Nomenclature = &Nomenclature";

endIf;

Odată cu apariția modelului de obiect de interogare în 8.3.5, va fi posibil să adăugați o condiție mai sigur:

Dacă ValueFilled(Nomenclatură) Atunci
Query1.Selection.Add("Articol = &Nomenclatură");
Request.SetParameter("Nomenclatură", Nomenclatură);
endIf;

*************************************************************************************************
Îmbinarea tabelelor în interogări:

Numărul total de înregistrări nu depinde de afișarea câmpului tabelului alăturat, depinde doar de relațiile configurate.
Adică, câmpul tabelului atașat poate să nu fie afișat.

Dacă doriți să atașați un tabel fără nicio condiție, atunci în fila de condiții scrieți pur și simplu condiția „ADEVĂRAT”.
În acest caz, masa va fi unită exact.

*************************************************************************************************
Folosind planul tipurilor de caracteristici (PVC):

1. Utilizare ca mecanism de descriere a caracteristicilor obiectelor.

1.1. Cream PVC. Acestea vor fi Tipuri de Caracteristici (de exemplu, culoare, dimensiune, viteza max. etc.). În setări, selectați toate tipurile posibile de valori caracteristice și, dacă este necesar, creați obiectul de la punctul 1.2 și indicați-l și în setări.

1.2. Pentru valori suplimentare de PVC, creăm un director subordonat Valori suplimentare ale caracteristicilor (sau pur și simplu Valori ale caracteristicilor).
Va stoca caracteristicile dacă nu sunt în directoare existente. Este posibil să nu îl creăm dacă toate caracteristicile de care avem nevoie sunt în directoare existente sau aceste valori pot fi reprezentate prin tipuri de date elementare. În setările PVC indicăm că acest director va fi folosit în scopuri suplimentare. valorile caracteristicilor.

1.3. Creăm un registru de informații, care conectează de fapt trei obiecte:
- Obiectul la care conectăm mecanismul caracteristicilor
- Tip Caracteristici (tip PVC)
- Valoarea caracteristicilor (tip - caracteristică, acesta este un tip nou care a apărut în sistem după crearea PVC-ului
și descrierea tuturor tipurilor de date posibile pe care le poate lua o valoare caracteristică).
În registrul de informații, indicăm că Tipul Caracteristic este proprietarul pentru Valoarea Caracteristică (link către parametrul de selecție), precum și conexiunea tip pentru Valoarea Caracteristică, din nou din Tipul Caracteristic.

O altă caracteristică este că pentru fiecare tip de caracteristică creat, puteți specifica tipul de valoare caracteristică, dacă nu aveți nevoie de toate tipurile posibile pentru a descrie valoarea acestei caracteristici.

2. Utilizarea PVC pentru a crea un mecanism sub-conto pentru registrul contabil .

2.1. Cream tipuri PVC Subconto.

2.2. Creăm un director subordonat ValuesSubConto (ca și în cazul caracteristicilor, acesta va conține valori subconto dacă nu există în alte directoare).

2.3. Comunicarea se face folosind un plan de conturi.

*************************************************************************************************
Resurse registrului contabil:

Suma - bilant,
Cantitate - în afara bilanţului şi asociată cu caracteristica contabilă Cantitativ

*************************************************************************************************
Tabele registrului contabil virtual:

Cifra de afaceri: cifra de afaceri a unui singur cont
TurnoverDtKt: cifra de afaceri între oricare două conturi, adică toate aceleași tranzacții pentru perioada respectivă.

*************************************************************************************************
Contabilitatea valutară pe registrele contabile - cum se implementează:

Creăm un atribut contabil „monedă” în planul de conturi.
În registrul contabil, creăm suplimentar:
- Dimensiunea valutară (interzicerea valorilor necompletate, în afara bilanţului, atribut contabil - valută)
- resursă CurrencyAmount (în afara bilanțului, atribut contabil - valută, va stoca suma în valută, adică 100 USD de exemplu)
Toate.

Astfel, structura registrului este:

Masuri:
- Moneda
Resurse
- Cantitate
- Suma (suma în ruble)
- CurrencyAmount (suma în valută)

Astfel, contabilitatea valutară este doar o rafinare a contabilității convenționale în Republica Belarus; nu schimbă esența, de exemplu, a resursei Suma
(acolo, ca de obicei, suma este în ruble, indiferent dacă contul este în valută sau nu).
Și dacă funcția de contabilitate valutară este dezactivată pentru cont, atunci aceasta este structura obișnuită a Republicii Belarus (resurse - doar cantitate și sumă).

*************************************************************************************************
Când setăm parametrii unui tabel virtual pentru a obține o felie din acesta din urmă, impunem condiții asupra dimensiunilor, și nu asupra resurselor.

În caz contrar, vom obține nu o felie dintre cele mai recente, ci ultima înregistrare cu valoarea specificată a resursei - este posibil să nu fie ultima din setul de dimensiuni

*************************************************************************************************
Semnificația resursei și detaliile din registrul de calcul

În registrele de calcul, crearea unei resurse face posibilă primirea acesteia la calcularea bazei folosind acest registru.
Și chiar proporțional cu perioada dată, valoarea resursei va fi recalculată (dacă perioada de bază nu coincide cu periodicitatea registrului).

Iar valoarea atributului este disponibilă numai în tabelul real al registrului de calcul; nu este disponibilă în tabelele virtuale.

*************************************************************************************************
Caseta de selectare „De bază” în proprietățile dimensiunii registrului de calcul
Înseamnă că se va obține o bază din această dimensiune în viitor și servește pentru indexarea suplimentară a valorilor pentru acest câmp.

*************************************************************************************************
Defalcarea perioadei de valabilitate a concediului pe lună la înregistrarea seturi de înscrieri în registru,
dacă vacanța este specificată în document pe o singură linie timp de mai multe luni simultan pe o singură linie:

StartDate of CurrentMonth = Începutul lunii(TexLineMainAccruals.ActionPeriodStart); CurrentMonthEndDate = EndMonth(TexLineMainAccruals.ActionPeriodStart); CurrentMonth = Data; WhileDateStartCurrentMonth<= НачалоМесяца(ТекСтрокаОсновныеНачисления.ПериодДействияКонец) Цикл Движение = Движения.ОсновныеНачисления.Добавить(); Движение.Сторно = Ложь; Движение.ВидРасчета = ТекСтрокаОсновныеНачисления.ВидРасчета; Движение.ПериодДействияНачало = Макс(ДатаНачалаТекМесяца, ТекСтрокаОсновныеНачисления.ПериодДействияНачало); Движение.ПериодДействияКонец = КонецДня(Мин(ДатаОкончанияТекМесяца, ТекСтрокаОсновныеНачисления.ПериодДействияКонец)); Движение.ПериодРегистрации = Дата; Движение.Сотрудник = ТекСтрокаОсновныеНачисления.Сотрудник; Движение.Подразделение = ТекСтрокаОсновныеНачисления.Подразделение; Движение.Сумма = 0; Движение.КоличествоДней = 0; Движение.График = ТекСтрокаОсновныеНачисления.График; Движение.Параметр = ТекСтрокаОсновныеНачисления.Параметр; Движение.БазовыйПериодНачало = НачалоМесяца(ДобавитьМесяц(Дата, -3)); Движение.БазовыйПериодКонец = КонецДня(КонецМесяца(ДобавитьМесяц(Дата, -1))); ДатаНачалаТекМесяца = НачалоМесяца(ДобавитьМесяц(ДатаНачалаТекМесяца, 1)); ДатаОкончанияТекМесяца = КонецМесяца(ДатаНачалаТекМесяца); КонецЦикла; КонецЕсли;

*************************************************************************************************
Construirea unei diagrame Gantt:

Plasăm un element de tipul „Diagrama Gantt” pe formular, îl numim DG, apoi creăm comanda „Generare” și scriem următoarele în modulul formular:

&OnClient Procedura Generare(Comandă) GenerareOnServer(); Sfârșitul procedurii &Pe server Procedura GenerateOn Server() DG.Clear(); DG.Actualizare = Fals; Solicitare = Solicitare nouă("SELECT |BasicAccrualsActualActionPeriod.Employee, |BasicAccrualsActualActionPeriod.CalculationType, |BasicAccrualsActualActionPeriod.ActionPeriodStart AS ActionPeriodStart, |BasicAccrualsActualActionPeriod.Period Actions |BasicAccrualsActualActionPeriod.PeriodAccrualsFA |BasicAccrualsActualActionPeriod. dActions AS BasicAccrualsActualPeriodActions |WHERE |BasicAccrualsActualPeriodActions.PeriodActions BETWEEN &StartDate AND &EndDate "); Query.SetParameter("StartDate", Period.StartDate); Request.SetParameter("EndDate", Period.EndDate); Selectare = Query.Run().Select(); While Selection.Next() Loop Point = DG.SetPoint(Selection.Employee); Series = DG.SetSeries(Selection.CalculationType); Valoare = DG.GetValue(Point, Series); Interval = Value.Add(); Interval.Start = Sample.PeriodActionStart; Interval.End = Sample.ActionPeriodEnd; EndCycle; DG.Actualizare = Adevărat; Sfârșitul procedurii

De fapt, doar codul din buclă este important pentru noi aici, restul lucrurilor sunt auxiliare, tocmai am dat întreaga implementare a acestei subsarcini.
În cerere, este important pentru noi să existe un angajat, tipul de plată, data de începere și data de încheiere a perioadei.
Codul este de fapt foarte simplu, ușor de reținut, nu vă alarmați dacă vi se pare greoi

*************************************************************************************************
Procesarea intrărilor „inversare” în sarcinile de calcul:

În procedura de procesare a tranzacțiilor (modul obiect), formăm toate mișcările, iar apoi dacă există înregistrări în alte perioade, le obținem astfel
(sistemul le generează automat - ne ajută):

Înregistrări de adăugare = Movements.MainAccruals.GetAddition(); // Nu este nevoie să înregistrați mișcările pentru a obține adăugarea

Pentru fiecare linie tehnică din ciclul de adăugiri record
Record = Movements.MainAccruals.Add();
FillPropertyValues(Înregistrare, TechString);
Record.RegistrationPeriod = TechString.RegistrationPeriodReversal;
Record.ActionPeriodStart = TechString.ActionPeriodStartReverse;
Record.ActionPeriodEnd = TechString.ActionPeriodEndReversal;
Sfârșitul ciclului

Și când calculați înregistrările, introduceți cecuri:

Dacă TechMotion.Reversal Atunci
CurrentMovement.Sum = - CurrentMovement.Amount;
endIf;

*************************************************************************************************
Cum să determinați ce este inclus în angajamentele principale și ce este inclus în angajamente suplimentare în sarcinile de calcul.

Dar acest lucru nu este întotdeauna 100% clar; există și cazuri mai complicate, deși sunt destul de multe.
(de exemplu, un bonus care depinde de numărul de zile lucrătoare dintr-o lună - acesta este HE).

Taxe de bază:
Dacă tipul de calcul este dependent de orar (adică un registru de informații cu date calendaristice), atunci se referă la taxele principale.

Exemplu OH:
- Salariul
- Ceva care se calculează din numărul de zile lucrătoare (și pentru asta trebuie să folosești un program): fie în perioada de valabilitate (cum ar fi salariul), fie în perioada de bază

Costuri suplimentare:
Ceea ce este considerat fie din suma acumulată, fie timpul LUCRAT (și nu norma!), fie nu depinde deloc - acesta este suplimentar. angajamente.

Adică: angajamentele pentru calculul cărora se folosește standardul de timp (poate și un fapt) este OH și pentru care este nevoie de date reale sau deloc este DN.

Sau cu alte cuvinte:

Dacă VR utilizează un standard de timp, atunci perioada de valabilitate trebuie inclusă pentru VR.

*************************************************************************************************
Adăugați posibilitatea de a deschide secțiunea de ajutor încorporată „Lucrul cu cărți de referință” în forma de listă din directorul „Nomenclatură”.

Rulați comanda pe formular:

&OnClient
Ajutor pentru procedură (comandă)
OpenHelp("v8help://1cv8/EnterprWorkingWithCatalogs");
Sfârșitul procedurii

Definim linia de secțiune după cum urmează:
Accesați informațiile de ajutor ale obiectului de configurare (în configurator), scrieți un cuvânt, selectați-l, accesați meniul Elemente/Link și selectați secțiunea dorită din 1C Help, după care linkul este inserat automat. Pare complicat, dar în practică este ușor.

*************************************************************************************************
Implementarea interacțiunii între formulare, de exemplu, selecția:

1. Din formularul curent, deschideți cel dorit folosind metoda „OpenForm()”, trecând structura cu parametri ca al doilea parametru (dacă este necesar). Al treilea parametru poate transmite un link către acest formular - ThisForm.

2. În formularul deschis, în handlerul „When CreatedOnServer()”, putem prinde parametrii trecuți la pasul 1 prin „Parameters.[ParameterName]”. Formularul care a inițiat deschiderea acestui formular va fi accesibil prin identificatorul „Proprietar” (dacă a fost, desigur, specificat la pasul 1).

Și cel mai important, funcțiile de export ale formularului de proprietar vor fi disponibile. Adică, putem apela funcția de export a formularului sursă și putem trece ceva acolo ca parametru pentru a procesa selecția. Și această funcție va completa deja ceea ce este necesar în formularul original. Există o singură avertizare - nu puteți trece un tabel de valori între procedurile client, dar îl putem plasa în stocare temporară și pur și simplu transmitem adresa VX, apoi o extragem din VX.

*************************************************************************************************
Ciclul de viață al parametrilor de formă

Toți parametrii transferați în formular în momentul deschiderii acestuia sunt vizibili numai în procedura „When CreateOnServer”.
Odată creați, toți parametrii sunt distruși și nu mai sunt disponibili în formular.
Excepția este pentru parametrii care sunt declarați în editorul de formulare cu atributul „Parametru cheie”.
Ele determină unicitatea formei.
Acest parametru va exista atâta timp cât există forma în sine.

*************************************************************************************************
Folosind interfața Taxi

În timpul dezvoltării, puteți seta interfața gestionată obișnuită 8.2 în proprietățile de configurare - acest lucru face ca totul să fie vizibil mai compact și mai familiar.
Acest lucru este valabil mai ales dacă închiriați de la distanță - rezoluția ecranului este foarte mică și este imposibil să faceți ceva cu interfața „taxi”.
Nu uitați să puneți din nou „Taxi” când ați terminat!În caz contrar, examinatorul va deduce puncte!

*************************************************************************************************

PS: E Există subtask-uri standard separate care sunt utilizate în toate sarcinile și acestea sunt pe care trebuie să le puteți rezolva (de exemplu, eliminarea pe loturi, utilizarea PVC-ului (ei bine, acest lucru este foarte rar) și altele). Și în toate sarcinile sunt pur și simplu repetate (undeva sunt niște subsarcini, altundeva, doar în combinații diferite). Mai mult decât atât, au promis de mult timp să lanseze o nouă colecție (dacă nu au făcut-o deja), în care ar trebui să existe mult mai multe probleme, adică nu are rost să memorezi soluții la probleme individuale, este logic să înveți cum să rezolvați subsarcini standard individuale, apoi veți rezolva orice problemă.

PSS: Colegi, dacă are cineva alte informații utile despre pregătirea pentru examen și promovarea acestuia, vă rugăm să scrieți în comentarii și vom adăuga la articol.