Daten mithilfe von FetchXML aggregieren

Artikel
07/22/2024

FetchXML umfasst Features zum Gruppieren und Aggregieren, mit denen Sie Summe, Durchschnitt, Minimum, Maximum und die Anzahl über mehrere Reihen von Daten hinweg berechnen können.

Um einen Aggregatwert zurückzugeben, müssen Sie:

Das Attribut Fetch-Element aggregate auf „wahr” festlegen.
Das alias-Attribut für jedes Attributelement festlegen.

Das aggregate-Attribut für jedes Attributelement auf eine dieser Aggregatfunktionen:

Funktion	Zurückgegebener Wert
`avg`	Der Durchschnittswert der Spaltenwerte mit Daten.
`count`	Die Anzahl der Zeilen.
`countcolumn`	Die Anzahl der Zeilen mit Daten in dieser Spalte.
`max`	Der Maximalwert der Zeilen in dieser Spalte.
`min`	Der Minimalwert der Zeilen in dieser Spalte.
`sum`	Der Gesamtwert der Spaltenwerte mit Daten.

Beachten Sie die folgenden Punkte:

Nullwerte werden bei der Berechnung von Aggregatwerten nicht berücksichtigt.
Sie können Daten aus Tabellen verwenden, die mit dem Element Link-Entität verknüpft sind.
Sie können Filter anwenden, um die Ergebnisse wie bei jeder Abfrage einzuschränken.

Beispiel

Nehmen wir an, Sie haben 10 Kontodatensätze mit den folgenden Daten:

Anzahl der Mitarbeiter	Name des Dataflows	Adresse 1: Ort	Erstellt am
NULL	Zum Beispiel: „Konto”.	NULL	25.08.2023
1.500	Contoso Pharmaceuticals (Beispiel)	Stuttgart	25.03.2023
2.700	Fabrikam Inc. (Beispiel)	Lynnwood	25.03.2023
2.900	Blue Yonder Airlines (Beispiel)	Los Angeles	25.03.2023
2.900	City Power & Light (Beispiel)	Stuttgart	25.03.2023
3.900	Coho Winery (Beispiel)	Phoenix	25.03.2023
4.300	Adventure Works (Beispiel)	Santa Cruz	25.03.2023
4.800	Alpine Ski House (Beispiel)	Missoula	25.03.2023
6.000	Litware, Inc. (Beispiel)	Dallas	25.03.2023
6.200	A. Datum Corporation (Beispiel)	Stuttgart	25.03.2023

Die folgende Abfrage gibt aggregierte Daten für die Spalte numberofemployees zurück.

<fetch aggregate='true'>
  <entity name='account'>
    <attribute name='numberofemployees'
      alias='Average'
      aggregate='avg' />
    <attribute name='numberofemployees'
      alias='Count'
      aggregate='count' />
    <attribute name='numberofemployees'
      alias='ColumnCount'
      aggregate='countcolumn' />
    <attribute name='numberofemployees'
      alias='Maximum'
      aggregate='max' />
    <attribute name='numberofemployees'
      alias='Minimum'
      aggregate='min' />
    <attribute name='numberofemployees'
      alias='Sum'
      aggregate='sum' />
  </entity>
</fetch>

Die Ergebnisse sind eine einzelne Zeile:

 --------------------------------------------------------------
 | Average | Count | ColumnCount | Maximum | Minimum | Sum    |
 --------------------------------------------------------------
 | 3,911   | 10    | 9           | 6,200   | 1,500   | 35,200 |
 --------------------------------------------------------------

Bestimmte Spaltenwerte

Wenn Sie die Aggregatfunktion countcolumn verwenden, können Sie das Attribut distinct so festlegen, dass eine Anzahl eindeutiger Werte für die Spalte zurückgegeben wird.

<attribute name='numberofemployees' 
   alias='ColumnCount' 
   aggregate='countcolumn' 
   distinct='true' />

Bei der Festlegung für die vorherige Abfrage geben die Ergebnisse 8 statt 9 zurück, da zwei Zeilen im Dataset den Wert für die Anzahl der Mitarbeitenden 2.900 haben.

Gruppierung

Gruppieren Sie die Ergebnisse einer aggregierten Abfrage, indem Sie ein Attributelement mit dem Attribut groupby anstelle des Attributs aggregate hinzufügen. Beim Gruppieren sollten Sie ein Bestellelement mit einem alias-Wert angeben, der auf den alias der Gruppe festgelegt ist.

Die folgende Abfrage gibt beispielsweise die Summe der Mitarbeitenden und die Anzahl nach Stadt zurück:

<fetch aggregate='true'>
   <entity name='account'>
      <attribute name='numberofemployees'
         alias='Total'
         aggregate='sum' />
      <attribute name='address1_city'
         alias='Count'
         aggregate='count' />
      <attribute name='address1_city'
         alias='City'
         groupby='true' />
      <order alias='City' />
   </entity>
</fetch>

Die Abfrage gruppiert die Ergebnisse nach Stadtwert und kombiniert die Ergebnisse für die drei Zeilen, in denen die Stadt „Redmond“ ist.

Gesamt	Anzahl	Stadt
0	1	NULL
6.000	1	Dallas
2.900	1	Los Angeles
2.700	1	Lynnwood
4.800	1	Missoula
3.900	1	Phoenix
10.600	3	Stuttgart
4.300	1	Santa Cruz

Gruppieren nach Teilen eines Datums

Sie können auswählen, welcher Teil des Datums beim Gruppieren nach Datum verwendet werden soll. Legen Sie das Attribut Attributelement dategrouping auf einen der folgenden Werte fest:

Wert	Eigenschaft
`day`	Nach Monatstag gruppieren
`week`	Nach Jahreswoche gruppieren
`month`	Nach Jahresmonat gruppieren
`quarter`	Nach Quartal des Geschäftsjahres gruppieren
`year`	Nach Jahr gruppieren
`fiscal-period`	Nach Zeitraum des Geschäftsjahres gruppieren
`fiscal-year`	Nach Geschäftsjahr gruppieren

Weitere Informationen zu Geschäftsjahreseinstellungen

Standardmäßig verwenden Datumsgruppierungen die Zeitzone des Benutzers. Setzen Sie das Attributelement usertimezone Attribut auf "false" , um anzugeben, dass stattdessen die UTC-Zeitzone verwendet werden soll.

Die folgende Abfrage gruppiert Kontodatensätze, die die Anzahl der Mitarbeitenden zeigen, nach dem Zeitpunkt, an dem die Datensätze erstellt wurden:

<fetch aggregate='true'>
   <entity name='account'>
      <attribute name='numberofemployees'
         alias='Total'
         aggregate='sum' />
      <attribute name='createdon'
         alias='Day'
         groupby='true'
         dategrouping='day' />
      <attribute name='createdon'
         alias='Week'
         groupby='true'
         dategrouping='week' />
      <attribute name='createdon'
         alias='Month'
         groupby='true'
         dategrouping='month' />
      <attribute name='createdon'
         alias='Year'
         groupby='true'
         dategrouping='year' />
      <attribute name='createdon'
         alias='FiscalPeriod'
         groupby='true'
         dategrouping='fiscal-period' />
      <attribute name='createdon'
         alias='FiscalYear'
         groupby='true'
         dategrouping='fiscal-year' />
      <order alias='Month' />
   </entity>
</fetch>

Die folgende Tabelle zeigt das Ergebnis anhand des zuvor erwähnten Beispiel-Dataset:

 -----------------------------------------------------------------------
 | Total  | Day | Week | Month | Year  | FiscalPeriod     | FiscalYear |
 -----------------------------------------------------------------------
 | 35,200 | 25  | 12   | 3     | 2,023 | Quarter 1 FY2023 | FY2023     |
 -----------------------------------------------------------------------
 | 0      | 27  | 35   | 8     | 2,023 | Quarter 3 FY2023 | FY2023     |
 -----------------------------------------------------------------------

Beispiel für eine Buchhaltungsperioden-Datumsgruppierung

Das folgende Beispiel zeigt einen FetchXML-Aggregationsausdruck, der die Gesamtanzahl der erfüllten Aufträge summiert und das Ergebnis nach Geschäftshalbjahr und Geschäftsjahr gruppiert.

<fetch aggregate="true">
   <entity name="order">
      <attribute name="totalamount"
         aggregate="sum"
         alias="total" />
      <attribute name="datefulfilled"
         groupby="true"
         dategrouping="fiscal-period" />
   </entity>
</fetch>

Zeilenaggregat

Wenn für eine Tabelle eine hierarchische Beziehung definiert ist, können Sie ein Zeilenaggregat in der Nachschlagespalte für die hierarchische Beziehung zurückgeben.

Das folgende Beispiel gibt die Anzahl der zugehörigen Konten in einer Spalte mit dem Namen CountChildren zurück, wenn die Datensatzspalte des untergeordneten Kontos parentaccountid der Spalte des aktuellen Kontos accountid entspricht.

<fetch top='5'>
   <entity name='account'>
      <attribute name='name' />
      <attribute name='accountid'
         alias='numberOfChildren'
         rowaggregate='CountChildren' />
      <order attribute='accountid'
         descending='true' />
   </entity>
</fetch>

Einschränkungen

Abfragen, doe aggregierte Werte zurückgeben, sind auf 50.000 Datensätze beschränkt. Diese Beschränkung hilft dabei, die Systemleistung und Zuverlässigkeit zu erhalten. Wenn die Filterkriterien in Ihrer Abfrage mehr als 50.000 Datensätze enthalten, wird die folgende Fehlermeldung angezeigt:

Nummer: -2147164125
Code: 8004E023
Meldung: AggregateQueryRecordLimit exceeded. Cannot perform this operation.
Client-Fehlermeldung: Die maximale Datensatzgrenze wird überschritten. Reduzieren Sie die Anzahl der Datensätze.

Um diesen Fehler zu vermeiden, fügen Sie entsprechende Filter zu Ihrer Abfrage hinzu, um sicherzustellen, dass nicht mehr als 50.000 Datensätzen ausgewertet werden. Führen Sie Ihre Abfrage dann mehrmals aus und kombinieren Sie die Ergebnisse. Geeignete Filter hängen von der Art Ihrer Daten ab, es kann sich jedoch auch um einen Datumsbereich oder eine Teilmenge von Werten in einer Auswahlspalte handeln.

Limit pro Abfrage

Selbst wenn der Standardgrenzwert für aggregierte Abfragen angewendet wird, kann es einige Zeit dauern, bis die Abfrage abgeschlossen ist. Sie können das Attribut aggregatelimit in einer Abfrage verwenden, um ein benutzerdefiniertes unteres Limit anzuwenden, das den Fehler AggregateQueryRecordLimit exceeded zurückgibt, wenn die Ergebnisse höher als Ihr benutzerdefiniertes Limit sind.

In diesem Beispiel beträgt die benutzerdefinierte maximale Zeilenbeschränkung 10:

<fetch aggregate='true'
   aggregatelimit = '10'>
   <entity name='opportunity'>
      <attribute name='name'
         alias='opportunity_count'
         aggregate='count' />
   </entity>
</fetch>

Das Limit pro Abfrage darf das standardmäßige Aggregatlimit nicht überschreiten.

Nächste Schritte,

Erfahren Sie, wie Sie Zeilen zählen.

Zeilen zählen

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

Freigeben über