Einfache Abfragen. Batch-Abfragen für Dummies Ein Algorithmus zum kompetenten Erstellen einer Batch-Abfrage

Schauen wir uns an einem einfachen Beispiel an, wie die Syntax von Abfragetexten geändert (bzw. ergänzt) wurde: Ein Dokument wird verarbeitet Verbrauchsmaterial enthalten im tabellarischen Teil Waren Liste der verkauften Waren und Menge. Bei der Erstellung eines solchen Dokuments muss sichergestellt werden, dass die im Saldenakkumulationsregister gespeicherten negativen Salden kontrolliert werden Restposten.

Die Konfigurationsstruktur ist in der Abbildung dargestellt.

(16,22 Kilobyte) Anzahl der Downloads: 64

Erstellen wir eine Abfrage für den tabellarischen Teil des Dokuments und die virtuelle Tabelle Reste Akkumulationsregister. Berücksichtigen wir mögliche doppelte Zeilen im Dokument; dazu gruppieren wir die Datensätze.

//Passing by register

EndCycle;

Ende des Verfahrens

Natürlich ist die obige Abfrage absolut nicht optimal. Mithilfe verschachtelter Abfragen optimieren wir es: Wir gruppieren den tabellarischen Teil des Dokuments, bevor wir es mit der Saldentabelle verbinden; wir übergeben eine Warenliste als Wert der Bedingung für die Saldenberechnung an die Parameter der virtuellen Tabelle . Unsere Anfrage wird daher wie folgt aussehen:

Wenn die Abfrage Daten aus den übrigen verschiedenen Registern abrufen müsste, würde der Filterwert und damit unsere zweite verschachtelte Abfrage in allen Parametern der virtuellen Tabellen wiederholt. Natürlich greift das System mit jeder verschachtelten Abfrage erneut auf die Datenbank zu Daten zu erhalten.

Temporäre Tabellen

Ich kann mich nicht erinnern, ab welcher Version es möglich wurde, temporäre Tabellen in Abfragen zu verwenden. Verwenden Sie dazu das Objekt „Temporary Table Manager“. Im Wesentlichen beschreibt der temporäre Tabellenmanager den Namensraum temporärer Tabellen und ist für deren Erstellung und Zerstörung in der Datenbank verantwortlich.

Die temporären Tabellen selbst werden tatsächlich physisch in der Datenbank erstellt, daher sollten Sie sie mit Vorsicht behandeln, da das Festplattensubsystem derzeit die langsamste Technologie ist und die Geschwindigkeit der Erstellung und Zerstörung von Tabellen direkt davon abhängt.

Schreiben wir die Abfrage um, um temporäre Tabellen zu verwenden. In temporären Tabellen platzieren wir den gruppierten tabellarischen Teil des Dokuments und die Produktliste für den virtuellen Tabellenfilter:

Verarbeitungsvorgang (Fehler, Modus)

MVT = Neuer TemporaryTableManager;

RequestResult = Request.Execute();
Selection = QueryResult.Select();

While Select.Next()-Schleife

//Überprüfung negativer Salden

//Passing by register

EndCycle;

Ende des Verfahrens

Bei Verwendung temporärer Tabellen wird die Anweisung im Abfragetext verwendet Ort Um eine neue temporäre Tabelle zu erstellen, übermittelt das System in diesem Fall nicht den Inhalt dieser Tabelle an das Abfrageergebnis (siehe Anmerkung 1 und Anmerkung 2 im Text oben), sondern die Anzahl der in der temporären Tabelle platzierten Datensätze; wenn Sie wünschen, Sie können diesen Wert nicht akzeptieren.

Es ist auch möglich, Anweisungen zu verwenden Zerstören In diesem Fall wird die temporäre Tabelle zerstört, andernfalls werden die temporären Tabellen zusammen mit dem temporären Tabellenmanagerobjekt zerstört.

In unserer Hauptabfrage habe ich die Namen temporärer Tabellen als Hinweis auf die Datenquelle verwendet (ihnen muss ein Synonym zugewiesen werden, was wir im Text sehen). Sie können temporäre Tabellen mehr als einmal als Quelle verwenden, was Ihnen bei geschickter Verwendung eine Verkürzung des Abfragetexts (Verbesserung der Lesbarkeit komplexer Abfragen) und eine Erhöhung der Geschwindigkeit (bei Verwendung temporärer Tabellendaten an mehreren Stellen in der Abfrage) ermöglicht. .

Batch-Anfragen

Batch-Abfragen ergänzen logisch die Funktionalität temporärer Tabellen und bieten mehr Möglichkeiten bei der Arbeit mit Abfragen.

In einer Batch-Abfrage können Sie tatsächlich mehrere Abfragen beschreiben, die sowohl durch die Verwendung temporärer Tabellen miteinander verbunden als auch unabhängig sind (das ist möglich, aber es ist nicht klar, warum?). Dadurch können Sie alle Anfragen nacheinander ausführen und erhalten als Ergebnis entweder ein Array mit den Ergebnissen jeder Anfrage oder das Ergebnis der letzten. Um ein Array mit Abfrageergebnissen zu erhalten, verwenden Sie die Methode ExecuteBatch() Anfrageobjekt und um das Ergebnis der letzten Anfrage abzurufen RunQuery().

Im Anfragetext werden Paketanfragen durch das Symbol „;“ getrennt. (Punkt mit Komma). Pro Batch-Anfrage gibt es nur einen Namensraum für virtuelle Tabellen. Die Verwendung eines temporären Tabellenmanagers ist nicht erforderlich, aber möglich, wenn Sie temporäre Tabellen von einer Batch-Abfrage an eine andere übergeben möchten.

Schreiben wir die Prozedur um, um Batch-Anfragen zu verwenden:

Verarbeitungsvorgang (Fehler, Modus)

While Select.Next()-Schleife

//Überprüfung negativer Salden

//Passing by register

EndCycle;

Ende des Verfahrens

Tatsächlich habe ich die Definition des Abfrageobjekts und die Verwendung des temporären Tabellenmanagers entfernt und die Abfragetexte kombiniert (beachten Sie das „;“-Trennzeichen zwischen den Texten). Dadurch ist der Abfragetext besser lesbar geworden (und bei Verwendung des Abfrage-Builders wird die Lesbarkeit der Abfrage erheblich verbessert).

Nach dem Ausführen einer Abfrage in eine Variable ArrayResults wir werden 3 Elemente haben. Die ersten beiden enthalten eine Zahl, die die Anzahl der Datensätze angibt, die in temporären Tabellen abgelegt werden DocTC Und Produktliste, und der dritte enthält eine Auswahl mit Feldern Nomenklatur, Doc_ Menge und Reg_ Menge.

Zu einer Variablen Abfrageergebnis es kommt nur eine Probe rein.

Nun, das ist alles für Batch-Anfragen. Ein sehr praktischer Mechanismus sowohl im Hinblick auf das Schreiben von Abfragen als auch im Hinblick auf das Lesen komplexer Abfragen.

Einfache Abfragen

Betrachten Sie anhand des folgenden Beispiels, wie die Abfragesyntax geändert (genauer gesagt, ergänzt) wurde: Es wird ein Verbrauchsmaterialdokument gebucht, das im tabellarischen Abschnitt „Produkte“ eine Liste der verkauften Produkte und deren Menge enthält. Um dieses Dokument zu erstellen, ist es notwendig, die im Register der Ansammlung von Warenresten erfassten negativen Salden zu kontrollieren.

Die Abbildung zeigt die Konfigurationsstruktur.

Erstellen wir eine Abfrage für die virtuellen Tabellenreste des Akkumulationsregisters und den tabellarischen Teil des Dokuments. Um mögliche Wiederholungen von Zeilen im Dokument zu berücksichtigen, werden wir die Datensätze gruppieren.

Natürlich ist die obige Abfrage nicht optimal genug. Optimieren wir es mithilfe verschachtelter Abfragen: Gruppieren Sie den tabellarischen Teil, bevor Sie ihn mit der Tabelle der Dokumentsalden verbinden, und übergeben Sie eine Liste von Produkteinheiten als Bedingung für die Berechnung der Salden an die Parameter der virtuellen Tabelle. Die resultierende Abfrage sieht folgendermaßen aus:

Wenn die Abfrage das Abrufen von Daten aus den übrigen verschiedenen Registern erfordert, werden der Filterwert und die zweite Unterabfrage in jedem Parameter der virtuellen Tabellen wiederholt, und das System kontaktiert die Infobase, um mit jeder Unterabfrage Daten abzurufen.

Temporäre Tabellen

Seit einiger Zeit ist es möglich, temporäre Tabellen in Abfragen zu verwenden, wofür das Objekt „Temporary Table Manager“ verwendet wird. Im Wesentlichen enthält ein temporärer Tabellenmanager eine Beschreibung des Namensraums temporärer Tabellen und stellt sicher, dass diese in der Datenbank erstellt und gelöscht werden.

Temporäre Tabellen werden physisch in der Datenbank gespeichert, daher sollten Sie sie mit Vorsicht verwenden, denn Das Festplattensubsystem ist der Teil der Technologie mit der geringsten Leistung und die Geschwindigkeit beim Erstellen und Löschen von Tabellen hängt direkt davon ab.

Ändern wir die Abfrage, um die Verwendung temporärer Tabellen zu berücksichtigen. Temporäre Tabellen enthalten den tabellarischen Teil des Dokuments in gruppierter Form und eine Liste von Produkten zum Filtern virtueller Tabellen:

Die Verwendung temporärer Tabellen in einer Abfrage erfordert die Verwendung der Place-Anweisung zum Erstellen einer neuen temporären Tabelle. Das Ergebnis der Abfrage ist nicht der Inhalt der Tabelle, sondern die Anzahl der Datensätze, die in der temporären Tabelle platziert wurden.

Darüber hinaus können Sie die Anweisung Destroy verwenden. In diesem Fall wird die temporäre Tabelle gelöscht, andernfalls werden die temporären Tabellen vom temporären Tabellenmanagerobjekt zusammen mit den Tabellen zerstört.

In der Hauptabfrage wurden die Namen der temporären Tabellen als Hinweis auf die Datenquelle verwendet (sie sollten mit einem Synonym versehen werden). Sie können temporäre Tabellen mehr als einmal als Quelle verwenden. Bei korrekter Verwendung können Sie so den Abfragetext verkürzen und die Geschwindigkeit erhöhen (bei Verwendung einer temporären Tabelle an verschiedenen Stellen in der Abfrage).

Batch-Anfragen

Batch-Abfragen erweitern die Funktionalität temporärer Tabellen erheblich und bieten neue Möglichkeiten bei der Arbeit mit Abfragen.

Tatsächlich kann eine Batch-Abfrage mehrere Abfragen beschreiben, die sowohl über temporäre Tabellen als auch über unabhängige Tabellen miteinander verbunden sind. Dadurch scheint es, als würde es alle Abfragen nacheinander ausführen und am Ende eine Reihe von Ergebnissen für jede Abfrage oder nur das Ergebnis der letzten Abfrage erhalten. Mit der ExecutePackage()-Methode des Anforderungsobjekts wird ein Array von Abfrageergebnissen abgerufen. Um nur das Ergebnis der letzten Anforderung zu erhalten, verwenden Sie die ExecuteQuery()-Methode.

Batch-Anfragen im Anfragetext müssen durch das Zeichen „;“ getrennt werden. Eine einzelne Batch-Anfrage verfügt über einen Namensraum für virtuelle Tabellen. Die Verwendung eines temporären Tabellenmanagers ist nicht erforderlich, aber möglich, wenn Sie temporäre Tabellen an eine andere Batch-Abfrage übergeben müssen.

Ändern wir das Verfahren unter Berücksichtigung von Batch-Anfragen:

Tatsächlich wurde die Definition des Abfrageobjekts gelöscht und der temporäre Tabellenmanager nicht verwendet, die Abfragetexte wurden zusammengeführt. Dadurch wurde der Anfragetext besser lesbar.

Nach der Ausführung der Anfrage enthält die Variable „Ergebnisarray“ drei Elemente. Die ersten beiden sind die Anzahl der DocTCH- und Produktlistendatensätze, die in temporären Tabellen platziert werden; der dritte enthält eine Auswahl mit den Feldern Doc_Quantity, Nomenclature und Reg_Quantity.

Die Variable „Abfrageergebnis“ enthält nur die Auswahl.

Somit sind Batch-Abfragen ein sehr praktisches Werkzeug sowohl zum Schreiben als auch zum Lesen komplexer Abfragen.

Mit der 1C Enterprise-Plattform können Sie mehrere Abfragen gleichzeitig nacheinander ausführen. In 1C wird dies als Anforderungspaket bezeichnet. Innerhalb eines Pakets wird jede Anfrage durch ein Semikolon getrennt.

Um eine schrittweise Ausführung von Abfragen in einem Paket zu erreichen, werden in der Regel zunächst temporäre Tabellen erstellt und dann Bedingungen für deren gemeinsame Nutzung, wie Filter, Joins und Joins, gebildet. Dadurch wird das Endergebnis erreicht. Temporäre Tabellen, die als Ergebnis von Abfragen in einem Stapel erhalten werden, bleiben bestehen, bis der Stapel als Ganzes beendet ist oder bis eine Abfrage ausgeführt wird, die die temporären Tabellen zerstört.

Darüber hinaus erhöht die Verwendung von Batch-Abfragen und temporären Tabellen die Lesbarkeit des gesamten Codeabschnitts erheblich. Komplexe Abfragen, die auch verschachtelte Abfragen enthalten, können sehr schwer zu verstehen sein. Wenn Sie jedoch eine lange komplexe Abfrage in mehrere aufteilen und sogar temporäre Tabellen verwenden, verbessert dies nicht nur die Wahrnehmung, sondern führt in den meisten Fällen auch zu einer Leistungssteigerung.

Ein weiteres wichtiges Detail für Batch-Abfragen in 1C ist, dass wir im Gegensatz dazu das Ergebnis jeder Abfrage im Batch separat erhalten können.

Ein Beispiel für die Erstellung eines Anforderungspakets in der 1C-Sprache

Um ein Beispiel für die Erstellung eines Abfragepakets zu sehen, verwenden wir den Abfrage-Designer, den wir aus Gründen der Übersichtlichkeit über die Abfragekonsole aufrufen. Somit können wir sofort das Ergebnis der Ausführung des Pakets sehen.

Lassen Sie uns eine einfache Batch-Anfrage erstellen. Ich schlage vor, den Anfragetext sofort in einzufügen, ihn dann zu öffnen und zu sehen, wie das Paket der Anfragen entsteht. Fügen Sie der Konsole eine neue Anfrage hinzu und fügen Sie den folgenden Text ein:

Holen Sie sich 267 Video-Lektionen zu 1C kostenlos:

Selbsttragend. Link,
Selbsttragend.Elternteil,
Selbsttragend. Code,
Selbsttragend. Schnellauswahlcode,
Selbsttragend. Name,
Selbsttragender Typ,
Selbsttragend. Außerbilanziell,
Selbsttragend. Quantitativ,
AUS
Kontenplan. Selbsttragend AS Selbsttragend
WO
Selbsttragend.Link = &Konto
;
////////////////////////////////////////////////////////////////////////////////

WÄHLEN
Selbsttragende TypenSubconto.Zeilennummer AS Zeilennummer,
Selbsttragende Typen von Subconto.ViewSubconto AS TypeSubconto,
Self-supportingTypesSubconto.TypeSubconto.Name AS Name,
Self-supportingTypesSubconto.TypeSubconto.ValueType ASValueType,
SelbsttragendTypesSubconto.OnlyTurnover AS OnlyTurnover,
Self-supportingTypesSubconto.Summary AS Summative
AUS
Kontenplan. Selbsttragend. Arten von Unterkonten AS Selbstbuchhaltung. Arten von Unterkonten
WO
Self-supportingTypesSubaccount.Link = &Account
SORTIERE NACH
Selbsttragende TypesSubconto.NumberLines

Bei mir sieht es so aus:

Kommen wir nun zum Abfrage-Designer. Hier interessiert uns der Reiter „Paket anfordern“:

Wie Sie sehen, haben wir ein Paket mit zwei Anfragen. Durch Doppelklicken auf eine davon können Sie mit der Bearbeitung fortfahren:

Klicken Sie auf die Schaltfläche „OK“ und versuchen Sie, das Ergebnis der Stapelanforderung anzuzeigen.

Lassen Sie uns den Parameter „Konto“ festlegen. Sie können ein beliebiges Konto aus dem Kontenplan auswählen. Wie Sie wahrscheinlich bereits vermutet haben, sollte dieses Anforderungspaket Kontoeigenschaften erhalten. Klicken Sie auf „Ausführen“ und sehen Sie sich das Ergebnis an:

Methoden Run() und RunBatch()

Ich denke, Sie sind sich alle einig, dass das Thema Abfragen im 1C:Enterprise 8-System heute mit seiner Relevanz aufwarten kann. Aus diesem Grund haben wir uns entschieden, unseren heutigen Artikel dem Thema Zusammenführen von Abfragen, Abrufen der neuesten Dokumente nach Datum in 1C-Abfragen und Verbinden von Abfragen zu widmen. Fangen wir trotzdem an.

Um eine Batch-Anfrage im 1C:Enterprise-System zu erstellen, sollten Sie also die PLACE-Klausel verwenden. Eine Batch-Anfrage bezieht sich auf mehrere Anfragen gleichzeitig, die als eine große Anfrage bezeichnet werden. Alle werden nacheinander ausgeführt. Durch die Verwendung einer dieser Abfragen können sie in einer temporären Tabelle abgelegt werden und dann mit einer anderen Abfrage darauf zugegriffen werden. Wahrscheinlich werden sich die meisten von Ihnen fragen: Welche Vorteile bietet diese Methode?

Wir haben die Antwort auf diese Frage. Persönlich denke ich, dass der größte Vorteil dieser Methode die Möglichkeit ist, ihre Ergebnisse in einer sogenannten temporären Tabelle abzulegen. Darin können sie mehrfach verwendet werden. Darüber hinaus müssen Sie bei all dem nicht mehrmals hintereinander dieselbe verschachtelte Abfrage ausführen; Sie müssen lediglich Daten aus einer vorgefertigten Tabelle auswählen. Einige von Ihnen werden sich fragen: Hat diese Technik irgendwelche Nachteile? Natürlich hat diese Technik, wie alles auf unserer Welt, gewisse Nachteile.

Das Wichtigste ist, dass das System bei Verwendung temporärer Tabellen in Batch-Abfragen sehr reale Tabellen in der Datenbank erstellen kann. Manche fragen sich vielleicht: Was ist daran so schlimm? Das ist einerseits gut. Andererseits verbringen Sie jedoch einen erheblichen Teil Ihrer Zeit damit, Abfragen zu erstellen, und nachdem Sie sie verwendet haben, müssen Sie einige Zeit damit verbringen, sie zu löschen.

Zum Beispiel:
WÄHLEN
Nomenklatur,

Betrag(Betrag) AS Betrag,
PLATZ DocPrikhod
AUS

Daher wird nach dem Ausführen dieser Abfrage nur die Anzahl der Datensätze angezeigt, die in der Tabelle platziert wurden. Die Ergebnisse werden in derselben Tabelle angezeigt. Lassen Sie uns eine ähnliche Anfrage für ein Spesendokument stellen. Dazu müssen wir diese beiden Abfragen mit dem Symbol „;“ trennen. Er ist es, der dem Benutzer mitteilen kann, dass eine Batch-Anfrage beendet ist und eine andere beginnt.

WÄHLEN
Nomenklatur,
Betrag(Menge) AS Menge,
Betrag(Betrag) AS Betrag,
PLATZ DocPrikhod
AUS
Dokument. Empfang von Waren und Dienstleistungen. Waren
GRUPPE NACH Nomenklatur
;

WÄHLEN
Nomenklatur,
Betrag(Menge) AS Menge,
Betrag(Betrag) AS Betrag,
PLATZIEREN Sie DockFlow
AUS
Dokument. Verkauf von Waren und Dienstleistungen. Waren
GRUPPE NACH Nomenklatur

;
WÄHLEN
*
AUS
DocPrihod AS DocPrihod
VOLLSTÄNDIGE VERBINDUNG
DocExpense AS DocExpense
VON

Daraus können Sie erkennen, dass die dritte Abfrage die Daten dieser beiden Abfragen zusammenführt.

Versuchen wir nun, die Abfrage noch schöner aussehen zu lassen. Dazu werden wir versuchen, als Ergebnis der Anfrage zu verstehen, welche Beträge und Mengen eingegangen und welche abgegangen sind. Dazu sollten Sie den Text der dritten Anfrage leicht ändern.

WÄHLEN
DocPriod.Nomenklatur,
DocConsumption.Nomenclature,

AUS
DocPrihod AS DocPrihod
VOLLSTÄNDIGE VERBINDUNG
DocExpense AS DocExpense
VON
DocIncome.Nomenclature = DocExpense.Nomenclature

Als Ergebnis erhalten wir Daten zu Einnahmen und Ausgaben. Aber wir haben immer noch ein Problem damit, wie wir zwei Spalten kombinieren könnten, „Nomenklatur“ und „Nomenklatur1“? Wenn wir in diesem Fall den Wert aus der Spalte „Nomenklatur“ nehmen, erhalten wir am Ende nicht den Wert aus der letzten Zeile, aber wenn wir den Wert aus der Spalte „Nomenklatur1“ nehmen, erhalten wir am Ende nicht der Wert aus der dritten Zeile. Verwenden Sie dazu die Funktion „ISNULL“.
Als Ergebnis sieht die Anfrage so aus:

WÄHLEN
AS-Nomenklatur,
DocIncoming.Quantity AS QuantityIncoming,
DocIncome.Amount AS AmountIncome,
DocConsumption.Quantity AS QtyConsumption,
DocExpense.Amount AS AmountExpense
AUS
DocPrihod AS DocPrihod
VOLLSTÄNDIGE VERBINDUNG
DocExpense AS DocExpense
VON
DocIncome.Nomenclature = DocExpense.Nomenclature

In diesem Fall könnte ein weiteres Problem auftreten, das damit zusammenhängt, wie man die Werte durch die numerische Null ersetzen könnte. Dazu müssen Sie erneut die Funktion „ISNULL“ verwenden und eine Abfrage schreiben:

WÄHLEN
ISNULL(Doc.Incoming.Nomenclature,Doc.Expense.Nomenclature)
AS-Nomenklatur,
ISNULL(Doc.Receipt.Quantity,0) AS QuantityReceipt,
ISNULL(Doc.Income.Amount,0) AS AmountIncoming,
ISNULL(DocumentConsumption.Quantity,0) AS QuantityConsumption,
ISNULL(DocExpense.Amount,0) AS AmountExpense
AUS
DocPrihod AS DocPrihod
VOLLSTÄNDIGE VERBINDUNG
DocExpense AS DocExpense
VON
DocIncome.Nomenclature = DocExpense.Nomenclature

1C GOODWILL Unternehmensblog

Um eine schrittweise Ausführung von Abfragen in einem Paket zu erreichen, werden in der Regel zunächst temporäre Tabellen erstellt und anschließend die Bedingungen für deren gemeinsame Nutzung, wie Filter, Joins und Joins, gebildet. Dadurch wird das Endergebnis erreicht. Temporäre Tabellen, die als Ergebnis von Abfragen in einem Stapel abgerufen werden, bleiben bis zum Ende des Stapels als Ganzes bestehen oder bis eine Abfrage ausgeführt wird, die die temporären Tabellen zerstört.

Ein weiteres wichtiges Detail für Batch-Abfragen in 1C ist, dass wir im Gegensatz zu verschachtelten Abfragen das Ergebnis jeder Abfrage im Batch separat erhalten können.

Ein Beispiel für die Erstellung eines Anforderungspakets in der 1C-Sprache

Um ein Beispiel für die Erstellung eines Abfragepakets zu sehen, verwenden wir den Abfrage-Designer, den wir der Übersichtlichkeit halber über die Abfragekonsole aufrufen. Somit können wir sofort das Ergebnis der Ausführung des Pakets sehen.

Lassen Sie uns eine einfache Batch-Anfrage erstellen. Ich schlage vor, den Anforderungstext sofort in die Konsole einzufügen, dann den Konstruktor zu öffnen und zu sehen, wie das Anforderungspaket gebildet wird. Fügen Sie der Konsole eine neue Anfrage hinzu und fügen Sie den folgenden Text ein:

Selbsttragend.Elternteil,

Selbsttragend. Code,

Selbsttragend. Schnellauswahlcode,

Selbsttragend. Name,

Selbsttragender Typ,

Selbsttragend. Außerbilanziell,

Selbsttragend. Quantitativ,

Kontenplan. Selbsttragend AS Selbsttragend

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

Selbsttragende TypenSubconto.Zeilennummer AS Zeilennummer,

Selbsttragende Typen von Subconto.ViewSubconto AS TypeSubconto,

Self-supportingTypesSubconto.TypeSubconto.Name AS Name,

Self-supportingTypesSubconto.TypeSubconto.ValueType ASValueType,

SelbsttragendTypesSubconto.OnlyTurnover AS OnlyTurnover,

Self-supportingTypesSubconto.Summary AS Summative

Kontenplan. Selbsttragend. Arten von Unterkonten AS Selbstbuchhaltung. Arten von Unterkonten

SORTIERE NACH

Selbsttragende TypesSubconto.NumberLines

Bei mir sieht es so aus:

Kommen wir nun zum Abfrage-Designer. Hier interessiert uns der Reiter „Paket anfordern“:

Wie Sie sehen, haben wir ein Paket mit zwei Anfragen. Durch Doppelklicken auf eine davon können Sie mit der Bearbeitung fortfahren:

Klicken Sie auf die Schaltfläche „OK“ und versuchen Sie, das Ergebnis der Stapelanforderung anzuzeigen.

Lassen Sie uns den Parameter „Konto“ festlegen. Sie können ein beliebiges Konto aus dem Kontenplan auswählen. Wie Sie wahrscheinlich bereits vermutet haben, muss dieses Anforderungspaket Kontoeigenschaften erhalten. Klicken Sie auf „Ausführen“ und sehen Sie sich das Ergebnis an:

Methoden Run() und RunBatch()

Zusätzlich zur Execute()-Methode, die alle Anfragen nacheinander in einem Stapel ausführt und das Ergebnis der letzten Anfrage zurückgibt, gibt es in 1C eine ExecuteBatch()-Methode. Es gibt ein Array von Beispielen jeder Anforderung im Stapel zurück. Im obigen Beispiel ist dies genau die Methode.

ArrayResults = Query.ExecuteBatch();

Selection1 = ArrayResults.Select();

Wenn Select1.Next() Dann

//Aktionen mit Auswahl 1

endIf;

SelectionViewsSubconto = ArrayResults.Select();

Der Beitrag „Arbeiten mit Batch-Anfragen in 1C 8.3 und 8.2“ erschien erstmals im Blog des Unternehmens 1C GOODWILL.