Partager via

Sélectionner des colonnes à l’aide de FetchXml

Comme décrit dans Les données de requête à l’aide de FetchXml, démarrez votre requête en sélectionnant une table à l’aide de l’élément d’entité.

Utilisez l’élément d’attribut pour sélectionner les colonnes à retourner avec votre requête. Par exemple:

<fetch>
  <entity name='account'>
    <attribute name='accountclassificationcode' />
    <attribute name='createdby' />
    <attribute name='createdon' />
    <attribute name='name' />
  </entity>
</fetch>

Cette requête retourne les colonnes AccountClassificationCode, CreatedBy, CreatedOn et Name des 5 000 premières lignes de la table Account. Si vous avez besoin de plus de lignes que cela, ou que vous souhaitez itérer dans des jeux de données plus petits, découvrez comment pager les résultats à l’aide de FetchXml.

Pour chaque attribut que vous souhaitez renvoyer, ajoutez un élément d’attribut et définissez la valeur de l’attribut name sur la LogicalName colonne.

Utilisez l’élément d’attribut pour sélectionner les colonnes de l’entité de votre requête et toutes les tables jointes à l’aide de l’élément link-entity. Découvrez comment joindre des tables à l’aide de FetchXml.

Important

Nous déconseillons fortement de renvoyer toutes les colonnes d’une table. Le renvoi de toutes les colonnes ralentira l’exécution de vos applications et peut provoquer des erreurs de délai d’attente. Vous devez spécifier le nombre minimal de colonnes à récupérer avec vos données. Si vous ne spécifiez pas de colonnes ou si vous utilisez l’élément all-attributes, les données de toutes les colonnes sont retournées.

Valeurs mises en forme

Les données typées retournées peuvent ne pas convenir à l’affichage dans votre application. Les valeurs mises en forme sont des valeurs de chaîne retournées avec la demande que vous pouvez afficher dans votre application.

Examinons d’abord les résultats sans utiliser de valeurs mises en forme. Ces fonctions utilisent le package NuGet ConsoleTables pour afficher la table dans une application console.

Cette SimpleOutput méthode accède uniquement aux valeurs de la collection Entity.Attributes.

/// <summary>
/// Output the entity attribute values
/// </summary>
/// <param name="service">The authenticated IOrganizationService instance</param>
static void SimpleOutput(IOrganizationService service) {

    string fetchXml = @"<fetch>
            <entity name='account'>
                <attribute name='accountclassificationcode' />
                <attribute name='createdby' />
                <attribute name='createdon' />
                <attribute name='name' />
            </entity>
            </fetch>";

    FetchExpression fetchExpression = new(fetchXml);

    //Retrieve the data
    EntityCollection entityCollection = service.RetrieveMultiple(query: fetchExpression);

    var table = new ConsoleTables.ConsoleTable("classificationcode", "createdby", "createdon", "name");

    foreach (var entity in entityCollection.Entities ) {

        var accountclassificationcode = entity.GetAttributeValue<OptionSetValue>("accountclassificationcode").Value;
        var createdby = entity.GetAttributeValue<EntityReference>("createdby").Name;
        var createdon = entity.GetAttributeValue<DateTime>("createdon");
        var name = entity.GetAttributeValue<string>("name");

        table.AddRow(accountclassificationcode, createdby, createdon, name);

    }
    table.Write();
}

Sortie:

 ----------------------------------------------------------------------------------------------
 | classificationcode | createdby           | createdon             | name                    |
 ----------------------------------------------------------------------------------------------
 | 1                  | FirstName LastName  | 8/13/2023 10:30:08 PM | Fourth Coffee (sample)  |
 ----------------------------------------------------------------------------------------------
 | 1                  | FirstName LastName  | 8/13/2023 10:30:10 PM | Litware, Inc. (sample)  |
 ----------------------------------------------------------------------------------------------
 | 1                  | FirstName LastName  | 8/13/2023 10:30:10 PM | Adventure Works (sample)|
 ----------------------------------------------------------------------------------------------

Ces valeurs peuvent ne pas être les valeurs conviviales que vous devez afficher dans une application.

  • La accountclassificationcode colonne de choix retourne la valeur entière.
  • La référence du kit de développement logiciel (SDK) à createdby doit utiliser la propriété EntityReference.Name
  • L’API Web renvoie la _createdby_valuepropriété de recherche qui possède la valeur GUID pour la colonne de recherchecreatedby.

Pour obtenir les valeurs conviviales souhaitées, vous devez accéder aux valeurs mises en forme qui peuvent être retournées par Dataverse.

La façon dont vous obtenez ces valeurs varie selon que vous utilisez le Kit de développement logiciel (SDK) pour .NET ou l’API web.

L’exemple OutputFetchRequest de méthode décrit dans FetchXml Sample code utilise des données de la collection Entity.FormattedValues , de sorte que les résultats de la requête ressemblent à ceci :

 --------------------------------------------------------------------------------------------------
 | accountclassificationcode | createdby           | createdon          | name                    |
 --------------------------------------------------------------------------------------------------
 | Default Value             | FirstName LastName  | 8/13/2023 10:30 PM | Fourth Coffee (sample)  |
 --------------------------------------------------------------------------------------------------
 | Default Value             | FirstName LastName  | 8/13/2023 10:30 PM | Litware, Inc. (sample)  |
 --------------------------------------------------------------------------------------------------
 | Default Value             | FirstName LastName  | 8/13/2023 10:30 PM | Adventure Works (sample)|
 --------------------------------------------------------------------------------------------------

Cette GetRowValues méthode extrait une liste de valeurs de chaîne pour un enregistrement à partir de Entity.FormattedValues lorsqu’elles sont disponibles.

/// <summary>
/// Returns the values of a row as strings
/// </summary>
/// <param name="columns">The names of the columns</param>
/// <param name="entity">The entity with the data</param>
/// <returns></returns>
static List<string> GetRowValues(List<string> columns, Entity entity)
{
   List<string> values = new();
   columns.ForEach(column =>
   {
      if (entity.Attributes.ContainsKey(column))
      {
            // Use the formatted value if it available
            if (entity.FormattedValues.ContainsKey(column) &&
            !string.IsNullOrWhiteSpace(entity.FormattedValues[column]))
            {
               values.Add($"{entity.FormattedValues[column]}");
            }
            else
            {
               // When an alias is used, the Aliased value must be converted
               if (entity.Attributes[column] is AliasedValue aliasedValue)
               {
                  // When an EntityReference doesn't have a Name, show the Id
                  if (aliasedValue.Value is EntityReference lookup &&
                  string.IsNullOrWhiteSpace(lookup.Name))
                  {
                        values.Add($"{lookup.Id:B}");
                  }
                  else
                  {
                        values.Add($"{aliasedValue.Value}");
                  }
               }
               else
               {
                  // Use the simple attribute value
                  values.Add($"{entity.Attributes[column]}");
               }
            }
      }
      // Null values are not in the Attributes collection
      else
      {
            values.Add("NULL");
      }

   });
   return values;
}

En savoir plus sur les valeurs mises en forme :

Alias de colonne

Les alias de colonne sont généralement utilisés pour les opérations d’agrégation, mais ils fonctionnent également pour des opérations de sélection simples. Nous pouvons donc les présenter ici.

Utilisez l’attribut alias pour spécifier un nom de colonne unique pour les résultats retournés.

Chaque colonne retournée doit avoir un nom unique. Par défaut, les noms de colonnes retournés pour la table de votre requête sont les valeurs de colonne LogicalName . Tous les noms logiques des colonnes sont uniques au sein de chaque table, ce qui empêche toute duplication de noms dans cet ensemble.

Lorsque vous utilisez un élément d’entité de liaison pour joindre des tables, les noms de colonnes par défaut suivent cette convention d’affectation de noms : {Linked table LogicalName}.{Column LogicalName}. Cela empêche tout nom de colonne en double. Vous pouvez le remplacer à l’aide d’un alias unique. Vous pouvez également définir une valeur alias pour link-entity représentant la table jointe.

Le comportement que vous voyez lors de l’utilisation d’alias de colonne dépend de l’utilisation du Kit de développement logiciel (SDK) pour .NET ou l’API web.

Cette SimpleAliasOutput méthode utilise des alias plutôt que les noms logiques des colonnes. En raison de cela, les résultats sont retournés en tant que AliasedValue. Pour accéder à la valeur des types complexes tels que OptionSetValue ou EntityReference, vous devez convertir la valeur.

Cette méthode utilise le package NuGet ConsoleTables .

/// <summary>
/// Output the entity attribute values with aliases
/// </summary>
/// <param name="service">The authenticated IOrganizaitonService instance</param>
static void SimpleAliasOutput(IOrganizationService service)
{
    string fetchXml = @"<fetch top='3'>
            <entity name='account'>
              <attribute name='accountclassificationcode' alias='code' />
              <attribute name='createdby' alias='whocreated' />
              <attribute name='createdon' alias='whencreated' />
              <attribute name='name' alias='companyname' />
            </entity>
          </fetch>";

    FetchExpression fetchExpression = new(fetchXml);

    //Retrieve the data
    EntityCollection entityCollection = service.RetrieveMultiple(query: fetchExpression);

    var table = new ConsoleTables.ConsoleTable("code", "whocreated", "whencreated", "companyname");

    foreach (var entity in entityCollection.Entities)
    {

        var code = ((OptionSetValue)entity.GetAttributeValue<AliasedValue>("code").Value).Value;
        var whocreated = ((EntityReference)entity.GetAttributeValue<AliasedValue>("whocreated").Value).Name;
        var whencreated = entity.GetAttributeValue<AliasedValue>("whencreated").Value;
        var companyname = entity.GetAttributeValue<AliasedValue>("companyname").Value;

        table.AddRow(code, whocreated, createdon, companyname);

    }
    table.Write();
}

Sortie:

 ----------------------------------------------------------------------------------
 | code | whocreated           | whencreated           | companyname              |
 ----------------------------------------------------------------------------------
 | 1    | FirstName LastName   | 8/13/2023 10:30:08 PM | Fourth Coffee (sample)   |
 ----------------------------------------------------------------------------------
 | 1    | FirstName LastName   | 8/13/2023 10:30:10 PM | Litware, Inc. (sample)   |
 ----------------------------------------------------------------------------------
 | 1    | FirstName LastName   | 8/13/2023 10:30:10 PM | Adventure Works (sample) |
 ----------------------------------------------------------------------------------

Note

La classe AliasedValue a deux propriétés qui vous indiquent l’EntityLogicalName d’origine et AttributeLogicalName si vous en avez besoin.

Étapes suivantes

Découvrez comment associer des tables de données.

Joindre des tables

  • Last updated on