Compartir por

Selección de columnas mediante FetchXml

Como se describe en Consulta de datos mediante FetchXml, inicie la consulta seleccionando una tabla mediante el elemento entity.

Use el elemento de atributo para seleccionar las columnas que se van a devolver con la consulta. Por ejemplo:

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

Esta consulta devuelve las columnas AccountClassificationCode, CreatedBy, CreatedOn y Name de las primeras 5000 filas de la tabla Account. Si necesita más filas que esta o desea recorrer en iteración conjuntos de datos más pequeños, aprenda a paginar los resultados mediante FetchXml.

Para cada atributo que desee devolver, agregue un elemento de atributo y establezca el valor del name atributo al LogicalName de la columna.

Use el elemento de atributo para seleccionar las columnas de la entidad de la consulta y las tablas unidas mediante el elemento link-entity. Obtenga más información acerca de cómo combinar tablas mediante FetchXml.

Importante

Recomendamos encarecidamente devolver todas las columnas de una tabla. Devolver todas las columnas hará que sus aplicaciones se ejecuten más lentamente y puede provocar errores de tiempo de espera. Debe especificar el número mínimo de columnas que se van a recuperar junto con sus datos. Si no especifica columnas o usa el elemento all-attributes, se devuelven los datos de todas las columnas.

Valores con formato

Es posible que los datos tipados devueltos no sean adecuados para mostrarlos en su aplicación. Los valores con formato son valores de cadena devueltos con la solicitud que puede mostrar en su aplicación.

Echemos un vistazo primero a los resultados sin usar valores con formato. Estas funciones usan el paquete NuGet ConsoleTables para mostrar la tabla en una aplicación de consola.

Este SimpleOutput método solo tiene acceso a los valores de la colección 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();
}

Salida:

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

Es posible que estos valores no sean los valores fáciles de usar que necesita mostrar en una aplicación.

  • La accountclassificationcode columna de elección devuelve el valor entero.
  • La referencia del SDK a createdby debe usar la propiedad EntityReference.Name
  • La API web devuelve la _createdby_valuepropiedad de búsqueda que tiene el valor GUID para la columna de búsqueda createdby.

Para obtener los valores fáciles de usar que desea, debe tener acceso a los valores con formato que Dataverse puede devolver.

La forma de obtener estos valores depende de si usa el SDK para .NET o la API web.

El OutputFetchRequest método de ejemplo descrito en Código de ejemplo FetchXml usa datos de la colección Entity.FormattedValues , por lo que los resultados de la consulta tienen este aspecto:

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

Este GetRowValues método extrae una lista de valores de cadena para un registro de Entity.FormattedValues cuando están 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;
}

Obtenga más información sobre los valores con formato:

Alias de columna

Los alias de columna se suelen usar para las operaciones de agregado, pero también funcionan para operaciones de selección sencillas, por lo que podemos presentarlos aquí.

Use el atributoalias attribute para especificar un nombre de columna único para los resultados devueltos.

Cada columna devuelta debe tener un nombre único. De forma predeterminada, los nombres de columna devueltos para la tabla de la consulta son los valores de columna LogicalName . Todos los nombres lógicos de columna son únicos para cada tabla, por lo que no puede haber nombres duplicados dentro de ese conjunto.

Cuando se usa un elemento link-entity para combinar tablas, los nombres de columna predeterminados siguen esta convención de nomenclatura: {Linked table LogicalName}.{Column LogicalName}. Esto impide cualquier nombre de columna duplicado. Puede invalidar esto mediante un alias único. También puede establecer un alias valor para la link-entity que representa la tabla combinada.

El comportamiento que observa al utilizar alias de columnas depende de si emplea el SDK para .NET o la API web.

Este SimpleAliasOutput método usa alias en lugar de los nombres lógicos de las columnas. Debido a esto, los resultados se devuelven como AliasedValue. Para tener acceso al valor de tipos complejos como OptionSetValue o EntityReference, debe convertir el valor.

Este método usa el paquete 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();
}

Salida:

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

Nota:

La clase AliasedValue tiene dos propiedades que le indican el EntityLogicalName original y AttributeLogicalName si los necesita.

Pasos siguientes

Obtenga información sobre cómo combinar tablas.

Unir tablas

  • Last updated on