heim Instagram

1c virtueller Tischsaldo und Umsatz. Registerkarte „Abfragestapel“.

Ich beschloss, meinen Beitrag zu leisten und die Merkmale der Sprache zu beschreiben, die in den obigen Artikeln nicht besprochen wurden. Der Artikel richtet sich an Anfängerentwickler.

1. „IZ“-Design.

Um Daten aus der Datenbank zu erhalten, ist es überhaupt nicht notwendig, die „FROM“-Konstruktion zu verwenden.
Beispiel: Wir müssen alle Informationen über Banken aus dem Bankenverzeichnis auswählen.
Anfrage:

SELECT Verzeichnis.Banken.*

Wählt alle Felder aus dem Bankenverzeichnis aus. Und ähnelt der Anfrage:

SELECT Banks.* FROM Directory.Banks AS Banks

2. Daten nach Referenzfeld bestellen

Wenn wir Abfragedaten nach primitiven Typen organisieren müssen: „String“, „Number“, „Datum“ usw., dann wird alles durch die Verwendung des Konstrukts „ORDER BY“ gelöst. Wenn Sie die Daten nach einem Referenzfeld ordnen müssen? Das Referenzfeld ist ein Link, eine eindeutige Kennung, d.h. Grob gesagt kann ein beliebiger Zeichensatz und eine gewöhnliche Reihenfolge zu einem Ergebnis führen, das nicht ganz erwartet wird. Um Referenzfelder zu ordnen, wird die „AUTO ORDER“-Konstruktion verwendet. Dazu müssen Sie die Daten zunächst direkt nach dem Referenztyp mit der „ORDER BY“-Konstruktion und dann mit der „AUTO ORDER“-Konstruktion ordnen.

In diesem Fall erfolgt die Sortierung bei Dokumenten in der Reihenfolge „Datum->Nummer“, bei Fachbüchern in der „Hauptansicht“. Wenn die Sortierung nicht nach Referenzfeldern erfolgt, wird die Verwendung der „AUTO ORDER“-Konstruktion nicht empfohlen.

In manchen Fällen kann das „AUTO ORDER“-Konstrukt den Auswahlprozess verlangsamen. Ebenso können Sie Dokumente ohne automatische Reihenfolge umschreiben:

3.Erhalten einer Textdarstellung eines Referenztyps. Design „PRÄSENTATION“.

Wenn Sie ein Feld eines Referenztyps anzeigen müssen, beispielsweise das Feld „Bank“, das einen Link zu einem Element des Verzeichnisses „Banken“ darstellt, müssen Sie verstehen, dass beim Anzeigen dieses Felds eine Unterabfrage zum „ Das Verzeichnis „Banken“ wird automatisch ausgeführt, um eine Ansicht des Verzeichnisses zu erhalten. Dadurch wird die Datenausgabe verlangsamt. Um dies zu vermeiden, müssen Sie in der Anfrage die Konstruktion „PRÄSENTATION“ verwenden, um sofort eine Darstellung des Objekts zu erhalten und diese dann zur Ansicht anzuzeigen.

Im Datenkompositionssystem wird dieser Mechanismus standardmäßig verwendet, aber beim Erstellen von Layouts in Zellen sollten Sie die Darstellung des Referenzfelds angeben und beispielsweise den Link selbst im Transkript platzieren.

4. Voraussetzung für die Datenerfassung gemäß einer Vorlage.

Beispielsweise benötigen Sie Mobiltelefone von Mitarbeitern des Formulars (8 -123- 456-78-912). Dazu müssen Sie in der Anfrage folgende Bedingung setzen:

SELECT Employee.Name, Employee.Phone AS Phone FROM Directory.Employees AS Employees WHERE Phone LIKE „_-___-___-__-__“

Das Zeichen „_“ ist ein Dienstzeichen und ersetzt jedes beliebige Zeichen.

5. Gleichzeitige Verwendung von Summen und Gruppierungen.

Summen werden häufig in Verbindung mit Gruppierungen verwendet; in diesem Fall dürfen in den Summen keine Aggregatfunktionen angegeben werden.

SELECT Bereitstellung von Diensten.Organisation AS Organisation, Bereitstellung von Diensten.Nomenklatur AS Nomenklatur, SUM(Bereitstellung von Diensten.Menge des Dokuments) AS Summe des Dokuments FROM Dokument.Erbringung von Diensten AS Bereitstellung von Diensten GRUPPE NACH Bereitstellung von Diensten.Organisation, Bereitstellung of Services.Nomenclature ERGEBNISSE NACH ALLGEMEINEM, Organisation, Nomen klatura

In diesem Fall wird die Abfrage fast dasselbe zurückgeben wie die folgende Abfrage:

AUSWÄHLEN Bereitstellung von Dienstleistungen.Organisation AS Organisation, Bereitstellung von Dienstleistungen.Nomenklatur AS Nomenklatur, Bereitstellung von Dienstleistungen.Menge des Dokuments AS Menge des Dokuments VON Dokument.Erbringung von Dienstleistungen AS Erbringung von Dienstleistungen ERGEBNISSE MENGE (Menge des Dokuments) NACH ALLGEMEIN, Organisation, Nomenklatur

Nur bei der ersten Abfrage werden Datensätze mit derselben Nomenklatur ausgeblendet.

6. Felder dereferenzieren.

Das Verweisen auf Felder durch einen Punkt wird als Referenzfeld-Dereferenzierungsvorgang bezeichnet. Zum Beispiel Zahlungsorganisation.Verwaltungseinheit. In diesem Fall wird im Referenzfeld „Organisation“ des Dokuments „Zahlung“ auf eine andere Tabelle „Organisationen“ verwiesen, in der der Wert des Attributs „Verwaltungseinheit“ ermittelt wird. Es ist wichtig zu verstehen, dass die Plattform beim Zugriff auf Felder über einen Punkt implizit eine Unterabfrage erstellt und diese Tabellen verknüpft.

Anfrage:

Kann dargestellt werden als:

WÄHLEN Sie „Payment.Link“, „Payment.Organization“, „Payment.Organization“, „Organisationen“. AdministrativeUnit FROM Document.Payment AS Payment LEFT JOIN Directory.Organizations AS Organizations Software Payment.Organization = Organizations.Link

Beim Dereferenzieren von Referenzfeldern eines zusammengesetzten Typs versucht das Framework, implizite Verknüpfungen zu allen Tabellen zu erstellen, die Teil des Typs dieses Felds sind. In diesem Fall ist die Abfrage nicht optimal. Wenn klar ist, um welche Art von Feld es sich handelt, ist es notwendig, solche Felder mit einem Konstrukt nach Typ einzuschränken ÄUSSERN().

Beispielsweise gibt es ein Sammelregister „Nicht verteilte Zahlungen“, in dem mehrere Dokumente als Registrar fungieren können. In diesem Fall ist es falsch, die Werte der Registrardaten auf diese Weise zu ermitteln:

SELECT UnallocatedPayments.Register.Date, ..... FROM RegisterAccumulation.UnallocatedPayments AS UnallocatedPayments

Sie sollten den Typ des zusammengesetzten Felds auf Logger beschränken:

SELECT EXPRESS(UnallocatedPayments.Register AS Document.Payment).Date, ..... FROM RegisterAccumulation.UnallocatedPayments AS UnallocatedPayments

7. Konstruktion „WO“

Wenn Sie bei einer linken Verknüpfung zweier Tabellen eine „WHERE“-Bedingung auf die rechte Tabelle anwenden, erhalten wir ein Ergebnis, das dem Ergebnis einer inneren Verknüpfung von Tabellen ähnelt.

Beispiel. Es ist notwendig, alle Kunden aus dem Kundenverzeichnis auszuwählen und für diejenigen Kunden, die über einen Zahlungsbeleg mit dem Wert des Attributs „Organisation“ = &Organisation verfügen, das Dokument „Zahlung“ anzuzeigen, für diejenigen, die kein Zahlungsdokument haben, wird es nicht angezeigt.

Das Ergebnis der Abfrage gibt nur Datensätze für die Kunden zurück, die im Parameter „Zahlung nach Organisation“ angegeben haben, und andere Kunden werden herausgefiltert. Daher müssen Sie zunächst alle Zahlungen für „so und so“-Organisation in einer temporären Tabelle erhalten und diese dann über einen Left-Join mit dem Verzeichnis „Kunden“ verbinden.

SELECT Payment.Link AS Payment, Payment.Shareholder AS Client PLACE toPayments FROM Document.Payment AS Payment WHERE Payment.Branch = &Branch; ///////////////////////////////////////////// // ////////////////////////// SELECT Clients.Link AS Client, ISNULL(tPayment.Payment, "") AS Payment FROM Directory .Clients AS Clients VERLASSEN VERBINDUNG zu payment AS to payment SOFTWARE Clients.Link = to payments.Client

Sie können diesen Zustand auf andere Weise umgehen. Es ist notwendig, eine „WHERE“-Bedingung direkt auf die Beziehung zwischen den beiden Tabellen anzuwenden. Beispiel:

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. Verknüpfung

8. Verknüpfungen mit verschachtelten und virtuellen Tabellen

Verschachtelte Abfragen Oft ist es erforderlich, Daten basierend auf einer bestimmten Bedingung abzurufen. Wenn Sie sie dann in Verbindung mit anderen Tabellen verwenden, kann dies die Ausführung der Abfrage kritisch verlangsamen.

Beispielsweise benötigen wir für einige Kunden den Restbetrag zum aktuellen Datum.

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.Balances AS UnallocatedPayments BY Nested Request.Link = UnallocatedPaymentsBalances. Kunde

Beim Ausführen einer solchen Abfrage kann es sein, dass der DBMS-Optimierer bei der Auswahl eines Plans Fehler macht, was zu einer suboptimalen Ausführung der Abfrage führt. Beim Verbinden zweier Tabellen wählt der DBMS-Optimierer einen Tabellenverknüpfungsalgorithmus basierend auf der Anzahl der Datensätze in beiden Tabellen aus. Bei einer verschachtelten Abfrage ist es äußerst schwierig, die Anzahl der Datensätze zu bestimmen, die die verschachtelte Abfrage zurückgibt. Daher sollten Sie immer temporäre Tabellen anstelle von verschachtelten Abfragen verwenden. Schreiben wir also die Anfrage neu.

SELECT Clients.Link AS Link PLACE tClients FROM Directory.Clients AS Clients WHERE
Clients.Link B (&Clients) ; ///////////////////////////////////////////// // ////////////////////////////////// SELECT tClients.Link, UnallocatedPaymentsRemains.AmountRemaining, FROM tClients AS tClients LEFT JOIN RegisterAccumulations.UnallocatedPayments.Balances (, Client IN (SELECT tClients.Link FROM tClients)) AS UnallocatedPaymentsBalances tClients.Link = UnallocatedPaymentsBalances.Clients

In diesem Fall kann der Optimierer bestimmen, wie viele Datensätze die temporäre Tabelle tClients verwendet, und den optimalen Algorithmus zum Zusammenführen von Tabellen auswählen.

Virtuelle Tische ermöglichen es Ihnen, praktisch vorgefertigte Daten für die meisten Anwendungsaufgaben zu erhalten. (Slice of the First, Slice of the Last, Remains, Turnovers, Remains und Turnovers) Das Schlüsselwort hier ist virtuell. Diese Tabellen sind nicht physisch, sondern werden vom System im laufenden Betrieb zusammengestellt, d. h. Beim Empfang von Daten aus virtuellen Tabellen sammelt das System Daten aus den Endregistertabellen, stellt sie zusammen, gruppiert sie und gibt sie an den Benutzer aus.

Diese. Beim Herstellen einer Verbindung zu einer virtuellen Tabelle wird eine Verbindung zu einer Unterabfrage hergestellt. In diesem Fall wählt der DBMS-Optimierer möglicherweise auch einen nicht optimalen Verbindungsplan. Wenn die Abfrage nicht schnell genug generiert wird und die Abfrage Verknüpfungen in virtuellen Tabellen verwendet, empfiehlt es sich, den Zugriff auf die virtuellen Tabellen auf eine temporäre Tabelle zu verlagern und dann eine Verknüpfung zwischen zwei temporären Tabellen durchzuführen. Schreiben wir die vorherige Anfrage neu.

SELECT Clients.Link AS Link PLACE tClients FROM Directory.Clients AS Clients INDEX BY Link WHERE
Clients.Link B (&Clients) ; ///////////////////////////////////////////// // ///////////////////////////////// SELECT UnallocatedPayments.AmountBalance, UnallocatedPayments.Client AS Client PLACE salden FROM RegisterAccumulations.UnallocatedPayments.Balances(, Client B ( SELECT tClients. Link FROM tClients)) AS UnallocatedPaymentsBalances; ///////////////////////////////////////////// // ////////////////////////////////// SELECT tClients.Link, toRemainders.AmountRemaining AS AmountRemaining FROM tClients AS tClients LEFT JOIN toRemainders AS Remainders BY tClients.Link = tRemainings.Client

9.Überprüfung des Ergebnisses der Anfrage.

Das Ergebnis der Abfrage kann leer sein. Um nach leeren Werten zu suchen, verwenden Sie das folgende Konstrukt:

ResRequest = Request.Execute(); If resQuery.Empty() Then Return; endIf;

Methode Leer() sollte vor Methoden verwendet werden Wählen() oder Entladen(), da das Abrufen der Sammlung einige Zeit in Anspruch nimmt.

Es ist für niemanden eine Offenbarung, dass es äußerst unerwünscht ist, Abfragen in einer Schleife zu verwenden. Dies kann die Betriebszeit einer bestimmten Funktion entscheidend beeinflussen. Es ist äußerst wünschenswert, alle Daten in der Anfrage zu empfangen und sie dann in einer Schleife zu verarbeiten. Aber manchmal gibt es Fälle, in denen es unmöglich wird, die Anfrage aus der Schleife zu verschieben. In diesem Fall können Sie zur Optimierung die Erstellung der Abfrage außerhalb der Schleife verschieben und in der Schleife die erforderlichen Parameter ersetzen und die Abfrage ausführen.

Dies erspart dem System die Syntaxprüfung der Anfrage in einer Schleife.

11. Konstruktion „HABEN“.

Ein Design, das bei Anfragen eher selten vorkommt. Ermöglicht das Auferlegen von Bedingungen für die Werte von Aggregatfunktionen (SUMME, MINIMUM, MITTELWERT usw.). Beispielsweise müssen Sie nur die Kunden auswählen, deren Zahlungsbetrag im September mehr als 13.000 Rubel betrug. Wenn Sie die Bedingung „WHERE“ verwenden, müssen Sie zunächst eine temporäre Tabelle oder eine verschachtelte Abfrage erstellen, dort Datensätze nach Zahlungsbetrag gruppieren und dann die Bedingung anwenden. Die „HAVING“-Konstruktion hilft dabei, dies zu vermeiden.

SELECT Payment.Customer, AMOUNT(Payment.Amount) AS Amount FROM Document.Payment AS Payment WHERE MONTH(Payment.Date) = 9 GROUP BY Payment.Customer HAVING AMOUNT(Payment.Amount) > 13000

Gehen Sie dazu im Konstruktor einfach auf die Registerkarte „Bedingungen“, fügen Sie eine neue Bedingung hinzu und aktivieren Sie das Kontrollkästchen „Benutzerdefiniert“. Dann schreib einfach Betrag(Zahlungsbetrag) > 13000

12. NULL-Wert

Ich werde hier nicht die Prinzipien der dreiwertigen Logik in der Datenbank beschreiben; es gibt viele Artikel zu diesem Thema. Nur kurz zum Wie NULL kann sich auf das Ergebnis der Abfrage auswirken. Der Wert NULL ist eigentlich kein Wert und die Tatsache, dass der Wert undefiniert ist, ist unbekannt. Daher gibt jede Operation mit NULL NULL zurück, sei es Addition, Subtraktion, Division oder Vergleich. Ein NULL-Wert kann nicht mit einem NULL-Wert verglichen werden, da wir nicht wissen, was wir vergleichen sollen. Diese. Beide Vergleiche lauten: NULL = NULL, NULL<>NULL ist nicht wahr oder falsch, es ist unbekannt.

Schauen wir uns ein Beispiel an.

Für Kunden, die keine Zahlungen haben, müssen wir das Feld „Signieren“ mit dem Wert „Keine Zahlungen“ anzeigen. Darüber hinaus wissen wir mit Sicherheit, dass wir solche Kunden haben. Und um die Essenz dessen wiederzugeben, was ich oben geschrieben habe, machen wir es so.

SELECT „Keine Zahlungen“ als Attribut, NULL als Dokument PLATZ für Zahlungen; ///////////////////////////////////////////// // ///////////////////////// SELECT Clients.Link AS Client, Payment.Link HOW Payment PUT tClientPayment FROM Directory.Clients AS Clients LEFT CONNECTION Document. Payment AS Zahlungssoftware Clients.Link = Payment.Shareholder; ///////////////////////////////////////////// // /////////////////////////// SELECT tClientPayment.Client FROM tClientPayment AS tClientPayment INTERNAL JOIN tPayment AS tTopay BY tClientPayment.Payment = tPayment. Dokument

Achten Sie auf die zweite temporäre Tabelle tClientPayment. Mit der linken Verknüpfung wähle ich alle Kunden und alle Zahlungen für diese Kunden aus. Für Kunden, die keine Zahlungen haben, ist das Feld „Zahlung“ NULL. Der Logik folgend habe ich in der ersten temporären Tabelle „tPayments“ zwei Felder festgelegt, eines davon NULL, die zweite Zeile „Hat keine Zahlungen“. In der dritten Tabelle verbinde ich die Tabellen „tClientPayment“ und „tPayment“ über die Felder „Payment“ und „Document“ mit einem internen Join. Wir wissen, dass in der ersten Tabelle das Feld „Dokument“ NULL ist und in der zweiten Tabelle diejenigen, die keine Zahlungen im Feld „Zahlung“ haben, ebenfalls NULL sind. Was wird uns eine solche Verbindung bringen? Aber es wird nichts zurückgegeben. Weil der Vergleich NULL = NULL nicht zu True führt.

Damit die Anfrage das erwartete Ergebnis zurückgibt, schreiben wir sie um:

SELECT „Keine Zahlungen“ AS Attribute, VALUE(Document.Payment.EmptyLink) AS Document PLACE toPayments; ///////////////////////////////////////////// // ////////////////////////// SELECT Clients.Link AS Client, ISNULL(Payment.Link, VALUE(Document.Payment.EmptyLink)) WIE Payment PUT tClientPayment FROM Directory.Clients AS Clients LEFT CONNECTION Document.Payment AS Payment BY Clients.Link = Payment.Shareholder; ///////////////////////////////////////////// // /////////////////////////// SELECT tClientPayment.Client FROM tClientPayment AS tClientPayment INTERNAL JOIN tPayment AS tTopay BY tClientPayment.Payment = tPayment. Document

Nun haben wir in der zweiten temporären Tabelle angegeben, dass, wenn das Feld „Zahlung“ NULL ist, dieses Feld = ein leerer Link zum Zahlungsbeleg. In der ersten Tabelle haben wir NULL auch durch eine leere Referenz ersetzt. Jetzt umfasst die Verbindung Nicht-NULL-Felder und die Anfrage gibt das erwartete Ergebnis zurück.

Alle im Artikel enthaltenen Anfragen spiegeln die Situationen wider, die ich berücksichtigen möchte, und nicht mehr. UM Sie dürfen nicht wahnhaft oder suboptimal sein, Hauptsache sie spiegeln die Essenz des Beispiels wider.

13. Eine undokumentierte Funktion des „WAHL WHEN...DANN...ENDE“-Designs.

Für den Fall, dass es notwendig ist, die Konstruktion „Bedingungen“ in der Anfrage zu beschreiben, verwenden wir die Standardsyntax:

SELECT SELECTION WHEN Users.Name = „Vasya Pupkin“ THEN „Unser Lieblingsmitarbeiter“ ELSE „Wir wissen das nicht“ END AS Field1 FROM Directory.Users AS Users

Was aber, wenn wir beispielsweise in einer Anfrage den Namen des Monats erhalten müssen? Eine umfangreiche Konstruktion in einer Anfrage zu schreiben ist hässlich und zeitaufwändig, daher kann uns diese Form des Schreibens oben helfen:

SELECT MONTH(US_CalculationConsumption_ScheduleTurnover.CalculationPeriod) WANN 1, DANN „Januar“, WANN 2, DANN „Februar“, WANN 3, DANN „März“, WANN 4, DANN „April“, WANN 5, DANN „Mai“, WANN 6, DANN „Juni“, WANN 7, DANN „Juli“ K WANN 8, DANN „August“, WANN 9, DANN „September“, WANN 10, DANN „Oktober“, WANN 11, DANN „November“, WANN 12, DANN „Dezember“, ENDE ALS EIN Monat

Jetzt sieht das Design weniger umständlich aus und ist leicht verständlich.

14. Ausführung der Batch-Abfrage.

Um Anfragen nicht zu vervielfachen, können Sie eine große Anfrage erstellen, diese in Pakete aufteilen und damit arbeiten.
Beispielsweise muss ich die folgenden Felder aus dem Verzeichnis „Benutzer“ abrufen: „Geburtsdatum“ und die verfügbaren Rollen für jeden Benutzer. Laden Sie dies in verschiedene tabellarische Teile des Formulars hoch. Natürlich können Sie dies in einer einzigen Anfrage tun, dann müssen Sie die Datensätze durchlaufen oder sie reduzieren, oder Sie können Folgendes tun:

SELECT Users.Link AS Vollständiger Name, Users.Geburtsdatum, Users.Role PUT vtUsers FROM Directory.Users AS Users; ////////////////////////////////////////////////// ////////////////////////////// ВЫБРАТЬ втПользователи.ФИО, втПользователи.ДатаРождения ИЗ втПользователи КАК втПользователи СГРУППИРОВАТЬ ПО втПользователи.ФИО, втПользователи. Geburtsdatum; ////////////////////////////////////////////////// ////////////////////////////// ВЫБРАТЬ втПользователи.ФИО, втПользователи.Роль ИЗ втПользователи КАК втПользователи СГРУППИРОВАТЬ ПО втПользователи.ФИО, втПользователи. Geburtsdatum

tPackage = Request.ExecutePackage();

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

Wie wir sehen, kann die Abfrage im Stapel ausgeführt und das Ergebnis als Array verarbeitet werden. In manchen Fällen ist es sehr praktisch.

15. Bedingungen in einer Batch-Anfrage

Zum Beispiel haben wir eine Batch-Anfrage, bei der wir zunächst die Felder „Name, Geburtsdatum, Code“ aus dem Verzeichnis „Benutzer“ abrufen und Datensätze mit Bedingungen für diese Felder aus dem Verzeichnis „Einzelpersonen“ abrufen möchten.

SELECT Users.Individual.Name AS Name, Users.Individual.Date of Birth AS Geburtsdatum, Users.Individual.Code AS Code PLACE vtUsers FROM Directory.Users AS Users; ///////////////////////////////////////////// // ////////////////////////// Einzelpersonen auswählen. Als Einzelperson aus dem Verzeichnis verknüpfen. Einzelpersonen als Einzelpersonen

Sie können Bedingungen wie diese auferlegen:

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)

Und Sie können es so machen:

WHERE (Individuals.Code, Individuals.Name, Individuals.Geburtsdatum) IN (SELECT tueUsers.Code, tueUsers.Name, tueUsers.Geburtsdatum FROM tueUsers)

Darüber hinaus ist es notwendig, die Ordnung aufrechtzuerhalten.

16. Aufrufen des Abfrage-Generators für „Bedingung“ in einer Batch-Anfrage

Wenn es notwendig ist, eine Bedingung festzulegen, wie im obigen Beispiel, können Sie vergessen, wie dieses oder jenes Feld in der virtuellen Tabelle aufgerufen wird.
Sie müssen beispielsweise eine Bedingung für das Feld „Geburtsdatum“ festlegen, und in der virtuellen Tabelle heißt dieses Feld „Geburtsdatum des Schuldners“. Wenn Sie den Namen vergessen, müssen Sie die Bearbeitung der Bedingung ohne verlassen Speichern Sie und sehen Sie sich den Namen des Feldes an. Um dies zu vermeiden, können Sie die folgende Technik verwenden.

Es ist notwendig, nach der Konstruktion „B“ Klammern einzufügen und zwischen den Klammern ein Leerzeichen (Leerzeichen) zu lassen, dieses Leerzeichen auszuwählen und den Abfragekonstruktor aufzurufen. Der Designer hat Zugriff auf alle Tabellen der Batch-Abfrage. Die Technik funktioniert sowohl auf virtuellen Registertabellen als auch auf der Registerkarte „Bedingungen“. Im letzteren Fall müssen Sie das Kontrollkästchen „P (willkürliche Bedingung)“ aktivieren und in den Bearbeitungsmodus „F4“ wechseln.

Die Fragen wurden oft spontan gestellt und dienen lediglich dazu, die „Techniken“ zu veranschaulichen, die ich in Betracht gezogen habe.

Ich wollte mir die Verwendung von Indizes in Abfragen ansehen, aber das ist ein sehr weit gefasstes Thema. Ich werde es in einen separaten Artikel einfügen oder es später hier hinzufügen.

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

Gebrauchte Bücher:
Abfragesprache „1C:Enterprise 8“ – E.Yu. Chrustalewa
Berufliche Weiterentwicklung im 1C:Enterprise 8-System.“

Bei der Organisation von Stichproben in realen Problemen wird die Datenauswahl in den allermeisten Fällen nach bestimmten Kriterien organisiert.

Wenn die Auswahl anhand einer echten Tabelle erfolgt, treten keine Schwierigkeiten auf. Die Datenverarbeitung erfolgt absolut trivial:

Wenn die Quelle in der Abfrage eine virtuelle Tabelle ist, wird die Situation etwas komplizierter.

Mit der Abfragesprache können Sie einer Auswahl aus virtuellen Tabellen auf zwei Arten eine Bedingung auferlegen: in der WHERE-Klausel und mithilfe virtueller Tabellenparameter. Beide Methoden führen (mit Ausnahme einiger Einzelfälle) zum gleichen Ergebnis, sind aber dennoch bei weitem nicht gleichwertig.

Wir wissen bereits, dass virtuelle Tabellen als virtuell bezeichnet werden, weil sie sich tatsächlich nicht in der Datenbank befinden. Sie werden erst in dem Moment gebildet, in dem eine Anfrage an sie gestellt wird. Trotzdem ist es für uns (also diejenigen, die die Abfrage schreiben) bequem, virtuelle Tabellen als reale Tabellen zu betrachten. Was passiert im 1C Enterprise 8-System, wenn die von uns kompilierte Abfrage immer noch auf die virtuelle Tabelle zugreift?

Im ersten Schritt erstellt das System eine virtuelle Tabelle. Im zweiten Schritt werden aus der resultierenden Tabelle Datensätze ausgewählt, die die in der WHERE-Klausel angegebene Bedingung erfüllen:
Es ist deutlich zu erkennen, dass die endgültige Stichprobe nicht alle Datensätze aus der virtuellen Tabelle (und damit aus der Datenbank) umfassen wird, sondern nur diejenigen, die die gegebene Bedingung erfüllen. Und die restlichen Datensätze werden einfach aus dem Ergebnis ausgeschlossen.

Somit wird das System nicht nur nutzlose Arbeit leisten, sondern doppelt nutzlose Arbeit! Zunächst werden Ressourcen für den Aufbau einer virtuellen Tabelle auf der Grundlage unnötiger Daten aufgewendet (in der Abbildung sind sie als „Datenbereiche A und B“ gekennzeichnet), und dann wird daran gearbeitet, diese Daten aus dem Endergebnis herauszufiltern.

Durch die Parametrisierung einer virtuellen Tabelle begrenzen wir sofort die Datenmenge, die von der Abfrage verarbeitet wird.

Was ist der Unterschied zwischen den Werten des virtuellen Tabellenparameters „Additionsmethode“?
Wenn die Additionsmethode auf „Bewegungen“ eingestellt ist, werden nur die Zeiträume zurückgegeben, in denen es Bewegungen gab. Wenn „Bewegungen und Periodengrenzen“ eingestellt ist, werden den oben genannten Bewegungen zwei Datensätze hinzugefügt: Bewegungen am Anfang und am Ende der in den VT-Parametern angegebenen Periode. Das Feld „Registrar“ ist für diese beiden Datensätze leer.

Informationen stammen von der Website

Bei der Organisation von Stichproben in realen Problemen wird die Datenauswahl in den allermeisten Fällen nach bestimmten Kriterien organisiert.

Wenn die Auswahl anhand einer echten Tabelle erfolgt, treten keine Schwierigkeiten auf. Die Datenverarbeitung erfolgt absolut trivial:

Wenn die Quelle in der Abfrage eine virtuelle Tabelle ist, wird die Situation etwas komplizierter.

Im ersten Schritt erstellt das System eine virtuelle Tabelle. Im zweiten Schritt werden aus der resultierenden Tabelle Datensätze ausgewählt, die die in der WHERE-Klausel angegebene Bedingung erfüllen:

Es ist deutlich zu erkennen, dass die endgültige Stichprobe nicht alle Datensätze aus der virtuellen Tabelle (und damit aus der Datenbank) umfassen wird, sondern nur diejenigen, die die gegebene Bedingung erfüllen. Und die restlichen Datensätze werden einfach aus dem Ergebnis ausgeschlossen.

Ist es möglich, bereits beim Erstellen einer virtuellen Tabelle auf die Verwendung unnötiger Daten zu verzichten? Es stellt sich heraus, dass es möglich ist. Genau hierfür sind die Parameter der virtuellen Tabelle gedacht:

Durch die Parametrisierung einer virtuellen Tabelle begrenzen wir sofort die Datenmenge, die von der Abfrage verarbeitet wird.

Rufen wir den Dialog zur Eingabe von Parametern der virtuellen Tabelle PriceSliceLast auf und geben an, dass der Zeitraum im Parameter ReportDate übergeben wird. Wählen Sie dazu diese Tabelle in der Tabellenliste aus und klicken Sie auf die Schaltfläche Optionen für virtuelle Tabellen. Wählen Sie dann die folgenden Felder aus den Tabellen aus:

SprNomenklatur. Elternteil,

PreiseSlice of Latest.Price.

Linker Tabellenbeitritt

- Auf dem Lesezeichen Verbindungen: im Feld Verknüpfungsbedingung, dass der Wert der Nomenklaturdimension des Informationsregisters gleich der Referenz auf das Nomenklaturverzeichniselement sein muss. Deaktivieren Sie außerdem das Kontrollkästchen „Alle“ für die Registertabelle und aktivieren Sie es für die Nachschlagetabelle, wodurch der Verbindungstyp als linke Verbindung für die Nachschlagetabelle festgelegt wird:

Reis. 13.15. Beziehung zwischen Tabellen in einer Abfrage

- Auf dem Lesezeichen Bedingungen Legen wir die Bedingung für die Auswahl von Elementen aus dem Nomenklaturverzeichnis fest – die ausgewählten Elemente müssen dem Nomenklaturtyp entsprechen, der im Anforderungsparameter „Nomenklaturtyp“ übergeben wurde:

Reis. 13.16. Bedingungen für die Auswahl von Elementen

- Auf dem Lesezeichen Gewerkschaften/Aliase: Geben Sie den Alias des Feldes Parent = Service Group und des Feldes Link = Service an. - OK klicken-

Anschließend müssen Sie das Datenlayout-Schema bearbeiten, indem Sie dies auf der Registerkarte tun Ressourcen, klicken Sie auf die Schaltfläche hinzufügen und wählen Sie eine Ressource aus - Preis

- Auf dem Lesezeichen Optionen Legen Sie den Wert des Nomenclature Type-Parameters fest – Enumeration.Nomenclature Types.Service. Darüber hinaus werden wir die Verfügbarkeitsbeschränkung für den ReportDate-Parameter entfernen. Legen Sie im Feld Typ dieses Parameters die Zusammensetzung des Datums fest – Datum. Für den Parameter „Periode“ hingegen legen wir eine Verfügbarkeitsbeschränkung fest:

Reis. 13.17. Layout-Schema-Optionen

Einstellungen

- Gehen wir zum Lesezeichen Einstellungen: Erstellen wir eine Gruppierung basierend auf dem Feld „Dienstgruppe“ und geben dabei den Gruppierungstyp „Hierarchie“ an.

Für Berichtsgruppierungen gibt es folgende Hierarchietypen: Ohne Hierarchie – in der Gruppierung werden nur nicht hierarchische Datensätze angezeigt. Hierarchie – in der Gruppierung werden sowohl nicht-hierarchische als auch hierarchische Datensätze angezeigt. Nur Hierarchie: In der Gruppierung werden nur hierarchische (übergeordnete) Datensätze angezeigt. Innerhalb dieser Gruppe erstellen wir eine weitere, ohne das Gruppenfeld anzugeben. Auf der Unterregisterkarte Ausgewählte Felder: Geben Sie die Ausgabefelder Service und Preis an:

Reis. 13.18. Berichtsstruktur und Felder

Auf der Unterregisterkarte Andere Einstellungen werden wir die folgenden Schritte durchführen:

Reis. 13.19. Einstellungen zur Anzeige allgemeiner Summen für die Gruppierung „Servicegruppe“.

Reis. 13.20. Einrichten und Anzeigen von Ergebnissen für einen globalen Bericht

Abschließend fügen wir den Parameter „Berichtsdatum“ in die Benutzereinstellungen ein und stellen den Bearbeitungsmodus auf „Schnellzugriff“ ein. Schließen wir den Datenkompositionsschema-Designer und gehen Sie im Fenster zum Bearbeiten des Objekts „Liste der Dienste“ zur Registerkarte „Subsysteme“. Beachten Sie in der Liste der Konfigurationssubsysteme die Subsysteme Service Provision und Accounting.

Im 1C: Enterprise-Modus

Starten wir 1C:Enterprise im Debug-Modus und öffnen wir zunächst das periodische Register Preise. Dann werden wir den Bericht testen.

Am Beispiel dieses Berichts haben wir untersucht, wie das Datenzusammensetzungssystem die neuesten Werte aus dem periodischen Informationsregister erhält und wie Gruppierungen gemäß der Verzeichnishierarchie angezeigt werden.

Wenn meine Veröffentlichung für Sie nützlich ist, vergessen Sie nicht, ihr ein Plus zu geben :-)

Hier finden Sie eine Rubrik für alle Aufgaben in der Sammlung(eine Seite mit Links zu Forenthreads für jede Aufgabe)
http://chistov.spb.ru/forum/16-969-1

So, nun meine Entwicklungen und Notizen, die ich während des Vorbereitungsprozesses erstellt habe.
Ich werde versuchen, die beiden oben genannten so wenig wie möglich zu wiederholen zuletzt Veröffentlichungen.

Also lasst uns anfangen:

Wenn Sie die Prüfung aus der Ferne absolvieren, sollten Sie am Ende der Prüfung zwei Objekte auf Ihrem Desktop haben:

1. Endgültiger Upload der Informationsbasis (dt-Datei)
2. Erläuterung

Es sollte nichts anderes geben, keine Zwischenkopien usw.

Schreiben Sie unbedingt eine Erläuterung!
Bei einer vage formulierten Aufgabe schreiben Sie dort unbedingt, dass Sie genau diese und jene Lösungsmöglichkeit gewählt haben.
Außerdem ist es an wichtigen Stellen im Code besser, kurze Kommentare ohne Fanatismus zu hinterlassen, aber wenn der Prüfer Fragen hat, ist es besser, zu schreiben.

Darüber werden Sie jedoch in der Anleitung informiert, die Sie vor der Prüfung zur Lektüre erhalten.
Es ist einfach besser, es im Voraus zu wissen)

Verwendung des kaufmännischen Und-Zeichens in Abfragen.

Manchmal ist es schneller, über eine zusätzliche Tastatur zu tippen, als das Layout hin und her zu wechseln, was Zeit spart
& = Alt+38

*************************************************************************************************
Verwenden von TimePoint() in Abfragen

Bei Abfragen an Akkumulations- und Abrechnungsregister muss nicht das Dokumentdatum als Parameter der virtuellen Tabelle (Periode) verwendet werden, sondern der Parameter Moment, der im Code wie folgt definiert ist:

Moment = ?(Passing Mode = Dokumentbuchungsmodus. Operational, Undefiniert, Moment of Time());

*************************************************************************************************
Bei der Generierung von Belegbewegungen nach Register ist es gleich zu Beginn des Buchungsvorgangs erforderlich, die Bewegungen des aktuellen Belegs nach Register auszugleichen.

Der Code lautet:

Movement.RegisterName.Write = True; Movements.RegisterName.Clear();

Es ist möglich, dass im Laufe des Prozesses eine Analyse der Einträge aus diesem Register erforderlich sein wird.
Damit bei der Analyse der aktuellen Datensätze (alte, vor der Änderung des Dokuments) diese definitiv nicht in der Stichprobe enthalten sind, können Sie zu den beiden oben genannten Zeilen noch eine weitere Zeile hinzufügen:

Movement.RegisterName.Write();

Oder geben Sie bei der Analyse von Datensätzen explizit eine Grenze an, die nicht den Zeitpunkt des aktuellen Dokuments umfasst.

Aber überall habe ich einfach den Aufbau dieser drei Zeilen angedeutet:

Movement.RegisterName.Write = True; Movements.RegisterName.Clear(); Movement.RegisterName.Write();

*************************************************************************************************
Es gibt zwei Möglichkeiten, Daten zu blockieren. Die Wahl zwischen ihnen hängt von der verwendeten Methode ab – alt oder neu:

1) Regelmäßige kontrollierte Blockierung, alte Methode der Dokumentenverarbeitung (Datenblockierungsobjekt)

Legen Sie fest, ob Salden zuerst geprüft und dann abgeschrieben werden.
Für den Fall, dass wir einige Informationen aus dem Register benötigen, um eine Bewegung zu bilden.

Beispiel:

Im Dokument - Menge, im Register - Menge und Betrag (Kosten)
Wir kennen also die Warenmenge aus dem Dokument – wie viel wir abschreiben, aber die Kosten – nicht.
Wir können es nur aus dem Register herausfinden, aber um sicherzustellen, dass niemand das Register zwischen dem Zeitpunkt des Erhalts der Salden und dem Zeitpunkt der Aufzeichnung der Bewegungen verändert, müssen wir das Register bereits vor dem Ablesen der Salden sperren.
In diesem Fall wird also das Data Locking-Objekt verwendet. Und beim Erstellen ist es richtiger, anzugeben, um welche Dimensionen wir das Register sperren (in unserem Fall zum Beispiel nur um den im Dokument angegebenen Artikel) – damit keine unnötigen Sperren entstehen und ein anderer Benutzer einen anderen verkaufen kann Artikel.

1. Setzen Sie eine Sperre mit dem Data Lock-Objekt
2. Lesen Sie den Rest
3. Wir prüfen die Möglichkeit einer Abschreibung
4. Wir erstellen Bewegungen, zum Beispiel schreiben wir Waren ab
5. Nach der Buchung des Belegs wird die Sperre automatisch aufgehoben (die Sperre gilt als Teil des Buchungsvorgangs und wird vom System automatisch aufgehoben). Das heißt, es ist nicht erforderlich, das Objekt speziell zu entsperren.

2) Neue Methodik zur Dokumentenverarbeitung (unter Verwendung der LockForChange-Eigenschaft = True)

Es wird verwendet, wenn wir für die Bildung von Bewegungen keine Informationen aus den Registern benötigen, und wir können überprüfen, ob wir bei der Abschreibung ins Negative geraten sind, wenn wir uns nach der Erfassung die Salden im Register ansehen und feststellen, dass es negative Salden gibt . In diesem Fall verstehen wir, dass wir zu viel abgeschrieben haben und brechen den Abschreibungsvorgang ab.

Beispiel:
Betrachten wir den Vorgang des Verkaufs eines Produkts.
Im Dokument - Menge, im Register - nur Menge
Wir kennen also die Warenmenge aus dem Dokument.
Wir bilden Bewegungen mit der im Dokument angegebenen Menge und erfassen diese. Als nächstes lesen wir das Register, sehen uns die Salden an und analysieren, ob es negative Salden gibt. Wenn dies der Fall ist, zeigen Sie einen Fehler an und setzen Sie Refusal = True.

Das heißt, die Reihenfolge ist wie folgt:
1. Um durch das Register zu navigieren, setzen Sie die BlockForChange-Eigenschaft = True
2. Wir erstellen Bewegungen – schreiben die Ware ab
3. Zeichnen Sie die Bewegungen auf
4. Lesen Sie das Register und stellen Sie sicher, dass keine negativen Salden vorhanden sind. Wenn ja, dann haben sie den Selbstbehalt abgeschrieben, wenn nicht, ist alles in Ordnung.

In diesem Fall ist es also nicht erforderlich, anzugeben, um welche Dimensionen wir das Register sperren müssen.
Wir setzen einfach die BlockForChange-Eigenschaft auf True, bevor wir unsere Bewegungen aufzeichnen, bilden die Bewegungen und zeichnen sie auf.
Das System selbst blockiert das Register zum Zeitpunkt der Aufzeichnung entsprechend den erforderlichen Messungen, nachdem es analysiert hat, was wir aufgezeichnet haben.
Sobald der Vorgang abgeschlossen ist, wird die Sperrung aufgehoben.

Diese Option (die zweite) ist einfacher, sie wird als „neue Methodik zur Verarbeitung von Dokumenten“ bezeichnet und 1C empfiehlt, sie nach Möglichkeit zu verwenden und Punkte abzuziehen, wenn die erste Option verwendet wird, aber in einigen Fällen kann sie einfach nicht angewendet werden und die erste Option mit Das Data Locking-Objekt wird verwendet (siehe Beispiel oben).

Ich stelle außerdem fest, dass unabhängig von der gewählten Methode die Uhrwerke gereinigt werden müssen, bevor mit ihnen gearbeitet wird (siehe vorherige Hinweise).

*************************************************************************************************
Datensperre (Sperrmethode Nr. 1 aus obiger Beschreibung)

Eine kontrollierte Sperrung ist dort erforderlich, wo Daten gelesen und Bewegungen auf Basis dieser Daten ausgeführt werden
Der schnellste Weg, den verwalteten Sperrcode zu erhalten, besteht darin, „Datensperre“ einzugeben, den Syntaxassistenten aufzurufen und einfach den Beispielcode von dort zu kopieren. Dann ändern Sie es einfach in den Namen Ihres Registers und Ihrer Abmessungen.

Es sieht ungefähr so aus:

Lock = NewDataLock; Locking Element = Locking.Add("Accumulation Register.GoodsInWarehouses"); LockElement.Mode = DataLockMode.Exclusive; BlockingElement.DataSource = PM; Sperren Element.UseFromDataSource("Nomenclature", "Nomenclature"); Lock.Lock();

*************************************************************************************************
Den tabellarischen Teil der Dokumente nennt man besser einfach „TC“

In 99 % der Dokumente gibt es nur einen tabellarischen Teil. Ein solcher einheitlicher Name für tabellarische Teile wird erheblich dazu beitragen, Zeit zu sparen, denn:
1) Sehr kurz – schreiben Sie schnell
2) Das Gleiche gilt für alle Dokumente. Sie müssen sich beim Schreiben von Code nicht merken, wie es heißt

*************************************************************************************************
Das Abfrageergebnis sollte vor dem Abrufen oder Hochladen in die technische Spezifikation auf Leere überprüft werden.

Im Allgemeinen habe ich bei allen Aufgaben Sampling verwendet.

Die Abtastung ist für das System hinsichtlich der Leistung optimaler, da sie nur für das Lesen von Daten „geschärft“ wird (im Gegensatz zu TK).

In jedem Fall ist es jedoch besser, vor der Select()-Methode das Abfrageergebnis auf Leere zu überprüfen, da dies die Belastung des Systems weiter verringert.

Ergebnis = Query.Run(); Wenn nicht Result.Empty() Then Select = Result.Select(TravelQueryResult.ByGrouping); ... EndIf;

Und für den Fall, dass wir nur einen Wert aus der Anfrage erhalten müssen
(zum Beispiel nur die Abschreibungsmethode gemäß der für dieses Jahr festgelegten Rechnungslegungsrichtlinie):

Ergebnis = Query.Run(); Wenn nicht Result.Empty() Then Select = Result.Select(); Selection.Next(); Kostenabschreibungsmethode = Sample.Cost-Abschreibungsmethode; endIf;

*************************************************************************************************
Dokument „Operation“ für eine Buchhaltungsaufgabe

Für Buchhaltungsaufgaben ist die Erstellung eines Betriebsdokuments erforderlich.

Wir deaktivieren die Buchung dafür vollständig (in den Eigenschaften „Buchung = Verweigern“), geben an, dass es Bewegungen im Buchhaltungsregister durchführt, und ziehen die Bewegungen auf das Formular.

*************************************************************************************************
Zeitnahe Bearbeitung der Unterlagen:

Muss sein inbegriffen:
Im operativen und buchhalterischen Bereich. Die Abrechnung von Belegen muss aktiviert sein (mit Ausnahme des Belegs „Vorgang“, siehe unten).

Muss sein ausgeschaltet:
Bei Kalkulationsaufgaben macht es für einen Lohn- und Gehaltsabrechnungsbeleg keinen Sinn.

Für den Beleg „Vorgang“ sollte die Buchung komplett deaktiviert werden (in den Belegeigenschaften „Buchung = Verboten“),
Da er schreibt, schreibt er beim Schreiben einfach Daten direkt in das Register.

*************************************************************************************************
Bedingung in einer Anfrage der Form „Entweder die angegebene Nomenklatur oder eine beliebige, falls nicht angegeben“

Bei Abfragen tritt folgende Aufgabe auf: Sie müssen beispielsweise Dokumente mit einer angegebenen Nomenklatur oder alle Dokumente auswählen, wenn die Nomenklatur nicht angegeben ist.
Es wird durch die folgende Bedingung in der Anfrage selbst gelöst:

Nomenclature = &Nomenclature ODER &Nomenclature = Value(Directory.Nomenclature.EmptyLink)

Optimaler und richtiger wäre es aber, diese Bedingung umzuwandeln (Danke Yukon):

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

endIf;

Mit der Einführung des Abfrageobjektmodells in 8.3.5 wird es möglich sein, eine Bedingung sicherer hinzuzufügen:

Wenn ValueFilled(Nomenklatur) Dann
Query1.Selection.Add("Item = &Nomenclature");
Request.SetParameter("Nomenclature", Nomenclature);
endIf;

*************************************************************************************************
Tabellen in Abfragen verknüpfen:

Die Anzahl der Gesamtdatensätze hängt nicht davon ab, ob das Feld der verknüpften Tabelle angezeigt wird, sondern nur von den konfigurierten Beziehungen.
Das heißt, das Feld der angehängten Tabelle wird möglicherweise nicht angezeigt.

Wenn Sie eine Tabelle ohne Bedingungen anhängen möchten, schreiben Sie auf der Registerkarte „Bedingungen“ einfach die Bedingung „TRUE“.
In diesem Fall wird die Tabelle exakt zusammengefügt.

*************************************************************************************************
Verwendung des Merkmalsplantyps (PVC):

1. Verwendung als Mechanismus zur Beschreibung der Eigenschaften von Objekten.

1.1. Wir stellen PVC her. Dabei handelt es sich um Arten von Merkmalen (z. B. Farbe, Größe, maximale Geschwindigkeit usw.). Wählen Sie in den Einstellungen alle möglichen Arten von Kennwerten aus und legen Sie ggf. das Objekt aus Punkt 1.2 an und geben Sie es auch in den Einstellungen an.

1.2. Für zusätzliche PVC-Werte erstellen wir ein untergeordnetes Verzeichnis AdditionalValues of Characteristics (oder einfach Values of Characteristics).
Es speichert Merkmale, wenn sie nicht in vorhandenen Verzeichnissen vorhanden sind. Wir erstellen es möglicherweise nicht, wenn sich alle benötigten Merkmale in vorhandenen Verzeichnissen befinden oder diese Werte durch elementare Datentypen dargestellt werden können. In den PVC-Einstellungen geben wir an, dass dieses Verzeichnis für weitere Zwecke verwendet wird. charakteristische Werte.

1.3. Wir erstellen ein Informationsregister, das tatsächlich drei Objekte verbindet:
- Das Objekt, mit dem wir den Merkmalsmechanismus verbinden
- TypeCharacteristics (PVC-Typ)
- Merkmalswert (Typ - Merkmal, dies ist ein neuer Typ, der nach der Erstellung von PVC im System erschien
und Beschreibung aller möglichen Datentypen, die ein Merkmalswert annehmen kann).
Im Informationsregister geben wir an, dass der Merkmalstyp der Eigentümer für den Merkmalswert ist (Link zum Auswahlparameter) sowie die Typverbindung für den Merkmalswert, wiederum vom Merkmalstyp.

Eine weitere Funktion besteht darin, dass Sie für jeden angelegten Merkmalstyp die Art des Merkmalswerts angeben können, wenn Sie nicht alle möglichen Typen benötigen, um den Wert dieses Merkmals zu beschreiben.

2. Verwendung von PVC zur Schaffung eines Sub-Conto-Mechanismus für das Buchhaltungsregister .

2.1. Wir erstellen PVC TypesSubconto.

2.2. Wir erstellen ein untergeordnetes Verzeichnis ValuesSubConto (wie bei Merkmalen enthält es Subconto-Werte, wenn solche in anderen Verzeichnissen nicht vorhanden sind).

2.3. Die Kommunikation erfolgt über einen Kontenplan.

*************************************************************************************************
Ressourcen für das Buchhaltungsregister:

Betrag - Bilanz,
Menge – außerbilanziell und mit dem Buchhaltungsmerkmal „Quantität“ verknüpft

*************************************************************************************************
Virtuelle Buchhaltungsregistertabellen:

Umsatz: Umsatz eines einzelnen Kontos
TurnoverDtKt: Umsatz zwischen zwei beliebigen Konten, also alle gleichen Transaktionen für den Zeitraum.

*************************************************************************************************
Währungsabrechnung in Buchhaltungsregistern – wie man sie umsetzt:

Wir legen im Kontenplan ein Buchhaltungsattribut „Währung“ an.
Im Buchhaltungsregister erstellen wir zusätzlich:
- Währungsdimension (Verbot von Leerwerten, Ausserbilanz, Buchhaltungsattribut - Währung)
- Ressource „CurrencyAmount“ (Außerbilanz, Buchhaltungsattribut – Währung, es wird der Betrag in der Währung gespeichert, also beispielsweise 100 $)
Alle.

Somit ist die Registerstruktur:

Messungen:
- Währung
Ressourcen
- Menge
- Betrag (Betrag in Rubel)
- CurrencyAmount (Betrag in Währung)

Daher ist die Währungsbuchhaltung nur eine Verfeinerung der herkömmlichen Buchhaltung in der Republik Belarus; sie ändert nichts an der Essenz beispielsweise der Ressource „Betrag“.
(Dort ist der Betrag wie üblich in Rubel angegeben, unabhängig davon, ob das Konto in Fremdwährung geführt wird oder nicht).
Und wenn die Währungsbuchhaltungsfunktion für das Konto deaktiviert ist, dann ist dies die übliche Struktur der Republik Belarus (Ressourcen – nur Menge und Betrag).

*************************************************************************************************
Wenn wir die Parameter einer virtuellen Tabelle festlegen, um einen Teil davon zu erhalten, stellen wir Bedingungen an die Dimensionen und nicht an die Ressourcen.

Andernfalls erhalten wir keinen Ausschnitt der neuesten Datensätze, sondern den letzten Datensatz mit dem angegebenen Ressourcenwert – er ist möglicherweise nicht der letzte im Dimensionssatz

*************************************************************************************************
Die Bedeutung der Ressource und Details im Berechnungsregister

In Berechnungsregistern ermöglicht das Anlegen einer Ressource, diese bei der Berechnung der Basis über dieses Register zu erhalten.
Und selbst im Verhältnis zum angegebenen Zeitraum wird der Ressourcenwert neu berechnet (wenn der Basiszeitraum nicht mit der Periodizität des Registers übereinstimmt).

Und der Wert des Attributs ist nur in der realen Tabelle des Berechnungsregisters verfügbar; in virtuellen Tabellen ist er nicht verfügbar.

*************************************************************************************************
Checkbox „Basic“ in den Eigenschaften der Berechnungsregisterdimension
Dies bedeutet, dass in Zukunft eine Basis aus dieser Dimension gewonnen wird und zur zusätzlichen Indizierung von Werten für dieses Feld dient.

*************************************************************************************************
Aufschlüsselung der Urlaubsgültigkeitsdauer nach Monaten bei der Erfassung von Registereinträgen,
wenn im Dokument Urlaub in einer Zeile für mehrere Monate gleichzeitig in einer Zeile angegeben ist:

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

*************************************************************************************************
Erstellen eines Gantt-Diagramms:

Wir platzieren ein Element vom Typ „Gantt-Diagramm“ auf dem Formular, nennen es DG, erstellen dann den Befehl „Generieren“ und schreiben Folgendes in das Formularmodul:

&OnClient-Prozedur Generate(Command) GenerateOnServer(); Ende der Prozedur &Auf der Serverprozedur GenerateOn Server() DG.Clear(); DG.Update = False; Request = New Request("SELECT |BasicAccrualsActualActionPeriod.Employee, |BasicAccrualsActualActionPeriod.CalculationType, |BasicAccrualsActualActionPeriod.ActionPeriodStart AS ActionPeriodStart, |BasicAccrualsActualActionPeriod.Period ActionsEnd AS PeriodActionsEnd |FROM |Calculation Register.BasicAc cruals.ActualPeriodActions AS BasicAccrualsActualPeriodActions |WHERE |BasicAccrualsActualPeriodActions.PeriodActions BETWEEN &StartDate AND &EndDate "); Query.SetParameter("StartDate", Period.StartDate); Request.SetParameter("EndDate", Period.EndDate); Select = Query.Run().Select(); While Selection.Next() Loop Point = DG.SetPoint(Selection.Employee); Series = DG.SetSeries(Selection.CalculationType); Value = DG.GetValue(Point, Series); Intervall = Value.Add(); Interval.Start = Sample.PeriodActionStart; Interval.End = Sample.ActionPeriodEnd; EndCycle; DG.Update = True; EndProzedur

Eigentlich ist für uns hier nur der Code in der Schleife wichtig, der Rest ist Hilfsstoff, ich habe nur die gesamte Implementierung dieser Unteraufgabe angegeben.
Bei der Anfrage ist es für uns wichtig, dass der Mitarbeiter, die Zahlungsart, das Startdatum und das Enddatum des Zeitraums angegeben sind.
Der Code ist eigentlich sehr einfach und leicht zu merken. Seien Sie nicht beunruhigt, wenn er umständlich erscheint

*************************************************************************************************
Bearbeitung von „Storno“-Einträgen in Rechenaufgaben:

Im Tr(Objektmodul) bilden wir alle Bewegungen, und wenn es dann Datensätze in anderen Perioden gibt, erhalten wir diese so
(Das System generiert sie automatisch – hilft uns):

Addition Records = Movements.MainAccruals.GetAddition(); // Es ist nicht nötig, Bewegungen aufzuzeichnen, um die Addition zu erhalten

Für jede Tech-Linie aus dem Record Additions-Zyklus
Record = Movements.MainAccruals.Add();
FillPropertyValues(Record, TechString);
Record.RegistrationPeriod = TechString.RegistrationPeriodReversal;
Record.ActionPeriodStart = TechString.ActionPeriodStartReverse;
Record.ActionPeriodEnd = TechString.ActionPeriodEndReversal;
Ende des Zyklus

Und wenn Sie Datensätze berechnen, fügen Sie Schecks ein:

Wenn TechMotion.Reversal Dann
CurrentMovement.Sum = - CurrentMovement.Amount;
endIf;

*************************************************************************************************
So ermitteln Sie, was in den Hauptrückstellungen und was in den Zusatzrückstellungen in Berechnungsaufgaben enthalten ist.

Dies ist jedoch nicht immer zu 100 % klar, es gibt auch kompliziertere Fälle, obwohl es davon einige gibt
(zum Beispiel ein Bonus, der von der Anzahl der Arbeitstage im Monat abhängt – das ist HE).

Grundpreise:
Ist die Art der Berechnung fahrplanabhängig (gemeint ist ein Informationsregister mit Kalenderdaten), so handelt es sich um die Hauptentgelte.

Beispiel OH:
- Gehalt
- Etwas, das aus der Anzahl der Arbeitstage berechnet wird (und dafür müssen Sie einen Zeitplan verwenden): entweder im Gültigkeitszeitraum (wie Gehalt) oder im Basiszeitraum

Zusätzliche Kosten:
Was berücksichtigt wird, ist entweder der aufgelaufene Betrag oder die ARBEITSZEIT (und nicht die Norm!) oder hängt überhaupt nicht davon ab - das ist zusätzlich. Rückstellungen.

Das heißt: Rückstellungen, für deren Berechnung der Zeitstandard verwendet wird (vielleicht auch eine Tatsache), sind OH, und für die tatsächliche Daten oder gar nichts benötigt werden, sind DN.

Oder mit anderen Worten:

Wenn die VR einen Zeitstandard verwendet, muss der Gültigkeitszeitraum für die VR berücksichtigt werden.

*************************************************************************************************
Fügen Sie die Möglichkeit hinzu, den integrierten Hilfeabschnitt „Arbeiten mit Nachschlagewerken“ im Listenformular des Verzeichnisses „Nomenklatur“ zu öffnen.

Führen Sie den Befehl im Formular aus:

&OnClient
Prozedurhilfe (Befehl)
OpenHelp("v8help://1cv8/EnterprWorkingWithCatalogs");
EndProzedur

Wir definieren die Schnittlinie wie folgt:
Gehen Sie zu den Hilfeinformationen des Konfigurationsobjekts (im Konfigurator), schreiben Sie ein Wort, wählen Sie es aus, gehen Sie zum Menü Elemente/Link und wählen Sie den gewünschten Abschnitt der 1C-Hilfe aus, woraufhin der Link automatisch eingefügt wird. Es sieht kompliziert aus, aber in der Praxis ist es einfach.

*************************************************************************************************
Implementierung der Interaktion zwischen Formularen, zum Beispiel Auswahl:

1. Öffnen Sie aus dem aktuellen Formular das gewünschte Formular mit der Methode „OpenForm()“ und übergeben Sie dabei (falls erforderlich) die Struktur mit Parametern als zweiten Parameter. Der dritte Parameter kann einen Link zu diesem Formular übergeben – ThisForm.

2. Im geöffneten Formular können wir im Handler „When CreatedOnServer()“ die in Schritt 1 über „Parameters.[ParameterName]“ übergebenen Parameter abfangen. Auf das Formular, das die Öffnung dieses Formulars initiiert hat, kann über die Kennung „Eigentümer“ zugegriffen werden (sofern diese natürlich in Schritt 1 angegeben wurde).

Und das Wichtigste: Exportfunktionen des Eigentümerformulars werden verfügbar sein. Das heißt, wir können die Exportfunktion des Quellformulars aufrufen und dort etwas als Parameter übergeben, um die Auswahl zu verarbeiten. Und diese Funktion füllt bereits das aus, was im Originalformular benötigt wird. Es gibt nur eine Einschränkung: Sie können keine Wertetabelle zwischen Client-Prozeduren übergeben, aber wir können sie im temporären Speicher ablegen und einfach die VX-Adresse übergeben und sie dann aus dem VX extrahieren.

*************************************************************************************************
Lebenszyklus von Formularparametern

Alle zum Zeitpunkt des Öffnens an das Formular übergebenen Parameter sind nur in der Prozedur „When CreateOnServer“ sichtbar.
Nach der Erstellung werden alle Parameter zerstört und sind im Formular nicht mehr verfügbar.
Eine Ausnahme bilden Parameter, die im Formulareditor mit dem Attribut „Schlüsselparameter“ deklariert werden.
Sie bestimmen die Einzigartigkeit der Form.
Dieser Parameter bleibt bestehen, solange das Formular selbst existiert.

*************************************************************************************************
Verwenden der Taxi-Schnittstelle

Während der Entwicklung können Sie in den Konfigurationseigenschaften das gewohnte Managed Interface 8.2 einstellen – das macht alles spürbar kompakter und vertrauter.
Dies gilt insbesondere dann, wenn Sie aus der Ferne mieten – die Bildschirmauflösung ist sehr gering und es ist unmöglich, mit der „Taxi“-Schnittstelle etwas zu tun.
Vergessen Sie nur nicht, „Taxi“ erneut einzugeben, wenn Sie fertig sind!Andernfalls wird der Prüfer Punkte abziehen!

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

PS: E Es gibt separate Standard-Unteraufgaben, die in allen Aufgaben verwendet werden, und diese müssen Sie lösen können (z. B. stapelweise abschreiben, PVC verwenden (naja, das kommt wirklich selten vor) und andere). Und bei allen Aufgaben wiederholen sie sich einfach (irgendwo gibt es Teilaufgaben, woanders nur in unterschiedlichen Kombinationen). Darüber hinaus haben sie seit langem versprochen, eine neue Sammlung herauszubringen (falls dies nicht bereits geschehen ist), in der es viel mehr Probleme geben sollte, d Lösen Sie einzelne Standard-Teilaufgaben, dann lösen Sie jedes Problem.

PSS: Kolleginnen und Kollegen, wenn jemand weitere nützliche Informationen zur Vorbereitung auf die Prüfung und zum Bestehen der Prüfung hat, schreiben Sie diese bitte in die Kommentare und wir werden den Artikel ergänzen.