Freigeben über

Verknüpfen von Tabellen mithilfe von FetchXML

Wie in Abfragedaten mithilfe von FetchXml beschrieben, starten Sie Ihre Abfrage, indem Sie eine Tabelle mithilfe des Entitätselements auswählen.

Verwenden Sie das Linkentitätselement , um die Daten aus verknüpften Tabellen zu beschreiben, die Sie mit Ihrer Abfrage zurückgeben möchten. Verwenden Sie die folgenden Attribute:

Merkmal Kurzbeschreibung Weitere Details finden Sie in der Referenz zum Linkentitätselement
name Der logische Name der Bezugstabelle.
from Der logische Name der Spalte aus der verknüpften Tabelle, die der im to Attribut angegebenen Spalte entspricht.
to Der logische Name der Spalte im übergeordneten Element, das mit der zugehörigen Tabelle abgeglichen wird, die im from-Attribut angegebenen ist.
link-type Der Typ des zu verwendenden Links. Der Standardwert ist inner, wodurch Ergebnisse auf Zeilen mit übereinstimmenden Werten in beiden Tabellen beschränkt werden.
Andere gültige Werte sind:
- outer
- any
- not any
- all
- not all
- exists
- in
- matchfirstrowusingcrossapply
Erfahren Sie mehr über Linktypoptionen.
alias Stellt den Namen der verknüpften Tabelle in den Ergebnissen dar.
intersect Gibt an, dass die link-entity Zum Verknüpfen von Tabellen verwendet wird und keine Spalten zurückgibt.

Einfaches Beispiel

Die folgende Abfrage gibt bis zu fünf Datensätze aus den Konto - und Kontakttabellen basierend auf der PrimaryContactId-Nachschlagespalte im Kontodatensatz zurück:

<fetch top='5'>
   <entity name='account'>
      <attribute name='name' />
      <link-entity name='contact'
         from='contactid'
         to='primarycontactid'
         link-type='inner'
         alias='contact'>
         <attribute name='fullname' />
      </link-entity>
   </entity>
</fetch>

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)  |
 -----------------------------------------------------------------

Einschränkungen

Sie können einer Abfrage bis zu 15 link-entity Elemente hinzufügen. Jeder link-entity fügt der Abfrage eine JOIN hinzu und erhöht die Zeit, die zum Ausführen der Abfrage benötigt wird. Dieser Grenzwert schützt die Leistung. Wenn Sie einer Abfrage mehr als 15 link-entity Elemente hinzufügen, wird diese Fehlermeldung angezeigt:

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

Untergeordnete Elemente

Innerhalb des link-entity-Elements können Sie untergeordnete Elemente hinzufügen, ähnlich wie im übergeordneten Element.

Viele-zu-eins-Beziehungen

Das grundlegende Beispiel zeigt eine n:1-Beziehung, bei der viele Kontodatensätze auf einen Kontaktdatensatz verweisen können. Sie definieren diese Informationen in der Konto-account_primary_contact 1:1-Beziehung, die die folgenden Werte aufweist:

Eigentum Wert Kommentar
SchemaName account_primary_contact Eindeutiger Name der Beziehung.
ReferencedEntity contact Die tabelle, auf die verwiesen wird. Die 1 in der n:1-Beziehung.
ReferencedAttribute contactid Der Primärschlüssel der tabelle, auf die verwiesen wird.
ReferencingEntity account Die Tabelle mit einer Nachschlagespalte, die auf die andere Tabelle verweist. Das n in der n:1-Beziehung.
ReferencingAttribute primarycontactid Der Name der Nachschlagespalte.
RelationshipType OneToManyRelationship Eine 1:n-Beziehung, wenn sie aus der referenzierten Tabelle (1) betrachtet wird.
Eine viele-zu-eins-Beziehung, wenn man sie von der referenzierenden (viele) Tabelle betrachtet.

Beziehungsinformationen abrufen

Wenn Sie Tools wie XrmToolBoxFetchXML Builder oder Power Platform ToolBoxFetchXML Studio verwenden, können Sie sehen, wie Sie mit diesen Tools die Beziehung auswählen können, um die entsprechenden nameWerte fromund to Attributwerte festzulegen.

Sie können auch andere Tools und APIs verwenden, um Beziehungsdaten für die entsprechenden name, fromund to Attributwerte nachzuschlagen. Informationen zum Abrufen dieser Daten finden Sie unter:

Eins-zu-viele-Beziehungen

Viele-zu-eins-Beziehungen und Eins-zu-viele-Beziehungen sind wie zwei Seiten derselben Münze. Die Beziehung besteht zwischen den Tabellen, sodass die Art und Weise, wie Sie sie verwenden, von der Basistabelle für Ihre Abfrage abhängt.

Sie können dieselben Daten wie das vorherige Beispiel aus der Kontakttabelle mit derselben Beziehung abrufen, aber von der Seite der Kontakttabelle. 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.

<fetch top='5'>
   <entity name='contact'>
      <attribute name='fullname' />
      <link-entity name='account'
         from='primarycontactid'
         to='contactid'
         alias='account'>
         <attribute name='name' />
      </link-entity>
   </entity>
</fetch>

Die folgende Tabelle zeigt die link-entity Attributswerte in diesem Beispiel:

Merkmal Wert Description
name account Der logische Name der referenzierenden Tabelle
from primarycontactid Der Name der Suchspalte in der referenzierten Kontotabelle
to contactid Der Primärschlüssel der referenzierten Kontakttabelle
alias account Für link-entity wird ein Wert mit einer 1:n-Beziehung empfohlen. Wenn Sie keinen Alias angeben, generiert das System einen Standardalias. Wenn Sie in diesem Beispiel keinen Alias angeben, werden die Daten mit einer Spalte mit dem Namen account1.namezurückgegeben.
link-type Nicht festgelegt Wenn Sie keinen Wert festlegen, wird standardmäßig inner

Die Ergebnisse enthalten dieselben Datensätze und Daten wie die vorhergehende Abfrage, die die Viele-zu-Eins-Beziehung verwendet. Der Unterschied besteht darin, dass die übergeordnete Entität jetzt contact anstelle von account.

 -----------------------------------------------------------------
 | 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)      |
 -----------------------------------------------------------------

M:n-Beziehungen

Viele-zu-viele-Beziehungen basieren auf einer Zwischentabelle. Eine überschneidene Tabelle hat in der Regel nur vier Spalten, aber nur zwei davon sind wichtig. Die beiden wichtigen Spalten entsprechen den Primärschlüsselspalten der teilnehmenden Tabellen.

Beispielsweise unterstützt die TeamMembership-Überschneidungstabelle die teammembership_association n:n-Beziehung zwischen SystemUser- und Team-Tabellen. Mithilfe dieser Beziehung können Benutzer mehreren Teams beitreten, und Teams können mehrere Benutzer haben. TeamMembership enthält die folgenden Spalten: systemuserid und teamid.

Verwenden Sie diese fetchXML-Abfrage, um Informationen über Benutzer und die Teams, zu denen sie gehören, abzurufen, indem Sie die teammembership_association viele-zu-viele-Beziehung nutzen.

<fetch top='2'>
   <entity name='systemuser'>
      <attribute name='fullname' />
      <link-entity name='teammembership'
         from='systemuserid'
         to='systemuserid'
         intersect='true' >
         <link-entity name='team'
            from='teamid'
            to='teamid'
            link-type='inner'
            alias='team'>
            <attribute name='name' />
         </link-entity>
      </link-entity>
   </entity>
</fetch>

Es gibt zwei geschachtelte Verknüpfungsentitäten.

  • Die erste verbindet systemuser mit der teammembership-Überschneidungstabelle, in der systemuserid = systemuserid.
  • Die zweite verbindet teammembership die Schnittpunkt-Tabelle an team wo teamid = teamid.

Die Ergebnisse sehen wie folgt aus:

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

Keine Beziehung

Sie können die from- und to-Attribute angeben, indem Sie Spalten verwenden, die nicht Teil einer definierten Beziehung sind.

Diese Abfrage findet beispielsweise Paare von Datensätzen, bei denen die Spalte "Name" eines Kontodatensatzes mit der Spalte "FullName " eines Kontaktdatensatzes übereinstimmt, unabhängig davon, ob sie in einer der Nachschlagespalten aufeinander verweisen.

<fetch>
   <entity name='account'>
     <attribute name='name' />
     <link-entity name='contact'
       from='fullname'
       to='name'
       link-type='inner'
       alias='contact'>
       <attribute name='fullname' />
     </link-entity>
   </entity>
 </fetch>

Hinweis

Stellen Sie sicher, dass die Spalten, die Sie in den from- und to-Attributen angeben, denselben Typ aufweisen, auch wenn sie nicht an einer Beziehung beteiligt sind. Wenn Sie Spalten unterschiedlicher Typen verwenden, benötigt die Abfrage eine Typkonvertierung, die sich auf die Leistung auswirken kann und bei einigen Spaltenwerten fehlschlägt.

Sie können die folgenden Spaltentypen nicht in from und to Attribute verwenden:

Sie können diese Spaltentypen in from und to Attribute verwenden, sie können jedoch zu einer schlechten Leistung führen:

  • Spalten des Typs "Mehrere Textzeilen"
  • Spalten des Typs "Einzelne Textzeile " mit einer maximalen Länge von mehr als 850
  • Formelspalten
  • Berechnete Spalten
  • Logische Spalten

Suchen von Datensätzen, die nicht in einer Gruppe enthalten sind

Sie können FetchXML verwenden, um eine Abfrage zu erstellen, die Datensätze zurückgibt, die nicht in einem Satz enthalten sind, indem Sie eine linke äußere Verknüpfung verwenden. Eine linke äußere Verknüpfung gibt jede Zeile zurück, die die Verknüpfung der ersten Eingabe mit der zweiten Eingabe erfüllt. 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 FetchXML ausführen, indem Sie das entityname Attribut in einem Bedingungselement verwenden. Das entityname Attribut ist in Bedingungen, Filtern und verschachtelten Filtern gültig. Erfahren Sie mehr über Filter für die Verknüpfungsentität.

Die folgende Abfrage gibt beispielsweise alle Kontodatensätze ohne Kontakte zurück.

<fetch>
   <entity name='account'>
      <attribute name='name' />
      <order attribute='name' />
      <link-entity name='contact'
         from='parentcustomerid'
         to='accountid'
         link-type='outer'
         alias='contact' />
      <filter type='and'>
         <condition entityname='contact'
            attribute='parentcustomerid'
            operator='null' />
      </filter>
   </entity>
</fetch>

Die folgenden Verknüpfungsentitätstypen entsprechen nicht direkt den T-SQL JOIN-Operatortypen und verwenden stattdessen Unterabfragen . Diese Typen bieten erweiterte Funktionen, die Sie verwenden können, um die Abfrageleistung zu verbessern und komplexere Abfragen zu definieren.

Name Description
exists Eine Variante von inner, die Leistungsvorteile bieten kann. Verwendet eine EXISTS-Bedingung in der where Klausel. Verwenden Sie dies, wenn mehrere Kopien der übergeordneten Zeile in den Ergebnissen nicht erforderlich sind. Weitere Informationen zu den Funktionen 'exists' und 'in'
in Eine Variante von inner, die Leistungsvorteile bieten kann. Verwendet eine IN-Bedingung in der where Klausel. Verwenden Sie dies, wenn mehrere Kopien der übergeordneten Zeile in den Ergebnissen nicht erforderlich sind. Weitere Informationen zu den Funktionen 'exists' und 'in'
matchfirstrowusingcrossapply Eine Variante von inner, die Leistungsvorteile bieten kann. Verwenden Sie diesen Typ, wenn nur ein einzelnes Beispiel einer übereinstimmenden Zeile aus der verknüpften Entität ausreichend ist und mehrere Kopien der übergeordneten Zeile in den Ergebnissen nicht erforderlich sind. Erfahren Sie mehr über "matchfirstrowusingcrossapply"

Die exists Typen und in Verknüpfungstypen sind Varianten des inner Verknüpfungstyps. Sie verwenden unterschiedliche Bedingungen (EXISTS bzw . IN ) in der where Klausel, sodass die Abfrage nicht mehrere Kopien der übergeordneten Zeile zurückgibt. Keine dieser Verknüpfungstypen gibt die Spaltenwerte der Zeilen der Verknüpfungsentität zurück.

exists

Diese FetchXML- und SQL-Beispiele zeigen die mit exists angewandten Muster.

<fetch>
   <entity name='contact'>
      <attribute name='fullname' />
      <link-entity name='account'
         from='primarycontactid'
         to='contactid'
         link-type='exists'>
         <filter type='and'>
            <condition attribute='statecode'
               operator='eq'
               value='1' />
         </filter>
      </link-entity>
   </entity>
</fetch>

in

Diese FetchXML- und SQL-Beispiele zeigen die Muster, die mit in.

<fetch>
   <entity name='contact'>
      <attribute name='fullname' />
      <link-entity name='account'
         from='primarycontactid'
         to='contactid'
         link-type='in'>
         <filter type='and'>
            <condition attribute='statecode'
               operator='eq'
               value='1' />
         </filter>
      </link-entity>
   </entity>
</fetch>

Die Verwendung exists oder in Verknüpfungstypen können die Größe von Zwischen- oder Endabfrageergebnissen verringern. Diese Reduzierung ist besonders hilfreich, wenn viele übereinstimmende verknüpfte Zeilen für dieselben übergeordneten Zeilen vorhanden sind oder wenn mehrere Verknüpfungsentitäten mit demselben übergeordneten Element verwendet werden. Mithilfe von exists Typen oder in Verknüpfungstypen können Sie die Leistung der Abfrage im Vergleich zum inner Verknüpfungstyp verbessern, da die Abfrage kein kartesisches Produkt zurückgeben muss, das alle möglichen Permutationen von Zeilen aus verschiedenen verknüpften Entitäten für jede übergeordnete Zeile enthält.

Mithilfe dieser Verknüpfungstypen muss Dataverse möglicherweise nur die erste übereinstimmende verknüpfte Entitätszeile für jede übergeordnete Zeile finden. Dieser Ansatz ist effizienter als alle übereinstimmenden Zeilen in der verknüpften Entität in einer inner Verknüpfung zu finden.

Dieser Verknüpfungstyp erzeugt einen CROSS APPLY-Operator mit einer Unterabfrage, die top 1 nach folgendem Muster verwendet.

<fetch>
   <entity name='contact'>
      <attribute name='fullname' />
      <link-entity name='account'
         from='primarycontactid'
         to='contactid'
         link-type='matchfirstrowusingcrossapply'>
         <attribute name='accountid' />
         <attribute name='name' />
      </link-entity>
   </entity>
</fetch>

Der matchfirstrowusingcrossapply Verknüpfungstyp entspricht dem inner Typ, mit der Ausnahme, dass er die übergeordnete Zeile höchstens einmal zurückgibt. Die übergeordnete Zeile wird nur zurückgegeben, wenn es übereinstimmende Zeilen in der verknüpften Entität gibt, aber im Gegensatz zu den Typen in und existsgibt es bei der Übereinstimmung von Zeilen Spaltenwerte aus einer der übereinstimmenden Zeilen in der verknüpften Entität zurück. Verwenden Sie diesen Typ, wenn nur ein einzelnes Beispiel einer übereinstimmenden Zeile aus der verknüpften Entität ausreichend ist, und Die Ergebnisse benötigen nicht mehrere Kopien der übergeordneten Zeile.

Wenn Sie den matchfirstrowusingcrossapply Verknüpfungstyp verwenden, unterscheiden sich die Namen der eigenschaften, die mithilfe der Web-API oder der SDK Entity.Attributes-AuflistungswerteKeys für die verknüpften Tabellenspalten von anderen Verknüpfungstypen zurückgegeben werden. In der Regel folgen diese Namen dem <tablealias>.<logicalname> Format. Für den matchfirstrowusingcrossapply Verknüpfungstyp werden jedoch die SchemaName-Werte ohne das Tabellenaliaspräfix verwendet.

Mithilfe des vorherigen Abfragebeispiels mit einem beliebigen anderen Verknüpfungstyp können Sie davon ausgehen, dass die Eigenschaften oder Schlüssel über diese Namen verfügen:

  • fullname
  • contactid
  • account1.accountid
  • account1.name

Mithilfe des matchfirstrowusingcrossapply Verknüpfungstyps weisen die Eigenschaften oder Schlüssel jedoch folgende Namen auf:

  • fullname
  • contactid
  • AccountId
  • Name

Nächste Schritte

Erfahren Sie, wie Sie Zeilen anordnen.

Zeilen anordnen

  • Last updated on