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, um mit Ihrer Abfrage mit den folgenden Attributen zurückzukehren:

Die folgende Abfrage gibt beispielsweise bis zu 5 Datensätze aus den Konto - und Kontakttabellen basierend auf der Nachschlagespalte "PrimaryContactId " 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. Jede Verknüpfungsentität fügt der Abfrage eine JOIN hinzu und erhöht die Zeit zum Ausführen der Abfrage. Dieser Grenzwert besteht darin, die Leistung zu schützen. Wenn Sie einer Abfrage mehr als 15 Verknüpfungsentitätselemente hinzufügen, wird dieser Fehler 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 genau wie beim übergeordneten Element hinzufügen, um:

• Auswählen von Spalten aus der verknüpften Tabelle
• Filtern von Zeilen aus der verknüpften Tabelle
• Verbinden einer anderen verknüpften Tabelle

Viele-zu-eins-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 Account account_primary_contact viele-zu-eins-Beziehung definiert, die die folgenden Werte aufweist:

Beziehungsinformationen abrufen

Wenn Sie den XrmToolBoxFetchXML Builder verwenden, können Sie sehen, wie Sie mit diesem Tool 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 zu suchen, die verwendet werden sollen. Erfahren Sie, wie Sie diese Daten abrufen:

• Durchsuchen von Tabellendefinitionen in Ihrer Umgebung
• Abfrageschemadefinitionen

Eins-zu-viele-Beziehungen

n:1- und 1:n-Beziehungen sind wie zwei Seiten einer Medaille. 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 im vorherigen Beispiel aus der Kontakttabelle mithilfe derselben Beziehung abrufen, außer 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:

Die Ergebnisse umfassen dieselben Datensätze und Daten wie die vorherige Abfrage unter Verwendung der n:1-Beziehung, mit der Ausnahme, dass die übergeordnete Entität jetzt contact ist statt 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 hängen von einer Verknüpfungstabelle ab. 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. Es ermöglicht Benutzern, mehreren Teams beizutreten, und Teams, mehrere Benutzer zu haben. TeamMembership enthält die folgenden Spalten: systemuserid, teamid.

Wenn Sie Informationen über Benutzende und die Teams, denen sie angehören, mithilfe der n:n-Beziehung von teammembership_association abrufen möchten, können Sie diese fetchXML-Abfrage verwenden:

<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 die teammembership-Überschneidungstabelle mit dem Team, wobei teamid = teamid.

Die Ergebnisse sollten etwa wie folgt aussehen:

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

Keine Beziehung

Es ist möglich, die Attribute from und to mithilfe von Spalten anzugeben, 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>

Die folgenden Spaltentypen können nicht in from und to Attribute verwendet werden:

• Datei
• Bild
• MultiSelect-Feld
• PartyList

Einige Spalten können in from und to Attribute verwendet werden, können aber 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, um Datensätze zurückzugeben, die sich nicht in einem Satz befinden, mithilfe einer linken äußeren Verknüpfung. Eine linke äußere Verknüpfung gibt jede Zeile zurück, die die Verknüpfung der ersten Eingabe mit der zweiten Eingabe erfüllt. Außerdem werden alle Zeilen aus der ersten Eingabe zurückgegeben, für die keine übereinstimmenden Zeilen in der zweiten Eingabe vorhanden sind. 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>

Verwenden erweiterter Linktypen

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.

Verwenden Sie exists- oder in-Verknüpfungstypen

exists und in sind Varianten von inner, die unterschiedliche Bedingungen (EXISTS bzw. IN) in der where-Klausel verwenden, sodass das Ergebnis mehrere Kopien der übergeordneten Zeile nicht anzeigt. Keine dieser Typen gibt die Spaltenwerte der Zeilen der Verknüpfungsentität zurück.

exists

Diese FetchXml und SQL-Beispiele zeigen die Muster, die mit exists angewendet werden.

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

select 
    "contact0".fullname as "fullname" 
from Contact as "contact0" 
where exists (
    select "account1".primarycontactid
    from Account as "account1"
    where "account1".statecode = 1
        and "contact0".contactid = "account1".primarycontactid)

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>

select 
    "contact0".fullname as "fullname" 
from Contact as "contact0" 
where "contact0".contactid in (
    select "account1".primarycontactid
    from Account as "account1"
    where "account1".statecode = 1)

Verwendung von exists oder in Verknüpfungstypen kann die Größe der Zwischen- oder Endabfrageergebnisse verringern, insbesondere, wenn viele übereinstimmende verknüpfte Zeilen für dieselben übergeordneten Zeilen vorhanden sind oder wenn mehrere Verknüpfungsentitäten mit demselben übergeordneten verwendet werden. Die Verwendung von exists- oder in-Verknüpfungstypen kann die Leistung der Abfrage im Vergleich zum inner-Typ verbessern, da kein kartesisches Produkt zurückgegeben werden muss, das alle möglichen Permutationen von Zeilen aus verschiedenen verknüpften Entitäten für jede übergeordnete Zeile enthält.

Diese Verknüpfungstypen ermöglichen Dataverse möglicherweise auch, nur die erste übereinstimmende verknüpfte Entitätszeile für jede übergeordnete Zeile zu finden, was effizienter ist, als alle übereinstimmenden Zeilen in der verknüpften Entität in einer inner Verknüpfung zu finden.

Linktyp verwenden matchfirstrowusingcrossapply

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>

select 
    "contact0".fullname as "fullname",
    "account1".accountid as "accountid",
    "account1".name as "name" 
from Contact as "contact0"
cross apply (
    select top 1
        "account1".accountid as "accountid",
        "account1".name as "name"
    from Account as "account1"
    where "contact0".contactid = "account1".primarycontactid
  ) "account1"

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 dies, wenn nur ein einzelnes Beispiel für eine übereinstimmende Zeile aus der verknüpften Entität ausreichend ist und mehrere Kopien der übergeordneten Zeile in den Ergebnissen nicht erforderlich sind.

Verwandte Tabelleneigenschafts-/Attributnamen sind inkonsistent

Bei Verwendung des Linktyps matchfirstrowusingcrossapply unterscheiden sich die Namen der Eigenschaften, die über die Web-API zurückgegeben werden, oder die Werte der SDK Entity.Attributes-SammlungKeys für die zugehörigen Tabellenspalten von anderen Arten von Verknüpfungen. In der Regel folgen diese 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 jedem anderen Linktyp können Sie davon ausgehen, dass die Eigenschaften oder Schlüssel diese Namen haben:

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

Bei dem Verknüpfungstyp matchfirstrowusingcrossapply weisen die Eigenschaften oder Schlüssel jedoch folgende Namen auf:

• fullname
• contactid
• AccountId
• Name

Nächste Schritte

Erfahren Sie, wie Sie Zeilen anordnen.