Combinación de tablas mediante FetchXml

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

Utilice el elemento link-entity para describir los datos de las tablas relacionadas para que estos se devuelvan con tu consulta con los siguientes atributos:

Por ejemplo, la consulta siguiente devuelve hasta 5 registros de la cuenta y las tablas de contacto basadas en la columna de búsqueda PrimaryContactId del registro de cuenta:

<fetch top='5'>
   <entity name='account'>
      <attribute name='name' />
      <link-entity name='contact'
         from='contactid'
         to='primarycontactid'
         link-type='inner'
         alias='contact'>
         <attribute name='fullname' />
      </link-entity>
   </entity>
</fetch>

Los resultados tienen este aspecto:

 -----------------------------------------------------------------
 | name                             | contact.fullname           |
 -----------------------------------------------------------------
 | Litware, Inc. (sample)           | Susanna Stubberod (sample) |
 -----------------------------------------------------------------
 | Adventure Works (sample)         | Nancy Anderson (sample)    |
 -----------------------------------------------------------------
 | Fabrikam, Inc. (sample)          | Maria Campbell (sample)    |
 -----------------------------------------------------------------
 | Blue Yonder Airlines (sample)    | Sidney Higa (sample)       |
 -----------------------------------------------------------------
 | City Power & Light (sample)      | Scott Konersmann (sample)  |
 -----------------------------------------------------------------

Limitaciones

Puede agregar hasta 15 link-entity elementos a una consulta. Cada entidad de vínculo agrega una JOIN a la consulta y aumenta el tiempo para ejecutar la consulta. Este límite es proteger el rendimiento. Si agrega más de 15 elementos de entidad de vínculo a una consulta, obtendrá este error:

Código: 0x8004430D
Número: -2147204339
Mensaje: Number of link entities in query exceeded maximum limit.

Elementos secundarios

Dentro del elemento link-entity se pueden agregar elementos secundarios al igual que en el elemento padre.

• Selección de columnas de la tabla relacionada
• Filtrar filas de la tabla relacionada
• Combinar otra tabla relacionada

Relaciones de muchos a uno

El ejemplo anterior es una relación de varios a uno, donde muchos registros de cuenta pueden hacer referencia a un registro de contacto único. Esta información se define en la relación de muchos a uno Relación de cuenta account_primary_contact, que tiene los siguientes valores:

Recuperar información de relación

Si usa XrmToolBoxFetchXML Builder, puede ver cómo esta herramienta le permite seleccionar la relación para establecer los valores de atributo , namey from adecuadosto.

También puede usar otras herramientas y APIs para buscar datos de relación para los valores de atributo adecuados de name, from, y to a utilizar. Obtenga información sobre cómo recuperar estos datos:

• Examinar definiciones de tabla en tu entorno
• Definiciones de esquema de consulta

Relaciones de uno a varios

Las relaciones de muchos a uno y de uno a muchos son como ver las dos caras de una moneda. La relación existe entre las tablas, por lo que la forma en que se usa depende de la tabla base de la consulta.

Puede recuperar los mismos datos que en el ejemplo anterior de la tabla de contactos usando la misma relación, excepto desde el costado de la tabla de contactos. Utilice los datos de la misma relación de cuenta account_primary_contact one-to-many, pero ajuste los valores para la vista diferente de la relación.

<fetch top='5'>
   <entity name='contact'>
      <attribute name='fullname' />
      <link-entity name='account'
         from='primarycontactid'
         to='contactid'
         alias='account'>
         <attribute name='name' />
      </link-entity>
   </entity>
</fetch>

En la tabla siguiente se muestran los valores de atributo link-entity en este ejemplo:

Los resultados incluyen los mismos registros y datos que la consulta anterior mediante la relación de varios a uno, salvo que la "entidad padre" ahora es contact en lugar de account.

 -----------------------------------------------------------------
 | fullname                   | account.name                     |
 -----------------------------------------------------------------
 | Susanna Stubberod (sample) | Litware, Inc. (sample)           |
 -----------------------------------------------------------------
 | Nancy Anderson (sample)    | Adventure Works (sample)         |
 -----------------------------------------------------------------
 | Maria Campbell (sample)    | Fabrikam, Inc. (sample)          |
 -----------------------------------------------------------------
 | Sidney Higa (sample)       | Blue Yonder Airlines (sample)    |
 -----------------------------------------------------------------
 | Scott Konersmann (sample)  | City Power & Light (sample)      |
 -----------------------------------------------------------------

Relaciones de varios a varios

Las relaciones de muchos a muchos dependen de una tabla de intersección. Normalmente, una tabla de intersección tiene solo cuatro columnas, pero solo dos de ellas son importantes. Las dos columnas importantes coinciden con las columnas de clave principal de las tablas participantes.

Por ejemplo, la tabla de intersección TeamMembership admite la relación de muchos a muchos teammembership_association entre SystemUser y Team . Permite a los usuarios unirse a varios equipos y equipos tener varios usuarios. TeamMembership tiene estas columnas: systemuserid, teamid.

Si desea recuperar información sobre los usuarios y los equipos a los que pertenecen utilizando la relación teammembership_association muchos a muchos, puede utilizar esta consulta fetchXML:

<fetch top='2'>
   <entity name='systemuser'>
      <attribute name='fullname' />
      <link-entity name='teammembership'
         from='systemuserid'
         to='systemuserid'
         intersect='true' >
         <link-entity name='team'
            from='teamid'
            to='teamid'
            link-type='inner'
            alias='team'>
            <attribute name='name' />
         </link-entity>
      </link-entity>
   </entity>
</fetch>

Hay dos entidades de vínculo anidadas.

• El primero conecta systemuser a la tabla de intersección teammembership donde systemuserid = systemuserid.
• La segunda conecta la tabla de intersección teammembership al equipo en el que teamid = teamid.

Los resultados deben tener un aspecto similar al siguiente:

 --------------------------------------
 | fullname             | team.name   |
 --------------------------------------
 | FirstName LastName   | org26ed931d |
 --------------------------------------
 | # PpdfCDSClient      | org26ed931d |
 --------------------------------------

Sin relación

Es posible especificar from atributos y to mediante columnas que no forman parte de una relación definida.

Por ejemplo, esta consulta busca pares de registros donde la columna Nombre de un registro de cuenta coincide con la columna FullName de un registro de contacto , independientemente de si se hacen referencia entre sí en cualquiera de las columnas de búsqueda.

<fetch>
   <entity name='account'>
     <attribute name='name' />
     <link-entity name='contact'
       from='fullname'
       to='name'
       link-type='inner'
       alias='contact'>
       <attribute name='fullname' />
     </link-entity>
   </entity>
 </fetch>

Los siguientes tipos de columna no se pueden usar en los atributos from y to:

• Archivo
• Imagen
• Campo de selección múltiple
• Lista de Fiestas

Algunas columnas se pueden usar en from y to atributos, pero podrían dar lugar a un rendimiento deficiente:

• Columnas del tipo Varias líneas de texto
• Columnas del tipo de línea de texto única con una longitud máxima superior a 850
• Columnas de fórmulas
• Columnas calculadas
• Columnas lógicas

Buscar registros que no están en un conjunto

Puede usar FetchXml para crear una consulta para devolver registros que no están en un conjunto mediante una combinación externa izquierda. Una combinación externa izquierda devuelve todas las filas que satisfacen la combinación de la primera entrada con la segunda entrada. También devuelve todas las filas de la primera entrada que no tenían filas coincidentes en la segunda entrada. Las filas que no coinciden en la segunda entrada se devuelven como valores NULL.

Puede realizar una combinación externa izquierda en FetchXML mediante el atributo entityname en un elemento de condición. El entityname atributo es válido en condiciones, filtros y filtros anidados. Obtenga más información sobre los filtros acerca de la entidad de enlace.

Por ejemplo, la siguiente consulta devuelve todos los registros de cuentas sin contactos.

<fetch>
   <entity name='account'>
      <attribute name='name' />
      <order attribute='name' />
      <link-entity name='contact'
         from='parentcustomerid'
         to='accountid'
         link-type='outer'
         alias='contact' />
      <filter type='and'>
         <condition entityname='contact'
            attribute='parentcustomerid'
            operator='null' />
      </filter>
   </entity>
</fetch>

Uso de tipos de vínculo avanzados

Los siguientes tipos de entidad de vínculo no corresponden directamente a los tipos de operador T-SQL JOIN y usan subconsultas en su lugar. Estos tipos proporcionan funcionalidades más avanzadas que puede usar para mejorar el rendimiento de las consultas y definir consultas más complejas.

Utilice tipos de enlace exists o in

exists y in son variantes de inner que usan condiciones diferentes (EXISTS e IN respectivamente) en la where cláusula para que no se devuelvan varias copias de la fila primaria en los resultados. Ninguno de estos tipos devuelve los valores de columna de las filas de la entidad vinculada.

exists

Estos ejemplos de FetchXml y SQL muestran los patrones aplicados con exists.

<fetch>
   <entity name='contact'>
      <attribute name='fullname' />
      <link-entity name='account'
         from='primarycontactid'
         to='contactid'
         link-type='exists'>
         <filter type='and'>
            <condition attribute='statecode'
               operator='eq'
               value='1' />
         </filter>
      </link-entity>
   </entity>
</fetch>

select 
    "contact0".fullname as "fullname" 
from Contact as "contact0" 
where exists (
    select "account1".primarycontactid
    from Account as "account1"
    where "account1".statecode = 1
        and "contact0".contactid = "account1".primarycontactid)

in

Estos ejemplos de FetchXml y SQL muestran los patrones aplicados con in.

<fetch>
   <entity name='contact'>
      <attribute name='fullname' />
      <link-entity name='account'
         from='primarycontactid'
         to='contactid'
         link-type='in'>
         <filter type='and'>
            <condition attribute='statecode'
               operator='eq'
               value='1' />
         </filter>
      </link-entity>
   </entity>
</fetch>

select 
    "contact0".fullname as "fullname" 
from Contact as "contact0" 
where "contact0".contactid in (
    select "account1".primarycontactid
    from Account as "account1"
    where "account1".statecode = 1)

El uso de los tipos de vínculo exists o in puede reducir el tamaño de los resultados intermedios o finales de la consulta, especialmente cuando existen muchas filas vinculadas coincidentes para las mismas filas primarias, o cuando se usan varias entidades de vínculo con el mismo elemento primario. El uso de los tipos de vínculo exists o in puede mejorar el rendimiento de la consulta en comparación con el tipo inner porque no requiere devolver un producto cartesiano que contenga todas las posibles permutaciones de filas de diferentes entidades vinculadas para cada fila primaria.

Estos tipos de vínculo también pueden permitir que Dataverse solo encuentre la primera fila de entidad vinculada coincidente para cada fila primaria, que es más eficaz que buscar todas las filas coincidentes de la entidad vinculada en una inner combinación.

Usar matchfirstrowusingcrossapply tipo de vínculo

Este tipo de vínculo produce un operador CROSS APPLY con una subconsulta usando top 1 después de este patrón:

<fetch>
   <entity name='contact'>
      <attribute name='fullname' />
      <link-entity name='account'
         from='primarycontactid'
         to='contactid'
         link-type='matchfirstrowusingcrossapply'>
         <attribute name='accountid' />
         <attribute name='name' />
      </link-entity>
   </entity>
</fetch>

select 
    "contact0".fullname as "fullname",
    "account1".accountid as "accountid",
    "account1".name as "name" 
from Contact as "contact0"
cross apply (
    select top 1
        "account1".accountid as "accountid",
        "account1".name as "name"
    from Account as "account1"
    where "contact0".contactid = "account1".primarycontactid
  ) "account1"

El matchfirstrowusingcrossapply tipo de vínculo es equivalente al inner tipo, excepto que solo devuelve la fila primaria como máximo una vez. La fila principal solo se devuelve si hay filas coincidentes en la entidad vinculada, pero, a diferencia de in y tipos exists, devuelve valores de columna de una de las filas coincidentes de la entidad vinculada. Úselo cuando solo sea necesario un ejemplo único de una fila coincidente de la entidad vinculada y no sean necesarias varias copias de la fila primaria en los resultados.

Los nombres de atributo o propiedad de tabla relacionados son incoherentes

Cuando se usa el matchfirstrowusingcrossapply tipo de vínculo, los nombres de las propiedades devueltas mediante la API web o los valores de la colecciónKeys Entity.Attributes del SDK para las columnas de tabla relacionadas son diferentes a otros tipos de combinaciones. Normalmente, estos seguirán el <tablealias>.<logicalname> formato. Sin embargo, para el matchfirstrowusingcrossapply tipo de vínculo, los valores SchemaName se usan sin el prefijo del alias de tabla.

Con el ejemplo de consulta anterior con cualquier otro tipo de vínculo, puede esperar que las propiedades o claves tengan estos nombres:

• fullname
• contactid
• account1.accountid
• account1.name

Pero con el tipo de matchfirstrowusingcrossapply vínculo, las propiedades o claves tienen estos nombres:

• fullname
• contactid
• AccountId
• Name

Pasos siguientes

Obtenga información sobre cómo ordenar filas.