Verknüpfen von Tabellen mithilfe von QueryExpression

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

• Welche verknüpften 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

LinkEntity-Eigenschaften

Die folgende Tabelle enthält Details zu den LinkEntity-Eigenschaften:

LinkEntity-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. Dies stellt eine n:1-Beziehung dar:

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

AddLink-Methoden

Sie können die gesamte Abfrage mithilfe der Objektinitialisierung wie dargestellt verfassen, es wird jedoch empfohlen, die Methoden QueryExpression.AddLink und LinkEntity.AddLink zu verwenden. Diese Methoden geben einen Verweis auf den erstellten Link zurück, sodass Sie auf einfache Weise auf die Abfrage innerhalb der Auflistung zugreifen und diese ändern können. Wenn Sie beispielsweise die Abfrage auf diese Weise mithilfe 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");

Sie können die Abfrage mit der LinkEntity.AddLink-Methode erweitern, um Informationen über den besitzenden Benutzer des über die linkedPrimaryContactLinkEntity Instanz verknüpften Kontakts einzuschließen.

// 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. Jeder LinkEntity 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 mehr als 15 LinkEntity Instanzen zum QueryExpression.LinkEntities hinzufügen, erhalten Sie diesen Laufzeitfehler:

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

Viele-zu-eins-Beziehungen

Im vorherigen Beispiel handelt es sich um eine Viele-zu-eins-Beziehung, bei der viele Konten auf einen 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

Sie können andere Tools und APIs verwenden, um Beziehungsdaten für die entsprechenden Werte von LinkToEntityName, LinkToAttributeName, LinkFromEntityName und LinkFromAttributeName nachzuschlagen. Weitere Informationen finden Sie unter:

• Durchsuchen von Tabellendefinitionen in Ihrer Umgebung
• Abfrageschemadefinitionen

Beispiel für eine n:1-Beziehung

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

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 das vorherige Beispiel aus der Kontakttabelle mit derselben Beziehung abrufen, mit Ausnahme der Seite der contact Tabelle. 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 Eins-zu-Viele-Beziehung die folgenden Beziehungswerte:

Die Ergebnisse enthalten dieselben Datensätze und Daten wie im vorherigen Beispiel unter Verwendung der n:1-Beziehung, außer dass die "übergeordnete Entität" jetzt contact anstelle von account ist.

 -----------------------------------------------------------------
 | 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 zu Benutzern und den Teams, zu denen sie gehören, mithilfe der teammembership_association n:n-Beziehung 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 verbindet systemuser mit der Schnittpunkttabelle teammembership, wo systemuserid = systemuserid.
• linkedTeam stellt eine Verbindung von der überschneidenden teammembership-Tabelle zu dem Team her, wo teamid = teamid ist.

Die Ergebnisse sollten etwa wie folgt aussehen:

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

Keine Beziehung

Es ist möglich, LinkFromAttributeName- und LinkToAttributeName-Eigenschaften anzugeben, indem Spalten verwendet werden, 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.

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

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

• Datei
• Bild
• MultiSelect-Feld
• PartyList

Einige Spalten können in LinkFromAttributeName und LinkToAttributeName Eigenschaften 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 QueryExpression verwenden, um eine Abfrage zu erstellen, um Datensätze zurückzugeben, die sich nicht in einem Satz befinden, 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. 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 NULL-Werte 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 in Bedingungen, Filtern und geschachtelten Filtern gültig. Weitere Informationen zu Filtern auf LinkEntity

Die folgende Abfrage gibt beispielsweise alle Kontodatensä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");

Verwenden von erweiterten JoinOperators

Die folgenden JoinOperator-Member 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 JoinOperator.Exists oder JoinOperator.In

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. Weder `Exists` noch `In` geben die Spaltenwerte der verknüpften Entitätszeilen zurück.

Die Verwendung von JoinOperator.Exists oder JoinOperator.In kann die Größe von Zwischen- oder Endabfrageergebnissen reduzieren, insbesondere wenn viele passende 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, da 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önnen Dataverse möglicherweise auch ermöglichen, nur die erste passende verlinkte Entitätszeile für jede übergeordnete Zeile zu finden. Dies ist effizienter, als alle passenden Zeilen in der verlinkten Entität zu finden.JoinOperator.Inner

JoinOperator.Exists Beispiel

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

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)

JoinOperator.In Beispiel

Diese Beispiele für QueryExpression und SQL 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);

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

Verwende JoinOperator.MatchFirstRowUsingCrossApply

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

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"

Dies entspricht JoinOperator.LeftOuter , mit der Ausnahme, dass die übergeordnete Zeile höchstens einmal zurückgegeben wird. Im Gegensatz zu JoinOperator.In und JoinOperator.Exists gibt sie Spaltenwerte aus einer der übereinstimmenden Zeilen in der verknüpften Tabelle zurück, wenn übereinstimmende Zeilen vorhanden sind, aber die übergeordnete Zeile wird auch dann zurückgegeben, wenn in der verknüpften Tabelle keine übereinstimmenden Zeilen vorhanden sind. Verwenden Sie dies, wenn nur ein einzelnes Beispiel einer übereinstimmenden Zeile aus der verknüpften Tabelle ausreichend ist und mehrere Kopien der übergeordneten Zeile in den Ergebnissen nicht erforderlich sind.

Nächste Schritte

Erfahren Sie, wie Sie Zeilen anordnen.