Compartir vía

Unir tablas mediante FetchXml

  • Artículo

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:

Atributo Breve descripción Encuentre más detalles en la referencia del elemento de vínculo-entidad
name El nombre lógico de la tabla relacionada.
from El nombre lógico de la columna de la tabla relacionada que coincide con la columna especificada en el atributo to.
to El nombre lógico de la columna del elemento primario para concuerda con la tabla relacionada que coincide con la columna especificada en el atributo from.
link-type El tipo de uso de vínculo. El comportamiento predeterminado es inner, que restringe los resultados a filas con valores coincidentes en ambas tablas.
Otros valores válidos son:
- outer
- any
- not any
- all
- not all
- exists
- in
- matchfirstrowusingcrossapply
Más información sobre las opciones de tipo de vínculo
alias Representa el nombre de la tabla relacionada en los resultados.
intersect Indica que link-entity se utiliza para unir tablas y no devuelve ninguna columna

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:

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:

Propiedad valor Comentario
SchemaName account_primary_contact Nombre único de la relación.
ReferencedEntity contact La tabla referenciada. El one (uno) en many-to-one (muchos a uno).
ReferencedAttribute contactid La clave principal de la tabla referenciada.
ReferencingEntity account La tabla con una columna de búsqueda que hace referencia a la otra tabla. El many (muchos) en many-to-one (muchos a uno).
ReferencingAttribute primarycontactid El nombre de la columna de búsqueda.
RelationshipType OneToManyRelationship Una relación de uno a muchos cuando se ve desde la tabla referenciada (uno).
Una relación de muchos a uno cuando se be desde la tabla de referencia (muchos)

Recuperar información de la relación

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

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:

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:

Atributo valor Descripción
name account El nombre lógico de la tabla de referencia
from primarycontactid El nombre de la columna de búsqueda en la tabla de cuenta de referencia
to contactid La clave principal de la tabla de contacto referenciada.
alias account Se recomienda un valor para link-entity con una relación de uno a muchos. Si no se proporciona un alias, se genera un alias predeterminado. En este ejemplo, si no se proporciona ningún alias, los datos se devuelven con una columna denominada account1.name.
link-type Sin establecer Cuando no se establece ningún valor, el valor predeterminado es inner

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>

Nota

Es importante que las columnas especificadas en los atributos from y to sean del mismo tipo incluso si no están involucradas en una relación. El uso de columnas de diferentes tipos requerirá una conversión de tipo que puede tener un impacto en el rendimiento y puede fallar en algunos valores de columna.

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

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 unión externa izquierda en FetchXML utilizando 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>

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.

Name Descripción
exists Una variante de inner que pueden proporcionar beneficios de rendimiento. Utiliza una condición EXISTS en la cláusula where . Utilícelo cuando no sean necesarias varias copias de la fila principal en los resultados. Obtenga más información sobre exists e in
in Una variante de inner que pueden proporcionar beneficios de rendimiento. Utiliza una condición IN en la cláusula where . Utilícelo cuando no sean necesarias varias copias de la fila principal en los resultados. Obtenga más información sobre exists e in
matchfirstrowusingcrossapply Una variante de inner que pueden proporcionar beneficios de rendimiento. Utilice este tipo 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. Obtenga más información sobre matchfirstrowusingcrossapply

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>

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>

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.

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>

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.

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.

Ordenar filas

Nota

¿Puede indicarnos sus preferencias de idioma de documentación? Realice una breve encuesta. (tenga en cuenta que esta encuesta está en inglés)

La encuesta durará unos siete minutos. No se recopilan datos personales (declaración de privacidad).