Agréger les données à l’aide de QueryExpression
QueryExpression inclut les fonctionnalités de regroupement et d’agrégation qui vous permettent de calculer une somme, une moyenne, un nombre minimal et maximal entre différentes lignes de données.
Pour renvoyer une valeur d’agrégation, vous devez :
Laissez la propriété ColumnSet.AllColumns définie sur
false. Ne le configurez pas à l’aide du Constructeur ColumnSet (booléen).Ajouter des instances de Classe XrmAttributeExpression au ColumnSet.AttributeExpressions collection
Pour chaque colonne que vous souhaitez renvoyer, définissez ces propriétés :
Propriété XrmAttributeExpression Description AttributeName Le LogicalNamede la colonneAlias La valeur de la colonne Pour chaque colonne que vous souhaitez agréger, définissez le Type d’agrégat au type d’agrégation que vous souhaitez effectuer. Découvrez les types de agrégation
Pour chaque colonne que vous souhaitez regrouper les résultats, définissez ces propriétés :
Propriété XrmAttributeExpression Description AggregateType Défini sur XrmAggregateType .NoneHasGroupBy Définir sur true.DateTimeGrouping Lorsque le regroupement implique des valeurs DateHeure, spécifiez le type de regroupement DateHeure à appliquer à l’aide de l’option enum XrmDateTimeGrouping membres. En savoir plus sur le regroupement en fonction des parties d’une date
Types d’agrégations
Les types d’agrégation que vous pouvez effectuer sont membres de l’enum XrmAggregateType.
| Membre XrmAggregateType | Description |
|---|---|
Avg |
La valeur moyenne des valeurs de la colonne avec des données. |
Count |
Le nombre de lignes. |
CountColumn |
Le nombre de lignes avec des données dans cette colonne. |
Max |
La valeur maximale des lignes dans cette colonne. |
Min |
La valeur minimale des lignes dans cette colonne. |
None |
Utilisez-le lorsque la colonne est utilisée pour regrouper les données agrégées. La valeur HasGroupBy doit être définie sur true. |
Sum |
La valeur totale des valeurs de la colonne avec des données. |
Notez les points suivants :
- Les valeurs nulles ne sont pas prises en compte lors du calcul des valeurs d’agrégation.
- Vous pouvez utiliser les données des tables jointes à l’aide de la classe LinkEntity.
- Vous pouvez appliquer des filtres pour limiter les résultats comme pour toute requête.
Exemple
Supposons que vous disposiez de 10 enregistrements de compte avec les données suivantes :
| Nombre d’employés | Nom | Adresse 1 Ville | Date de création |
|---|---|---|---|
| NULL | Exemple de compte | NULL | 25/08/2023 |
| 1 500 | Contoso Pharmaceuticals (exemple) | Colombes | 25/03/2023 |
| 2 700 | Fabrikam, Inc. (exemple) | Lynnwood | 25/03/2023 |
| 2 900 | Blue Yonder Airlines (exemple) | Los Angeles | 25/03/2023 |
| 2 900 | City Power & Light (exemple) | Colombes | 25/03/2023 |
| 3 900 | Coho Winery (exemple) | Phoenix | 25/03/2023 |
| 4 300 | Adventure Works (exemple) | Santa Cruz | 25/03/2023 |
| 4 800 | Alpine Ski House (exemple) | Missoula | 25/03/2023 |
| 6 000 | Litware, Inc. (exemple) | Dallas | 25/03/2023 |
| 6 200 | A. Datum Corporation (exemple) | Colombes | 25/03/2023 |
La requête suivante renvoie des données d’agrégation pour la colonne numberofemployees.
QueryExpression query = new()
{
EntityName = "account",
ColumnSet = new ColumnSet(false)
{
AttributeExpressions = {
{
new XrmAttributeExpression(
attributeName: "numberofemployees",
alias: "Average",
aggregateType: XrmAggregateType.Avg)
},
{
new XrmAttributeExpression(
attributeName: "numberofemployees",
alias: "Count",
aggregateType: XrmAggregateType.Count)
},
{
new XrmAttributeExpression(
attributeName: "numberofemployees",
alias: "ColumnCount",
aggregateType: XrmAggregateType.CountColumn)
},
{
new XrmAttributeExpression(
attributeName: "numberofemployees",
alias: "Maximum",
aggregateType: XrmAggregateType.Max)
},
{
new XrmAttributeExpression(
attributeName: "numberofemployees",
alias: "Minimum",
aggregateType: XrmAggregateType.Min)
},
{
new XrmAttributeExpression(
attributeName: "numberofemployees",
alias: "Sum",
aggregateType: XrmAggregateType.Sum)
}
}
}
};
Les résultats sont une seule ligne :
--------------------------------------------------------------
| Average | Count | ColumnCount | Maximum | Minimum | Sum |
--------------------------------------------------------------
| 3,911 | 10 | 9 | 6,200 | 1,500 | 35,200 |
--------------------------------------------------------------
Regroupement
Regroupez les résultats d’une requête agrégée en ajoutant un XrmAttributeExpression avec la propriété HasGroupBy AggregateType défini sur XrmAggregateType.None.
Lors du regroupement, vous devez spécifier un QueryExpression.Orders avec un OrderExpression qui a le Propriété Alias définie sur l’alias du groupe.
Par exemple, la requête suivante renvoie la somme des employés et le nombre par ville :
QueryExpression query = new()
{
EntityName = "account",
ColumnSet = new ColumnSet(false)
{
AttributeExpressions = {
{
new XrmAttributeExpression(
attributeName: "numberofemployees",
alias: "Total",
aggregateType: XrmAggregateType.Sum)
},
{
new XrmAttributeExpression(
attributeName: "address1_city",
alias: "Count",
aggregateType: XrmAggregateType.Count)
},
{
new XrmAttributeExpression(
attributeName: "address1_city",
alias: "City",
aggregateType: XrmAggregateType.None){
HasGroupBy = true
}
}
}
}
};
query.Orders.Add(new OrderExpression(
attributeName: "address1_city",
alias: "City",
orderType: OrderType.Ascending));
La requête regroupe les résultats par City valeur, en combinant les résultats des trois lignes où la ville est "Redmond".
| Total | Nombre | Ville |
|---|---|---|
| 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 | Colombes |
| 4 300 | 1 | Santa Cruz |
Regroupement par parties d’une date
Vous pouvez sélectionner la partie de la date à utiliser lors du regroupement par date. Définissez XrmAttributeExpression.DateTimeGrouping sur l’un des enum XrmDateTimeGrouping membres.
| Membre XrmDateTimeGrouping | Description |
|---|---|
None |
Aucun regroupement DateHeure |
Day |
Regrouper par jour |
Week |
Regrouper par semaine |
Month |
Regrouper par mois |
Quarter |
Regrouper par trimestre |
Year |
Regrouper par année |
FiscalPeriod |
Regrouper par FiscalPeriod |
FiscalYear |
Regrouper par FiscalYear |
La requête suivante regroupe les enregistrements de compte indiquant le nombre d’employés selon la date de création des enregistrements :
QueryExpression query = new()
{
EntityName = "account",
ColumnSet = new ColumnSet(false)
{
AttributeExpressions = {
{
new XrmAttributeExpression(
attributeName: "numberofemployees",
alias: "Total",
aggregateType: XrmAggregateType.Sum)
},
{
new XrmAttributeExpression(
attributeName: "createdon",
alias: "Day",
aggregateType: XrmAggregateType.None){
HasGroupBy = true,
DateTimeGrouping = XrmDateTimeGrouping.Day
}
},
{
new XrmAttributeExpression(
attributeName: "createdon",
alias: "Week",
aggregateType: XrmAggregateType.None){
HasGroupBy = true,
DateTimeGrouping = XrmDateTimeGrouping.Week
}
},
{
new XrmAttributeExpression(
attributeName: "createdon",
alias: "Month",
aggregateType: XrmAggregateType.None){
HasGroupBy = true,
DateTimeGrouping = XrmDateTimeGrouping.Month
}
},
{
new XrmAttributeExpression(
attributeName: "createdon",
alias: "Year",
aggregateType: XrmAggregateType.None){
HasGroupBy = true,
DateTimeGrouping = XrmDateTimeGrouping.Year
}
},
{
new XrmAttributeExpression(
attributeName: "createdon",
alias: "FiscalPeriod",
aggregateType: XrmAggregateType.None){
HasGroupBy = true,
DateTimeGrouping = XrmDateTimeGrouping.FiscalPeriod
}
},
{
new XrmAttributeExpression(
attributeName: "createdon",
alias: "FiscalYear",
aggregateType: XrmAggregateType.None){
HasGroupBy = true,
DateTimeGrouping = XrmDateTimeGrouping.FiscalYear
}
}
}
}
};
query.Orders.Add(new OrderExpression(
attributeName: "createdon",
alias: "Month",
orderType: OrderType.Ascending));
Le tableau suivant montre le résultat en utilisant l’exemple de jeu de données mentionné précédemment :
-----------------------------------------------------------------------
| 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 |
-----------------------------------------------------------------------
Exemple de regroupement de dates par période fiscale
L’exemple suivant montre une QueryExpression qui totalise le nombre des commandes exécutées et classe le résultat par semestre fiscal et exercice.
QueryExpression query = new()
{
EntityName = "salesorder",
ColumnSet = new ColumnSet(false)
{
AttributeExpressions = {
{
new XrmAttributeExpression(
attributeName: "totalamount",
alias: "total",
aggregateType: XrmAggregateType.Sum)
},
{
new XrmAttributeExpression(
attributeName: "datefulfilled",
alias: "date",
aggregateType: XrmAggregateType.None){
HasGroupBy = true,
DateTimeGrouping = XrmDateTimeGrouping.FiscalPeriod
}
}
}
}
};
query.Orders.Add(new OrderExpression(
attributeName: "datefulfilled",
alias: "Date",
orderType: OrderType.Ascending));
Limites de l’agrégation QueryExpression
Cette section décrit les fonctionnalités disponibles à l’aide de l’agrégation avec FetchXml qui ne sont actuellement pas disponibles à l’aide de QueryExpression.
Obtenez un numéro distinct avec CountColumn
Vous ne pouvez pas obtenir un nombre distinct de valeurs en utilisant CountColumn avec QueryExpression. Découvrez les valeurs de colonnes distinctes à l’aide de FetchXml
Fuseau horaire lors du regroupement par date
Le regroupement par parties d’une date utilise toujours l’heure UTC et il n’existe aucun moyen de spécifier que le fuseau horaire de l’utilisateur doit être utilisé à la place disponible dans FetchXml
Agrégation de lignes
Lorsqu’une table a une relation hiérarchique définie, vous ne pouvez pas renvoyer un agrégat de lignes dans la colonne de recherche pour la relation hiérarchique. En savoir plus sur les agrégats de lignes à l’aide de FetchXml
Limite par requête
Il n’existe aucun moyen de spécifier une limite globale configurable. En savoir plus sur les limites par requête à l’aide de FetchXml
Limitations
Les requêtes qui renvoient des valeurs agrégées sont limitées à 50 000 enregistrements. Cette limite aide à gérer les performances et la fiabilité du système. Si les critères de filtre de votre requête renvoient plus de 50 000 enregistrements, vous obtenez le message d’erreur suivant :
Nombre :
-2147164125
Code :8004E023
Message :AggregateQueryRecordLimit exceeded. Cannot perform this operation.
Message d’erreur client : La limite d’enregistrement maximale est dépassée. Réduisez le nombre d’enregistrements.
Pour éviter cette erreur, ajoutez des filtres appropriés à votre requête pour garantir qu’elle n’évalue pas plus de 50 000 enregistrements. Ensuite, exécutez votre requête plusieurs fois et combinez les résultats. Les filtres appropriés dépendent de la nature de vos données, mais il peut s’agir d’une plage de dates ou d’un sous-ensemble de valeurs dans une colonne de choix.
Étapes suivantes
Découvrez comment compter des lignes.
Notes
Pouvez-vous nous indiquer vos préférences de langue pour la documentation ? Répondez à un court questionnaire. (veuillez noter que ce questionnaire est en anglais)
Le questionnaire vous prendra environ sept minutes. Aucune donnée personnelle n’est collectée (déclaration de confidentialité).