Compartir por

Combinación de tablas mediante QueryExpression

Use la propiedad QueryExpression.LinkEntities para describir los datos de las tablas relacionadas que se van a devolver con la consulta. Esta propiedad contiene una colección de instancias de LinkEntity que describen:

  • Qué filas relacionadas de la tabla se deben devolver
  • Sobre qué valores de columna basar la combinación
  • Qué columnas de esos registros devolver
  • Cualquier filtro para aplicar con la combinación

Nota:

La LinkEntities propiedad es de solo lectura. Puede asignar LinkEntity instancias a esta colección mediante la inicialización de objetos o mediante el uso del método QueryExpression.AddLink.

También puede usar métodos System.Collections.ObjectModel.Collection<T> las herencias de propiedades de LinkEntities.

Propiedades de LinkEntity

En la tabla siguiente se proporcionan detalles sobre las propiedades LinkEntity:

Propiedad Description
LinkFromEntityName El nombre lógico de la entidad desde la que estás enlazando.
Para LinkEntity que no está anidado, use el mismo valor que la propiedad QueryExpression.EntityName.
Para un LinkEntity que está anidado en una colección LinkEntity.LinkEntities, use el valor de LinkEntity.LinkToEntityName de la entidad de vínculo principal.
LinkToEntityName Nombre lógico de la entidad a la que está vinculando.
LinkFromAttributeName Nombre lógico del atributo de la entidad desde la que está vinculando.
LinkToAttributeName Nombre lógico del atributo de la entidad a la que está vinculando.
JoinOperator El operador de combinación. Utilice un valor de uno de los miembros de JoinOperator enum. El valor predeterminado es Inner, que restringe los resultados a las filas con valores coincidentes en ambas tablas.
Otros valores válidos son:
- LeftOuter Incluye los resultados de la fila primaria que no tienen un valor coincidente.
- Natural Solo se devuelve un valor de las dos columnas combinadas si se realiza una operación de combinación igual y los dos valores son idénticos.
Estos miembros consideraron JoinOperators avanzados:
- Exists
- In
- MatchFirstRowUsingCrossApply
Estos miembros se usan para filtrar los valores de los registros relacionados:
- All
- Any
- NotAll
- NotAny
EntityAlias Alias de la tabla.
Columns Columnas para incluir en la tabla. Agregue estas columnas a la tabla combinada mediante .ColumnSet Aprenda a seleccionar columnas mediante QueryExpression
LinkCriteria Condición compleja y expresiones de filtro lógico que filtran los resultados de la consulta. Obtenga información sobre cómo filtrar filas mediante QueryExpression
LinkEntities Conjunto de vínculos entre entidades que pueden incluir vínculos anidados. Se pueden incluir hasta 15 vínculos totales en una consulta.

Nota:

El significado de las propiedades LinkEntity.LinkFromAttributeName y LinkEntity.LinkToAttributeName es lo contrario de los atributos correspondientes from y to en FetchXml. Más información acerca del uso de los atributos from y to con FetchXml

Ejemplo de LinkEntity

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. Esto representa una relación de varios a uno:

QueryExpression query = new("account")
{
      TopCount = 5,
      ColumnSet = new ColumnSet("name"),
      LinkEntities = {
            new LinkEntity()
            {
                  LinkFromEntityName = "account",
                  LinkToEntityName = "contact",
                  LinkFromAttributeName = "primarycontactid",
                  LinkToAttributeName = "contactid",
                  JoinOperator = JoinOperator.Inner,
                  EntityAlias = "contact",
                  Columns = new ColumnSet("fullname")
            }
      }
};

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

Puede componer toda la consulta mediante la inicialización de objetos como se muestra, pero se recomienda usar los métodos QueryExpression.AddLink y LinkEntity.AddLink . Estos métodos devuelven una referencia al vínculo creado para que pueda acceder y modificar fácilmente la consulta dentro de la colección. Por ejemplo, si redacta la consulta de esta manera mediante el método QueryExpression.AddLink:

var query = new QueryExpression("account")
{
      TopCount = 5,
      ColumnSet = new ColumnSet("name"),
};

// Link to primary contact
LinkEntity linkedPrimaryContact = query.AddLink(
      linkToEntityName: "contact",
      linkFromAttributeName: "primarycontactid",
      linkToAttributeName: "contactid",
      joinOperator: JoinOperator.Inner);

linkedPrimaryContact.EntityAlias = "primarycontact";
linkedPrimaryContact.Columns = new ColumnSet("fullname");

Puede ampliar la consulta mediante el método LinkEntity.AddLink para incluir información sobre el usuario propietario del contacto vinculado a través de la linkedPrimaryContactLinkEntity instancia:

// Link to contact owning user
LinkEntity linkedContactOwner = linkedPrimaryContact.AddLink(
      linkToEntityName: "systemuser",
      linkFromAttributeName: "owninguser",
      linkToAttributeName: "systemuserid",
      joinOperator: JoinOperator.Inner);

linkedContactOwner.EntityAlias = "owner";
linkedContactOwner.Columns = new ColumnSet("fullname");

De este modo, puede acceder más fácilmente a las distintas partes de la consulta para realizar ajustes.

Limitaciones

Puede agregar hasta 15 instancias de LinkEntity a una consulta. Cada LinkEntity agrega un JOIN a la consulta y aumenta el tiempo de ejecución de la consulta. Este límite es proteger el rendimiento. Si agrega más de 15 LinkEntity instancias a QueryExpression.LinkEntities, obtendrá este error en tiempo de ejecución:

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

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:

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). LinkToEntityName en el ejemplo anterior.
ReferencedAttribute contactid Clave principal de la tabla a la que se hace referencia. LinkToAttributeName en el ejemplo anterior.
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). LinkFromEntityName en el ejemplo anterior.
ReferencingAttribute primarycontactid Nombre de la columna de búsqueda. LinkFromAttributeName en el ejemplo anterior.
RelationshipType OneToManyRelationship Una relación de uno a muchos cuando se ve desde la tabla referenciada (uno) contact.
Una relación de muchos a uno cuando se be desde la tabla de referencia (muchos) account

Recuperar información de relación

Puede usar otras herramientas y APIs para buscar datos de relación para los valores adecuados LinkToEntityName, LinkToAttributeName, LinkFromEntityName y LinkFromAttributeName que se van a usar. Para obtener más información, consulte:

Ejemplo de relación de varios a uno

En la tabla siguiente se muestran los valores de relación que se van a usar para una relación de varios a uno:

Propiedad Valor de relación Comentario
LinkFromEntityName ReferencingEntity Tabla a la que se hace referencia. El many (muchos) en many-to-one (muchos a uno). account en el ejemplo de varios a uno. No hay ningún parámetro para esta propiedad en los métodos AddLink porque se puede derivar de las QueryExpression.EntityName propiedades o LinkEntity.LinkToEntityName .
LinkToEntityName ReferencedEntity La tabla con una clave principal a la que hace referencia la otra tabla. El one (uno) en many-to-one (muchos a uno). contact en el ejemplo de varios a uno.
LinkFromAttributeName ReferencingAttribute Nombre de la columna de búsqueda. primarycontactid en el ejemplo de varios a uno.
LinkToAttributeName ReferencedAttribute Clave principal de la tabla a la que se hace referencia. contactid en el ejemplo de varios a uno.

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.

Nota:

Si su tabla base contiene la columna de búsqueda, es una relación de varios a uno. De lo contrario, es una relación uno a varios.

Puede recuperar los mismos datos que el ejemplo anterior de la tabla de contacto mediante la misma relación, excepto desde el lado de la tabla contact. 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.

var query = new QueryExpression("contact")
{
      TopCount = 5,
      ColumnSet = new ColumnSet("fullname"),
};

// Link to related account
var linkedPrimaryContact = query.AddLink(
      linkToEntityName: "account",
      linkFromAttributeName: "contactid",
      linkToAttributeName: "primarycontactid",
      joinOperator: JoinOperator.Inner);

linkedPrimaryContact.EntityAlias = "account";
linkedPrimaryContact.Columns = new ColumnSet("name");

Para una relación uno a varios, use estos valores de relación:

Propiedad Valor de relación Comentario
LinkFromEntityName ReferencedEntity Tabla a la que se hace referencia. El one (uno) en many-to-one (muchos a uno). contact en el ejemplo uno a varios. No hay ningún parámetro para esta propiedad en los métodos AddLink porque se puede derivar de las QueryExpression.EntityName propiedades o LinkEntity.LinkToEntityName .
LinkToEntityName ReferencingEntity 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). account en el ejemplo de uno a varios.
LinkFromAttributeName ReferencedAttribute Clave principal de la tabla a la que se hace referencia. contactid en el ejemplo de uno a varios.
LinkToAttributeName ReferencingAttribute Nombre de la columna de búsqueda. primarycontactid en el ejemplo de uno a varios.

Los resultados incluyen los mismos registros y datos que el ejemplo anterior mediante la relación de varios a uno, excepto que la "entidad primaria" es ahora 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 mediante la teammembership_association relación de muchos a muchos, puede usar esta consulta QueryExpression:

var query = new QueryExpression("systemuser")
{
      TopCount = 2,
      ColumnSet = new ColumnSet("fullname"),
};

LinkEntity linkedTeamMemberShip = query.AddLink(
      linkToEntityName: "teammembership",
      linkFromAttributeName: "systemuserid",
      linkToAttributeName: "systemuserid");

LinkEntity linkedTeam = linkedTeamMemberShip.AddLink(
      linkToEntityName: "team",
      linkFromAttributeName: "teamid",
      linkToAttributeName: "teamid");

linkedTeam.EntityAlias = "team";
linkedTeam.Columns = new ColumnSet("name");

Hay dos instancias de LinkEntity .

  • linkedTeamMemberShip se conecta systemuser a la tabla de intersección de teammembership donde systemuserid = systemuserid.
  • linkedTeam conecta la tabla de intersección de 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 LinkFromAttributeName y LinkToAttributeName propiedades 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.

var query = new QueryExpression("account")
{
      ColumnSet = new ColumnSet("name"),
};

LinkEntity linkedContact = query.AddLink(
      linkToEntityName: "contact", 
      linkFromAttributeName: "name", 
      linkToAttributeName: "fullname");
linkedContact.EntityAlias = "contact";
linkedContact.Columns = new ColumnSet("fullname");

Nota:

Es importante que las columnas especificadas en las LinkFromAttributeName propiedades y LinkToAttributeName sean del mismo tipo incluso si no participan en una relación. El uso de columnas de diferentes tipos requerirá una conversión de tipos que podría tener un impacto en el rendimiento y podría producir un error en algunos valores de columna.

Los siguientes tipos de columna no se pueden usar en las propiedades LinkFromAttributeName y LinkToAttributeName:

Algunas columnas se pueden usar en LinkFromAttributeName y LinkToAttributeName propiedades, pero podrían dar lugar a un rendimiento deficiente.

Buscar registros que no están en un conjunto

Puede usar QueryExpression 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 QueryExpression mediante la propiedad ConditionExpression.EntityName. La EntityName propiedad es válida en condiciones, filtros y filtros anidados. Más información sobre los filtros en LinkEntity

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

var query = new QueryExpression(entityName: "account");
query.ColumnSet.AddColumn("name");
query.AddOrder(
      attributeName: "name", 
      orderType: OrderType.Descending);
query.Criteria.AddCondition(
      entityName: "contact",
      attributeName: "parentcustomerid",
      conditionOperator: ConditionOperator.Null);

LinkEntity linkedContact = query.AddLink(
      linkToEntityName: "contact",
      linkFromAttributeName: "accountid",
      linkToAttributeName: "parentcustomerid",
      joinOperator: JoinOperator.LeftOuter);
linkedContact.EntityAlias = "contact";
linkedContact.Columns.AddColumn("fullname");

Utilice operadores de unión avanzados

Los siguientes miembros JoinOperator no corresponden directamente a los tipos de operador JOIN de T-SQL y utilizan 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 . Use Exists cuando no sean necesarias varias copias de la fila primaria en los resultados. Obtenga 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 cláusula where. Use In cuando no sean necesarias varias copias de la fila primaria en los resultados. Obtenga 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 el uso de MatchFirstRowUsingCrossApply

Use JoinOperator.Exists o JoinOperator.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. Tanto Exists como In, no devuelven los valores de columna de las filas de entidad relacionadas.

Usar JoinOperator.Exists o JoinOperator.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 JoinOperator.Exists o JoinOperator.In puede mejorar el rendimiento de la consulta en comparación con JoinOperator.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 JoinOperator miembros también pueden permitir que Dataverse solo encuentre la primera fila de entidad vinculada coincidente para cada fila primaria que sea más eficaz que buscar todas las filas coincidentes en la entidad vinculada con JoinOperator.Inner.

Ejemplo JoinOperator.Exists

Estos ejemplos de QueryExpression y SQL muestran los patrones aplicados con JoinOperator.Exists.

QueryExpression query = new("contact");
query.ColumnSet.AddColumn("fullname");

LinkEntity linkedAccount = query.AddLink(
      linkToEntityName: "account",
      linkFromAttributeName: "contactid",
      linkToAttributeName: "primarycontactid",
      joinOperator: JoinOperator.Exists);

linkedAccount.EntityAlias = "account";

linkedAccount.LinkCriteria.AddCondition(
      entityName:"account", 
      attributeName: "statecode", 
      conditionOperator: ConditionOperator.Equal,
      values: 1);

Ejemplo JoinOperator.In

Estos ejemplos de QueryExpression y SQL muestran los patrones aplicados con JoinOperator.In.

QueryExpression query = new("contact");
query.ColumnSet.AddColumn("fullname");

LinkEntity linkedAccount = query.AddLink(
      linkToEntityName: "account",
      linkFromAttributeName: "contactid",
      linkToAttributeName: "primarycontactid",
      joinOperator: JoinOperator.In);

linkedAccount.EntityAlias = "account";

linkedAccount.LinkCriteria.AddCondition(
      entityName: "account",
      attributeName: "statecode",
      conditionOperator: ConditionOperator.Equal,
      values: 1);

Utilice JoinOperator.MatchFirstRowUsingCrossApply

JoinOperator.MatchFirstRowUsingCrossApply produce un operador CROSS APPLY con una subconsulta usando top 1 siguiendo este patrón:

QueryExpression query = new("contact");
query.ColumnSet.AddColumn("fullname");

LinkEntity linkedAccount = query.AddLink(
      linkToEntityName: "account",
      linkFromAttributeName: "contactid",
      linkToAttributeName: "primarycontactid",
      joinOperator: JoinOperator.MatchFirstRowUsingCrossApply);

linkedAccount.EntityAlias = "account";
linkedAccount.Columns = new ColumnSet("accountid", "name");

Esto equivale a JoinOperator.LeftOuter , salvo que solo devuelve la fila primaria como máximo una vez. A diferencia JoinOperator.In de y JoinOperator.Exists, devuelve valores de columna de una de las filas coincidentes de la tabla relacionada cuando existen filas coincidentes, pero la fila primaria se devuelve incluso si no hay filas coincidentes en la tabla relacionada. Úselo cuando solo un ejemplo de una fila coincidente de la tabla relacionada es suficiente y no son necesarias varias copias de la fila primaria en los resultados.

Pasos siguientes

Obtenga información sobre cómo ordenar filas.

Ordenar filas

  • Last updated on