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.

Use el elemento link-entity para describir los datos de las tablas relacionadas que desea devolver con la consulta. Use los atributos siguientes:

Atributo	Descripción breve Buscar más detalles en la referencia del elemento link-entity
`name`	El nombre lógico de la tabla relacionada.
`from`	Nombre lógico de la columna de la tabla relacionada que coincide con la columna especificada en el `to` atributo .
`to`	Nombre lógico de la columna del elemento primario que debe coincidir con la columna de tabla relacionada especificada en el `from` atributo .
`link-type`	Tipo de vínculo que se va a usar. El valor predeterminado es `inner`, que restringe los resultados a las filas con valores coincidentes en ambas tablas. Otros valores válidos son: - `outer` - `any` - `not any` - `all` - `not all` - `exists` - `in` - `matchfirstrowusingcrossapply` Obtenga 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 usa para combinar tablas y no devuelve ninguna columna.

Ejemplo básico

La consulta siguiente devuelve hasta cinco 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 link-entity agrega una join a la consulta y aumenta el tiempo de ejecución de la consulta. Este límite protege el rendimiento. Si agrega más de 15 link-entity elementos a una consulta, recibirá este mensaje de 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 al igual que lo hace en el elemento primario.

Seleccione columnas de la tabla relacionada.
Filtre las filas de la tabla relacionada.
Unir otra tabla relacionada.

Relaciones de muchos a uno

En el ejemplo básico se muestra una relación de varios a uno donde muchos registros de cuenta pueden hacer referencia a un registro de contacto. Esta información se define en la relación de cuenta de uno a muchos account_primary_contact, que tiene los siguientes valores:

Propiedad	Importancia	Comentario
`SchemaName`	`account_primary_contact`	Nombre único de la relación.
`ReferencedEntity`	`contact`	Tabla a la que se hace referencia. El one (uno) en many-to-one (muchos a uno).
`ReferencedAttribute`	`contactid`	Clave principal de la tabla a la que se hace referencia.
`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`	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 varios a uno cuando se ve desde la tabla de referencia (varios).

Recuperar información de relación

Si usa herramientas como XrmToolBox FetchXML Builder o Power Platform ToolBox FetchXML Studio, puede ver cómo estas herramientas le permiten seleccionar la relación para establecer los valores de atributo , namey from adecuadosto.

También puede usar otras herramientas y API para buscar datos de relación para los valores de atributo name, from y to adecuados. Para obtener información sobre cómo recuperar estos datos, consulte:

Relaciones de uno a varios

Las relaciones uno a uno y uno a varios son como dos lados de la misma 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 el ejemplo anterior de la tabla de contactos mediante la misma relación, pero desde el lado 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:

Atributo	Importancia	Description
`name`	`account`	Nombre lógico de la tabla de referencia
`from`	`primarycontactid`	Nombre de la columna de búsqueda en la tabla de cuentas de referencia
`to`	`contactid`	Clave principal de la tabla de contactos a la que se hace referencia
`alias`	`account`	Se recomienda un valor para `link-entity` con una relación de uno a varios. Si no proporciona un alias, el sistema genera un alias predeterminado. En este ejemplo, si no proporciona un alias, los datos se devuelven con una columna denominada `account1.name`.
`link-type`	Sin establecer	Cuando no se establece un valor, el valor predeterminado es `inner`

Los resultados incluyen los mismos registros y datos que la consulta anterior que utiliza la relación de muchos a uno. La diferencia es que la entidad primaria 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 varios a varios se basan en 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 corresponden a 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 . Con esta relación, los usuarios pueden unirse a varios equipos y los equipos pueden tener varios usuarios. TeamMembership tiene estas columnas: systemuserid y teamid.

Para recuperar información sobre los usuarios y los equipos a los que pertenecen mediante la teammembership_association relación de muchos a muchos, use esta consulta de tipo 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 a team donde teamid = teamid.

Los resultados tienen el siguiente aspecto:

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

Sin relación

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

Nota:

Asegúrese de que las columnas especificadas en los from atributos y to son del mismo tipo, aunque no estén implicadas en una relación. Si usa columnas de diferentes tipos, la consulta necesita una conversión de tipos, lo que puede afectar al rendimiento y podría producir un error en algunos valores de columna.

No puede usar los siguientes tipos de columna en from y to atributos:

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

Puede usar estos tipos de columna 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 que devuelva 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 las filas de la primera entrada que no tenían ninguna fila coincidente 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.

Nombre	Description
`exists`	Una variante de `inner` que puede proporcionar ventajas de rendimiento. Usa una condición EXISTS en la `where` cláusula . Úselo cuando no sean necesarias varias copias de la fila primaria en los resultados. Más información sobre "exists" y "in"
`in`	Una variante de `inner` que puede proporcionar ventajas de rendimiento. Usa una condición IN en la `where` cláusula . Úselo cuando no sean necesarias varias copias de la fila primaria en los resultados. Más información sobre "exists" y "in"
`matchfirstrowusingcrossapply`	Una variante de `inner` que puede proporcionar ventajas de rendimiento. Use este tipo 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. Más información sobre matchfirstrowusingcrossapply

Utilice tipos de enlace `exists` o `in`

Los tipos de vínculo exists y in son variantes del tipo de vínculo inner. Usan condiciones diferentes (EXISTS e IN respectivamente) en la where cláusula para que la consulta no devuelva varias copias de la fila primaria. Ninguno de estos tipos de vínculo devuelve los valores de columna de las filas de la entidad de enlace.

`exists`

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

FetchXML
SQL

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

FetchXML
SQL

<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 exists o in tipos de vínculo puede reducir el tamaño de los resultados intermedios o finales de la consulta. Esta reducción es especialmente útil 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. Mediante el uso de los tipos de vínculo exists o in, puede mejorar el rendimiento de la consulta en comparación con el tipo de vínculo inner, ya que la consulta no necesita devolver un producto cartesiano que contenga todas las posibles permutaciones de filas procedentes de diferentes entidades vinculadas para cada fila principal.

Con estos tipos de vínculo, Es posible que Dataverse solo necesite encontrar la primera fila de entidad vinculada coincidente para cada fila primaria. Este enfoque 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:

FetchXml
SQL

<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. Use este tipo cuando solo un ejemplo único de una fila coincidente de la entidad vinculada sea suficiente y los resultados no necesiten varias copias de la fila primaria.

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ón Keys del SDK para las columnas de tabla relacionadas difieren de otros tipos de combinaciones. Normalmente, estos nombres siguen 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.

Mediante 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, mediante 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.

Ordenar filas

Comentarios

Resultoulle útil esta páxina?

Last updated on 2026-03-14