Freigeben über

Tabellen mit QueryExpression verknüpfen

  • Artikel

Verwenden Sie die Eigenschaft QueryExpression.LinkEntities, um die Daten aus zugehörigen Tabellen zu beschreiben, die mit Ihrer Abfrage zurückgegeben werden sollen. Diese Eigenschaft enthält eine Sammlung von LinkEntity-Instanzen, die Folgendes beschreiben:

  • Welche zugehörigen Tabellenzeilen zurückgegeben werden sollen
  • Auf welchen Spaltenwerten die Verknüpfung basieren soll
  • Welche Spalten dieser Datensätze zurückgegeben werden sollen
  • Alle Filter, die mit der Verknüpfung angewendet werden sollen

Hinweis

Die LinkEntities-Eigenschaft ist schreibgeschützt. Sie können LinkEntity-Instanzen mithilfe der Objektinitialisierung oder durch Verwendung der QueryExpression.AddLink-Methode auf diese Sammlung festlegen.

Sie können auch System.Collections.ObjectModel.Collection<T>-Methoden verwenden, welche die LinkEntities-Eigenschaft erbt.

LinkEntity-Eigenschaften

Die folgende Tabelle enthält detaillierte Angaben über LinkEntity-Eigenschaften:

Eigenschaften Beschreibung
LinkFromEntityName Der logische Name der Entität, von der aus Sie eine Verknüpfung herstellen.
Für eine nicht verschachtelte LinkEntity verwenden Sie den gleichen Wert wie die QueryExpression.EntityName-Eigenschaft.
Verwenden Sie für eine LinkEntity, die in einer LinkEntity.LinkEntities-Sammlung verschachtelt ist, den Wert von LinkEntity.LinkToEntityName aus der übergeordneten Linkentität.
LinkToEntityName Der logische Name der Entität, mit der Sie eine Verknüpfung herstellen.
LinkFromAttributeName Der logische Name des Attributs der Entität, von der aus Sie eine Verknüpfung herstellen.
LinkToAttributeName Der logische Name des Attributs der Entität, mit der Sie eine Verknüpfung herstellen.
JoinOperator Der Verknüpfungsoperator. Verwenden Sie den Wert eines der Elemente der JoinOperator-Enumeration. Der Standardwert ist Inner, wodurch die Ergebnisse auf Zeilen mit übereinstimmenden Werten in beiden Tabellen beschränkt werden.
Andere gültige Werte sind:
- LeftOuter: Schließt Ergebnisse aus der übergeordneten Zeile ein, die keinen übereinstimmenden Wert haben.
- Natural: Wenn ein Gleich-Verknüpfungsvorgang ausgeführt wird und die beiden Werte identisch sind, wird nur ein Wert der beiden verbundenen Spalten zurückgegeben.
Diese Elemente werden als erweiterte JoinOperators betrachtet:
- Exists
- In
- MatchFirstRowUsingCrossApply
Diese Elemente werden zum Filtern von Werten in zugehörigen Datensätzen verwendet:
- All
- Any
- NotAll
- NotAny
EntityAlias Das Alias der Tabelle.
Columns Die Spalten, die in die Tabelle aufgenommen werden sollen. Fügen Sie diese Spalten mit einem ColumnSet zur verknüpften Tabelle hinzu. Erfahren Sie, wie man Spalten mit QueryExpression auswählt
LinkCriteria Die komplexe Bedingung und logischen Filterausdrücke, welche die Ergebnisse der Abfrage filtern. Erfahren Sie, wie man Zeilen mithilfe von QueryExpression filtert.
LinkEntities Die Sammlung von Links zwischen Entitäten, die verschachtelte Links enthalten kann. Insgesamt können bis zu 15 Links in eine Abfrage einbezogen werden

Hinweis

Die LinkEntity.LinkFromAttributeName und LinkEntity.LinkToAttributeName-Eigenschaft haben die gegenteilige Bedeutung der entsprechenden from- und to-Attribute in FetchXml. Erfahren Sie mehr über die Verwendung von from- und to-Attributen mit FetchXml

LinkEntity-Beispiel

Die folgende Abfrage gibt bis zu fünf Datensätze aus den Tabellen Konto und Kontakt zurück, basierend auf der Suchspalte PrimaryContactId im Kontodatensatz. Dies steht für eine n:1-Beziehung:

QueryExpression query = new("account")
{
      TopCount = 5,
      ColumnSet = new ColumnSet("name"),
      LinkEntities = {
            new LinkEntity()
            {
                  LinkFromEntityName = "account",
                  LinkToEntityName = "contact",
                  LinkFromAttributeName = "primarycontactid",
                  LinkToAttributeName = "contactid",
                  JoinOperator = JoinOperator.Inner,
                  EntityAlias = "contact",
                  Columns = new ColumnSet("fullname")
            }
      }
};

Die Ergebnisse sehen folgendermaßen aus:

 -----------------------------------------------------------------
 | name                             | contact.fullname           |
 -----------------------------------------------------------------
 | Litware, Inc. (sample)           | Susanna Stubberod (sample) |
 -----------------------------------------------------------------
 | Adventure Works (sample)         | Nancy Anderson (sample)    |
 -----------------------------------------------------------------
 | Fabrikam, Inc. (sample)          | Maria Campbell (sample)    |
 -----------------------------------------------------------------
 | Blue Yonder Airlines (sample)    | Sidney Higa (sample)       |
 -----------------------------------------------------------------
 | City Power & Light (sample)      | Scott Konersmann (sample)  |
 -----------------------------------------------------------------

Sie können die gesamte Abfrage wie gezeigt mithilfe der Objektinitialisierung zusammenstellen. Wir empfehlen jedoch die Verwendung der QueryExpression.AddLink- und LinkEntity.AddLink-Methoden. Diese Methoden geben einen Verweis auf den erstellten Link zurück, sodass Sie innerhalb der Sammlung problemlos auf die Abfrage zugreifen und sie ändern können. Wenn Sie die Abfrage beispielsweise mit der QueryExpression.AddLink-Methode verfassen:

var query = new QueryExpression("account")
{
      TopCount = 5,
      ColumnSet = new ColumnSet("name"),
};

// Link to primary contact
LinkEntity linkedPrimaryContact = query.AddLink(
      linkToEntityName: "contact",
      linkFromAttributeName: "primarycontactid",
      linkToAttributeName: "contactid",
      joinOperator: JoinOperator.Inner);

linkedPrimaryContact.EntityAlias = "primarycontact";
linkedPrimaryContact.Columns = new ColumnSet("fullname");

Können Sie die Abfrage mit der LinkEntity.AddLink-Methode erweitern, um Informationen zum zuständigen Benutzenden für den über die linkedPrimaryContact LinkEntity-Instanz verknüpften Kontakt mitaufnehmen:

// Link to contact owning user
LinkEntity linkedContactOwner = linkedPrimaryContact.AddLink(
      linkToEntityName: "systemuser",
      linkFromAttributeName: "owninguser",
      linkToAttributeName: "systemuserid",
      joinOperator: JoinOperator.Inner);

linkedContactOwner.EntityAlias = "owner";
linkedContactOwner.Columns = new ColumnSet("fullname");

Auf diese Weise können Sie einfacher auf die verschiedenen Teile der Abfrage zugreifen, um Anpassungen vorzunehmen.

Einschränkungen

Sie können einer Abfrage bis zu 15 LinkEntity-Instanzen hinzufügen. Jedr LinkEntity fügt der Abfrage einen JOIN hinzu und erhöht die zum Ausführen der Abfrage benötigte Zeit. Dieser Grenzwert dient dem Schutz der Leistung. Wenn Sie mehr als 15 LinkEntity-Instanzen zu QueryExpression.LinkEntities hinzufügen, erhalten Sie diesen Laufzeitfehler:

Name: TooManyLinkEntitiesInQuery Code: 0x8004430D
Nummer: -2147204339
Meldung: Number of link entities in query exceeded maximum limit.

n:1-Beziehungen

Das vorherige Beispiel ist eine n:1-Beziehung, bei der viele Kontodatensätze auf einen einzigen Kontaktdatensatz verweisen können. Diese Informationen werden in der n:1-Beziehung Konto „account_primary_contact“ n:1-Beziehung definiert, die die folgenden Werte hat:

Eigenschaften Wert Kommentieren
SchemaName account_primary_contact Eindeutiger Name der Beziehung.
ReferencedEntity contact Die Tabelle, auf die verwiesen wurde. Die 1 in der n:1-Beziehung. LinkToEntityName im vorhergehenden Beispiel.
ReferencedAttribute contactid Das primäre Schlüssel der referenzierten Tabelle. LinkToAttributeName im vorhergehenden Beispiel.
ReferencingEntity account Die Tabelle mit einer Suchspalte, die auf die andere Tabelle verweist. Das n in der n:1-Beziehung. LinkFromEntityName im vorhergehenden Beispiel.
ReferencingAttribute primarycontactid Der Name der Suchspalte. LinkFromAttributeName im vorhergehenden Beispiel.
RelationshipType OneToManyRelationship Eine 1:n-Beziehung, wenn sie aus der referenzierten contact-Tabelle (1) betrachtet wird.
Eine n:1-Beziehung, wenn sie aus der referenzierenden account-Tabelle (n) betrachtet wird

Beziehungsinformationen abrufen

Sie können andere Tools und APIs verwenden, um in den Beziehungsdaten die entsprechenden LinkToEntityName-, LinkToAttributeName-, LinkFromEntityName und LinkFromAttributeName-Werte nachzuschlagen. Weitere Informationen finden Sie unter

Beispiel für n:1-Beziehungen

In der folgenden Tabelle sind die zu verwendenden Beziehungswerte für eine n:1-Beziehung aufgeführt:

Eigenschaften Beziehungswert Kommentieren
LinkFromEntityName ReferencingEntity Die Tabelle, auf die verwiesen wurde. Das n in der n:1-Beziehung. account im Beispiel für n:1-Beziehungen. Für diese Eigenschaft gibt es in den AddLink-Methoden keinen Parameter, da er aus den QueryExpression.EntityName- oder LinkEntity.LinkToEntityName-Eigenschaften abgeleitet werden kann.
LinkToEntityName ReferencedEntity Die Tabelle mit einem Primärschlüssel, auf den die andere Tabelle verweist. Die 1 in der n:1-Beziehung. contact im Beispiel für n:1-Beziehungen.
LinkFromAttributeName ReferencingAttribute Der Name der Suchspalte. primarycontactid im Beispiel für n:1-Beziehungen.
LinkToAttributeName ReferencedAttribute Das primäre Schlüssel der referenzierten Tabelle. contactid im Beispiel für n:1-Beziehungen.

Eins-zu-viele-Beziehungen

n:1- und 1:n-Beziehungen sind wie zwei Seiten einer Medaille. Die Beziehung besteht zwischen den Tabellen. Die Art und Weise, wie Sie sie verwenden, hängt also davon ab, welche Tabelle die Basistabelle für Ihre Abfrage ist.

Hinweis

Wenn Ihre Basistabelle die Suchspalte enthält, handelt es sich um eine n:1-Beziehung. Andernfalls handelt es sich um eine 1:n-Beziehung.

Sie können dieselben Daten wie im vorherigen Beispiel aus der Kontakttabelle abrufen, indem Sie dieselbe Beziehung verwenden, allerdings von der Seite der contact-Tabelle aus. Verwenden Sie die Daten aus derselben Kontakt account_primary_contact 1:n-Beziehung, passen Sie die Werte jedoch für die unterschiedliche Ansicht der Beziehung an.

var query = new QueryExpression("contact")
{
      TopCount = 5,
      ColumnSet = new ColumnSet("fullname"),
};

// Link to related account
var linkedPrimaryContact = query.AddLink(
      linkToEntityName: "account",
      linkFromAttributeName: "contactid",
      linkToAttributeName: "primarycontactid",
      joinOperator: JoinOperator.Inner);

linkedPrimaryContact.EntityAlias = "account";
linkedPrimaryContact.Columns = new ColumnSet("name");

Verwenden Sie für eine 1:n-Beziehung die folgenden Beziehungswerte:

Eigenschaften Beziehungswert Kommentieren
LinkFromEntityName ReferencedEntity Die Tabelle, auf die verwiesen wurde. Die 1 in der n:1-Beziehung. contact im Beispiel für 1:n-Beziehungen. Für diese Eigenschaft gibt es in den AddLink-Methoden keinen Parameter, da er aus den QueryExpression.EntityName- oder LinkEntity.LinkToEntityName-Eigenschaften abgeleitet werden kann.
LinkToEntityName ReferencingEntity Die Tabelle mit einer Suchspalte, die auf die andere Tabelle verweist. Das n in der n:1-Beziehung. account im Beispiel für 1:n-Beziehungen.
LinkFromAttributeName ReferencedAttribute Das primäre Schlüssel der referenzierten Tabelle. contactid im Beispiel für 1:n-Beziehungen.
LinkToAttributeName ReferencingAttribute Der Name der Suchspalte. primarycontactid im Beispiel für 1:n-Beziehungen.

Die Ergebnisse enthalten dieselben Datensätze und Daten wie im vorhergehenden Beispiel mit der n:1-Beziehung, mit dem Unterschied, dass die übergeordnete Entität jetzt contact statt account lautet.

 -----------------------------------------------------------------
 | fullname                   | account.name                     |
 -----------------------------------------------------------------
 | Susanna Stubberod (sample) | Litware, Inc. (sample)           |
 -----------------------------------------------------------------
 | Nancy Anderson (sample)    | Adventure Works (sample)         |
 -----------------------------------------------------------------
 | Maria Campbell (sample)    | Fabrikam, Inc. (sample)          |
 -----------------------------------------------------------------
 | Sidney Higa (sample)       | Blue Yonder Airlines (sample)    |
 -----------------------------------------------------------------
 | Scott Konersmann (sample)  | City Power & Light (sample)      |
 -----------------------------------------------------------------

Viele-zu-viele-Beziehungen

n:n-Beziehungen hängen von einer Überschneidungstabelle ab. Eine Überschneidungstabelle hat normalerweise nur vier Spalten, von denen jedoch nur zwei wichtig sind. Die beiden wichtigen Spalten stimmen mit den Primärschlüsselspalten der teilnehmenden Tabellen überein.

Beispielsweise unterstützt die TeamMembership-Überschneidungstabelle die teammembership_association n:n-Beziehung zwischen SystemUser- und Team-Tabellen. Es ermöglicht Benutzenden, mehreren Teams beizutreten, und Teams können mehrere Benutzende haben. TeamMembership hat diese Spalten: systemuserid, teamid.

Wenn Sie mithilfe der n:n-teammembership_association-Beziehung Informationen zu Benutzenden und den Teams, denen Sie angehören, abrufen möchten, können Sie diese QueryExpression-Abfrage verwenden:

var query = new QueryExpression("systemuser")
{
      TopCount = 2,
      ColumnSet = new ColumnSet("fullname"),
};

LinkEntity linkedTeamMemberShip = query.AddLink(
      linkToEntityName: "teammembership",
      linkFromAttributeName: "systemuserid",
      linkToAttributeName: "systemuserid");

LinkEntity linkedTeam = linkedTeamMemberShip.AddLink(
      linkToEntityName: "team",
      linkFromAttributeName: "teamid",
      linkToAttributeName: "teamid");

linkedTeam.EntityAlias = "team";
linkedTeam.Columns = new ColumnSet("name");

Es gibt zwei LinkEntity-Instanzen.

  • linkedTeamMemberShip stellt eine Verbindung von systemuser zur überschneidenden teammembership-Tabelle her, wo systemuserid = systemuserid ist.
  • linkedTeam stellt eine Verbindung von der überschneidenden teammembership-Tabelle zu dem Team her, wo teamid = teamid ist.

Die Ergebnisse sollten in etwa so aussehen:

 --------------------------------------
 | fullname             | team.name   |
 --------------------------------------
 | FirstName LastName   | org26ed931d |
 --------------------------------------
 | # PpdfCDSClient      | org26ed931d |
 --------------------------------------

Keine Beziehung

Es ist möglich, LinkFromAttributeName- und LinkToAttributeName-Eigenschaften mithilfe von Spalten anzugeben, die nicht zu einer festgelegten Beziehung gehören.

Diese Abfrage findet beispielsweise Datensatzpaare, bei denen die Spalte „Name“ eines Konto-Datensatzes der Spalte „FullName“ eines Kontakt-Datensatzes entspricht, unabhängig davon, ob sie in einer der Suchspalten aufeinander verweisen.

var query = new QueryExpression("account")
{
      ColumnSet = new ColumnSet("name"),
};

LinkEntity linkedContact = query.AddLink(
      linkToEntityName: "contact", 
      linkFromAttributeName: "name", 
      linkToAttributeName: "fullname");
linkedContact.EntityAlias = "contact";
linkedContact.Columns = new ColumnSet("fullname");

Hinweis

Es ist wichtig, dass die in den LinkFromAttributeName- und LinkToAttributeName-Eigenschaften angegebenen Spalten vom gleichen Typ sind, auch wenn sie nicht in eine Beziehung eingebunden sind. Werden Spalten unterschiedlicher Typen verwendet, muss eine Typkonvertierung durchgeführt werden, die sich auf die Leistung auswirken und bei einigen Spaltenwerten fehlschlagen kann.

Die folgenden Spaltentypen können in LinkFromAttributeName- und LinkToAttributeName-Eigenschaften nicht verwendet werden:

  • Datei
  • Image
  • Feld „MultiSelect“
  • PartyList

Einige Spalten können in LinkFromAttributeName- und LinkToAttributeName-Eigenschaften verwendet werden, können aber Leistungseinbußen verursachen:

  • Spalten des Mehrere Textzeilen-Typs
  • Spalten des Einzelne Textzeile-Typs mit einer maximalen Länge größer als 850
  • Formel-Spalten
  • Berechnete Spalten
  • Logische Spalten

Nach Datensätzen suchen, die nicht in einem Satz enthalten sind

Mit QueryExpression können Sie mithilfe einer linken äußeren Verknüpfung eine Abfrage erstellen, die Datensätze zurückgibt, die nicht in einem Satz enthalten sind. Eine linke äußere Verknüpfung gibt jede Zeile zurück, die der Verknüpfung der ersten Eingabe mit der zweiten Eingabe entspricht. Es werden auch alle Zeilen aus der ersten Eingabe zurückgegeben, die in der zweiten Eingabe keine Übereinstimmung haben. Die nicht übereinstimmenden Zeilen in der zweiten Eingabe werden als Nullwerte zurückgegeben.

Sie können eine linke äußere Verknüpfung in QueryExpression durchführen, indem Sie die ConditionExpression.EntityName-Eigenschaft verwenden. Die EntityName-Eigenschaft ist auch für die Bedingungen, Filter und geschachtelte Filter gültig. Erfahren Sie mehr über Filter auf LinkEntity

Beispielsweise gibt die folgende Abfrage alle Kontaktdatensätze ohne Kontakte zurück.

var query = new QueryExpression(entityName: "account");
query.ColumnSet.AddColumn("name");
query.AddOrder(
      attributeName: "name", 
      orderType: OrderType.Descending);
query.Criteria.AddCondition(
      entityName: "contact",
      attributeName: "parentcustomerid",
      conditionOperator: ConditionOperator.Null);

LinkEntity linkedContact = query.AddLink(
      linkToEntityName: "contact",
      linkFromAttributeName: "accountid",
      linkToAttributeName: "parentcustomerid",
      joinOperator: JoinOperator.LeftOuter);
linkedContact.EntityAlias = "contact";
linkedContact.Columns.AddColumn("fullname");

Erweiterte JoinOperators verwenden in

Die folgenden JoinOperator-Elemente entsprechen nicht direkt T-SQL Verknüpfungsoperatortypen und verwenden stattdessen Unterabfragen. Diese Typen bieten erweiterte Funktionen, mit denen Sie die Abfrageleistung verbessern und komplexere Abfragen definieren können.

Name des Dataflows Beschreibung
Exists Eine Variante von Inner kann Leistungsvorteile bieten. Verwendet eine VORHANDEN-Bedingung in der where-Klausel. Verwenden Sie Exists, wenn nicht mehrere Kopien der übergeordneten Zeile in den Ergebnissen erforderlich sind. Erfahren Sie mehr über Exists und In.
In Eine Variante von Inner kann Leistungsvorteile bieten. Verwendet eine IN-Bedingung in der Where-Klausel. Verwenden Sie In, wenn nicht mehrere Kopien der übergeordneten Zeile in den Ergebnissen erforderlich sind. Erfahren Sie mehr über Exists und In.
MatchFirstRowUsingCrossApply Eine Variante von Inner kann Leistungsvorteile bieten. Verwenden Sie diesen Typ, wenn nur ein einziges Beispiel einer übereinstimmenden Zeile aus der verknüpften Entität ausreicht und mehrere Kopien der übergeordneten Zeile in den Ergebnissen nicht erforderlich sind. Erfahren Sie mehr über die Verwendung von MatchFirstRowUsingCrossApply

Verwenden Sie JoinOperator.Exists oder JoinOperator.In

Exists und In sind Varianten von Inner, die unterschiedliche Bedingungen (jeweils EXISTIERT und IN) in der where-Klausel verwenden, damit nicht mehrere Kopien der übergeordneten Zeile in den Ergebnissen zurückgegeben werden. Weder Exists noch In geben die Spaltenwerte der zugehörigen Entitätszeilen zurück.

Die Verwendung von JoinOperator.Exists oder JoinOperator.In kann die Größe von Zwischen- oder Endergebnissen von Abfragen verringern, insbesondere wenn viele übereinstimmende verknüpfte Zeilen für dieselben übergeordneten Zeilen vorhanden sind oder wenn mehrere Verknüpfungselemente mit demselben übergeordneten Element verwendet werden. Die Verwendung von JoinOperator.Exists oder JoinOperator.In kann die Leistung der Abfrage im Vergleich zu JoinOperator.Inner verbessern, weil es nicht erforderlich ist, ein kartesisches Produkt zurückzugeben, das alle möglichen Permutationen von Zeilen aus verschiedenen verknüpften Entitäten für jede übergeordnete Zeile enthält.

Diese JoinOperator-Elemente könnten auch Dataverse zulassen, um nur die erste passende verknüpfte Entitätszeile für jede übergeordnete Zeile zu finden, was effizienter ist, als alle übereinstimmenden Zeilen in der mit JoinOperator.Inner verknüpften Entität zu finden ist.

Beispiel für JoinOperator.Exists

Diese QueryExpression und SQL-Beispiele zeigen die Muster, die mit JoinOperator.Exists angewendet werden.

QueryExpression query = new("contact");
query.ColumnSet.AddColumn("fullname");

LinkEntity linkedAccount = query.AddLink(
      linkToEntityName: "account",
      linkFromAttributeName: "contactid",
      linkToAttributeName: "primarycontactid",
      joinOperator: JoinOperator.Exists);

linkedAccount.EntityAlias = "account";

linkedAccount.LinkCriteria.AddCondition(
      entityName:"account", 
      attributeName: "statecode", 
      conditionOperator: ConditionOperator.Equal,
      values: 1);

Beispiel für JoinOperator.In

Diese QueryExpression und SQL-Beispiele zeigen die Muster, die mit JoinOperator.In angewendet werden.

QueryExpression query = new("contact");
query.ColumnSet.AddColumn("fullname");

LinkEntity linkedAccount = query.AddLink(
      linkToEntityName: "account",
      linkFromAttributeName: "contactid",
      linkToAttributeName: "primarycontactid",
      joinOperator: JoinOperator.In);

linkedAccount.EntityAlias = "account";

linkedAccount.LinkCriteria.AddCondition(
      entityName: "account",
      attributeName: "statecode",
      conditionOperator: ConditionOperator.Equal,
      values: 1);

JoinOperator.MatchFirstRowUsingCrossApply verwenden

JoinOperator.MatchFirstRowUsingCrossApply erzeugt einen CROSS APPLY-Operator mit einer Unterabfrage mithilfe von top 1 nach diesem Muster:

QueryExpression query = new("contact");
query.ColumnSet.AddColumn("fullname");

LinkEntity linkedAccount = query.AddLink(
      linkToEntityName: "account",
      linkFromAttributeName: "contactid",
      linkToAttributeName: "primarycontactid",
      joinOperator: JoinOperator.MatchFirstRowUsingCrossApply);

linkedAccount.EntityAlias = "account";
linkedAccount.Columns = new ColumnSet("accountid", "name");

Dies entspricht JoinOperator.LeftOuter, außer dass die übergeordnete Zeile höchstens einmal zurückgegeben wird. Im Gegensatz zu JoinOperator.In und JoinOperator.Exists werden Spaltenwerte aus einer der übereinstimmenden Zeilen in der verknüpften Tabelle zurückgegeben, wenn übereinstimmende Zeilen vorhanden sind. Die übergeordnete Zeile wird jedoch auch dann zurückgegeben, wenn in der verknüpften Tabelle keine übereinstimmenden Zeilen vorhanden sind. Verwenden Sie dies, wenn nur ein einziges Beispiel einer übereinstimmenden Zeile aus der zugehörigen Tabelle ausreicht und nicht mehrere Kopien der übergeordneten Zeile in den Ergebnissen erforderlich sind.

Nächste Schritte,

Erfahren Sie, wie Sie Zeilen anordnen.

Bestellzeilen

Hinweis

Können Sie uns Ihre Präferenzen für die Dokumentationssprache mitteilen? Nehmen Sie an einer kurzen Umfrage teil. (Beachten Sie, dass diese Umfrage auf Englisch ist.)

Die Umfrage dauert etwa sieben Minuten. Es werden keine personenbezogenen Daten erhoben. (Datenschutzbestimmungen).