Selecionar colunas usando FetchXml

Conforme descrito nos dados de consulta usando FetchXml, inicie sua consulta selecionando uma tabela usando o elemento de entidade.

Use o elemento de atributo para selecionar as colunas a serem retornadas com sua consulta. Por exemplo:

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

Essa consulta retorna as colunas AccountClassificationCode, CreatedBy, CreatedOn e Name das primeiras 5.000 linhas da tabela Account. Se você precisar de mais linhas do que isso ou quiser iterar por meio de conjuntos menores de dados, saiba como páginar resultados usando FetchXml.

Para cada atributo que você deseja retornar, adicione um elemento de atributo e defina o valor do atributo name para o LogicalName da coluna.

Use o attribute element para selecionar as colunas da entidade da sua consulta e de todas as tabelas associadas usando o link-entity element. Saiba como unir tabelas usando FetchXml.

Importante

Desencorajamos fortemente o retorno de todas as colunas em uma tabela. O retorno de todas as colunas fará com que seus aplicativos sejam executados mais lentamente e poderá causar erros de tempo limite. Você deve especificar o número mínimo de colunas a serem recuperadas com seus dados. Se você não especificar colunas ou usar o elemento all-attributes, os dados de todas as colunas serão retornados.

Valores formatados

Os dados digitado retornados podem não ser adequados para exibição em seu aplicativo. Valores formatados são valores de cadeia de caracteres retornados com a solicitação que você pode exibir em seu aplicativo.

Vamos examinar os resultados sem usar os valores formatados primeiro. Essas funções usam o pacote NuGet ConsoleTables para mostrar a tabela em um aplicativo de console.

Esse SimpleOutput método acessa apenas valores na coleção 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();
}

Saída:

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

Esses valores podem não ser os valores de fácil compreensão que você precisa exibir em um aplicativo.

  • accountclassificationcode A coluna de escolha retorna o valor inteiro.
  • A referência do SDK para createdby deve usar a propriedade EntityReference.Name
  • A Web API retorna a _createdby_valuepropriedade Lookup que tem o valor GUID da createdby coluna de pesquisa.

Para obter os valores amigáveis desejados, você precisa acessar valores formatados que podem ser retornados pelo Dataverse.

A forma como você obtém esses valores depende se você usa o SDK para .NET ou API Web.

O OutputFetchRequest método de exemplo descrito no código de exemplo FetchXml usa dados da coleção Entity.FormattedValues, de modo que os resultados da consulta fiquem assim:

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

Esse GetRowValues método extrai uma lista de valores de cadeia de caracteres de um registro em Entity.FormattedValues quando eles estão disponíveis.

/// <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;
}

Saiba mais sobre valores formatados:

Apelidos de coluna

Os aliases de coluna normalmente são usados para operações de agregação, mas também funcionam para operações de seleção simples, para que possamos apresentá-los aqui.

Use o atributo attributealias para especificar um nome de coluna exclusivo para os resultados retornados.

Cada coluna retornada deve ter um nome exclusivo. Por padrão, os nomes de coluna retornados para a tabela da consulta são os valores da coluna LogicalName. Todos os nomes lógicos de coluna são exclusivos para cada tabela, portanto, não pode haver nomes duplicados dentro desse conjunto.

Quando você usa um elemento link-entity para unir tabelas, os nomes de coluna padrão seguem esta convenção de nomenclatura: {Linked table LogicalName}.{Column LogicalName}. Isso impede qualquer nome de coluna duplicado. Você pode sobrescrever isso usando um alias exclusivo. Você também pode definir um alias valor para a tabela link-entity que representa a junção.

O comportamento que você vê ao usar aliases de coluna depende se você está usando o SDK para .NET ou API Web.

Esse SimpleAliasOutput método usa aliases em vez dos nomes lógicos das colunas. Por isso, os resultados são retornados como AliasedValue. Para acessar o valor de tipos complexos como OptionSetValue ou EntityReference, você precisa converter o valor.

Esse método usa o pacote 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();
}

Saída:

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

A classe AliasedValue tem duas propriedades que informam o EntityLogicalName original e AttributeLogicalName se você precisar delas.

Próximas Etapas 

Saiba como unir tabelas.

Unir tabelas

  • Última atualização em