Unir tablas mediante FetchXml

Como se describe en Consultar datos mediante FetchXml, comience su consulta seleccionando una tabla que utilice el elemento de entidad.

Utilice el elemento vínculo-entidad para describir los datos de tablas relacionadas que se devolverán con su consulta con los siguientes atributos:

Por ejemplo, la siguiente consulta devuelve hasta 5 registros de las tablas cuenta y contacto basadas en la Columna de búsqueda PrimaryContactId en el 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 elementos link-entity a una consulta. Cada entidad de vínculo agrega un JOIN a la consulta y aumenta el tiempo para ejecutar la consulta. Este límite es para proteger el rendimiento. Si agrega más de 15 elementos de entidad de vínculo a una consulta, obtiene 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 puede agregar elementos secundarios como en el elemento principal para:

• Seleccionar columnas de la tabla relacionada
• Filtrar filas de la tabla relacionada
• Unirse a otra tabla relacionada

Relaciones de varios a uno

El ejemplo anterior es una relación de muchos a uno donde muchos registros de cuentas pueden hacer referencia a un registro de contacto. 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 la relación

Si utiliza XrmToolBox FetchXML Builder, puede ver cómo esta herramienta le permite seleccionar la relación para establecer los valores de atributo name, from y to adecuados.

También puede utilizar otras herramientas y API para buscar datos de relaciones para los valores de atributo name, from y to adecuados que se utilizarán. Aprenda a recuperar estos datos:

• Examinar las definiciones de tablas en su entorno
• Consultar definiciones de esquema

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 la use depende de qué tabla es la tabla base para su 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>

La siguiente tabla muestra los valores de atributo vínculo-entidad en este ejemplo:

Los resultados incluyen los mismos registros y datos que la consulta anterior usando la relación de muchos a uno, excepto que la 'entidad principal' 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. Una tabla de intersección normalmente 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 a los 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.

• La primera se 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.

El resultado deberá ser ahora similar a:

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

No existe relación

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

Por ejemplo, esta consulta encuentra pares de registros donde la Columna de 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 utilizar en los atributos from y to:

• Archivo
• Image
• Campo MultiSelect
• PartyList

Algunas columnas se pueden utilizar en los atributos from y to pero podría resultar en un rendimiento deficiente:

• Columnas del tipo Varias líneas de texto
• Columnas del tipo Línea única de texto con una longitud máxima superior a 850
• Columnas de Fórmula
• Columnas de Calculado
• 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 usando 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 las filas de la primera entrada que no tenían ninguna fila coincidente en la segunda entrada. Las filas no coincidentes de la segunda entrada se devuelven como valores nulos.

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

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>

Utilizar tipos de vínculos avanzados

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

Utilizar tipos de vínculo exists o in

exists e in son variantes de inner que utilizan diferentes condiciones ( EXISTS e IN respectivamente) en la cláusula where para que no se devuelvan varias copias de la fila principal en los resultados. Ninguno de estos tipos devuelve los valores de las columnas de las filas de la entidad de vínculo.

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 tipos de vínculos exists o in puede reducir el tamaño de los resultados de consulta intermedios o finales, especialmente cuando existen muchas filas vinculadas coincidentes para las mismas filas principales, o cuando se utilizan varias entidades de vínculo con el mismo elemento primario. El uso de tipos de vínculos 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 permutaciones posibles de filas de diferentes entidades vinculadas para cada fila principal.

Estos tipos de vínculos también podrían permitir a Dataverse buscar solo la primera fila de entidad vinculada coincidente para cada fila principal, lo cual es más eficiente que encontrar todas las filas coincidentes en la entidad vinculada en una combinación inner.

Usar el tipo de vínculo matchfirstrowusingcrossapply

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 tipo de vínculo matchfirstrowusingcrossapply es equivalente al tipo inner excepto que solo devuelve la fila principal como máximo una vez. La fila primaria se devuelve solo si hay filas coincidentes en la entidad vinculada pero, a diferencia de los tipos in y exists, sí devuelve valores de columna de una de las filas coincidentes en la entidad vinculada cuando coincide con filas existen, pero la fila principal se devuelve incluso si no hay filas coincidentes en la entidad vinculada. Utilícelo cuando solo sea suficiente un único ejemplo de una fila coincidente de la entidad vinculada y no sean necesarias varias copias de la fila principal en los resultados.

Los nombres de atributos/propiedades de tablas relacionadas son incoherentes

Cuando se utiliza el tipo de vínculo matchfirstrowusingcrossapply, los nombres de las propiedades devueltas mediante la API web o los valores del SDK colección Entity.Attributes Keys para las columnas de la tabla relacionada son diferentes que otros tipos de uniones. Normalmente, seguirán el formato <tablealias>.<logicalname>. Sin embargo, para el tipo de vínculo matchfirstrowusingcrossapply, los valores SchemaName se utilizan sin el prefijo de alias de tabla.

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

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

• fullname
• contactid
• AccountId
• Name

Pasos siguientes

Aprenda a filtrar las filas de pedidos.