Unir tabelas usando FetchXML

Conforme descrito nos dados de consulta usando FetchXml, inicie sua consulta selecionando uma tabela usando o elemento de entidade.

Utilize o elemento 'link-entity' para descrever os dados das tabelas relacionadas que você deseja retornar com sua consulta. Use os seguintes atributos:

Exemplo básico

A consulta a seguir retorna até cinco registros da conta e tabelas de contato com base na coluna de pesquisa PrimaryContactId no registro da conta:

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

Os resultados serão semelhantes a estes:

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

Limitações

Você pode adicionar até 15 link-entity elementos a uma consulta. Cada link-entity um adiciona um JOIN à consulta e aumenta o tempo necessário para executar a consulta. Esse limite protege o desempenho. Se você adicionar mais de 15 link-entity elementos a uma consulta, receberá esta mensagem de erro:

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

Elementos filhos

Dentro do link-entity elemento, você pode adicionar elementos filho como no elemento pai a:

• Selecione colunas na tabela relacionada.
• Filtrar linhas da tabela relacionada.
• Conecte-se a outra tabela relacionada.

Relações muitos-para-um

O exemplo básico mostra uma relação muitos para um em que muitos registros de conta podem se referir a um registro de contato. Você define essas informações na conta account_primary_contact relação muitos para um, que tem os seguintes valores:

Recuperar informações de relação

Se você usar ferramentas como xrmToolBoxFetchXML Builder ou Power Platform ToolBoxFetchXML Studio, poderá ver como essas ferramentas permitem selecionar a relação para definir os valores apropriados namefrome to de atributo.

Você também pode usar outras ferramentas e APIs para pesquisar dados de relação para os valores de atributo apropriados name, from, e to. Para saber como recuperar esses dados, confira:

• Navegar pelas definições de tabela no seu ambiente
• Definições de esquema de consulta

Relacionamento um para muitos

Relações muitos-para-um e um-para-muitos são como dois lados da mesma moeda. A relação existe entre as tabelas, portanto, a maneira como você a usa depende de qual tabela é a tabela base para sua consulta.

Você pode recuperar os mesmos dados do exemplo anterior da tabela de contatos usando a mesma relação, mas do lado da tabela de contatos. Use os dados da mesma relação um-para-muitos do Contato account_primary_contact, mas ajuste os valores para uma visualização diferente do relacionamento.

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

A tabela a seguir mostra os valores de atributo de entidade de link neste exemplo:

Os resultados incluem os mesmos registros e dados da consulta anterior que usa a relação muitos para um. A diferença é que a entidade pai agora contact está em vez 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)      |
 -----------------------------------------------------------------

Relacionamentos de muitos para muitos

Relações muitos-para-muitos dependem de uma tabela de interseção. Uma tabela intersect normalmente tem apenas quatro colunas, mas apenas duas delas são importantes. As duas colunas importantes correspondem às colunas de chave primária das tabelas participantes.

Por exemplo, a TeamMembership tabela de interseção suporta a relação de muitos-para-muitos teammembership_association entre as tabelas SystemUser e Team. Usando essa relação, os usuários podem ingressar em várias equipes e as equipes podem ter vários usuários. TeamMembership tem estas colunas: systemuserid e teamid.

Para recuperar informações sobre os usuários e as equipes às quais eles pertencem usando a relação muitos para muitos teammembership_association, utilize a 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>

Há duas entidades de link aninhadas.

• O primeiro conecta-se systemuser à tabela de interseção teammembership onde systemuserid = systemuserid.
• O segundo conecta a tabela de interseção teammembership ao team onde teamid = teamid.

Os resultados se parecem com:

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

Nenhuma relação

Você pode especificar atributos from e to usando colunas que não fazem parte de uma relação definida.

Por exemplo, essa consulta localiza pares de registros em que a coluna Name de um registro de conta corresponde à coluna FullName de um registro de contato , independentemente de se eles fazem referência uns aos outros em qualquer uma das colunas de pesquisa.

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

Você não pode usar os seguintes tipos de coluna em atributos from e to:

• Arquivo
• Imagem
• Campo de Seleção Múltipla
• ListaDeFestas

Você pode usar esses tipos de coluna em from e atributos em to, mas eles podem resultar em um desempenho ruim.

• Colunas do tipo várias linhas de texto
• Colunas do tipo linha única de texto com um comprimento máximo maior que 850
• Colunas de fórmula
• Colunas calculadas
• Colunas lógicas

Localizar registros que não estão em um conjunto

Você pode usar FetchXML para criar uma consulta que retorna registros que não estão em um conjunto usando uma junção externa esquerda. Uma junção externa esquerda retorna cada linha que satisfaz a junção da primeira entrada a segunda. Além disso, ele retorna todas as linhas da primeira entrada que não têm linhas correspondentes na segunda entrada. As linhas não correspondentes na segunda entrada são retornadas como valores nulos.

Você pode realizar uma junção externa à esquerda no FetchXML ao usar o entityname atributo em um elemento de condição. O entityname atributo é válido em condições, filtros e filtros aninhados. Saiba mais sobre filtros na entidade de ligação.

Por exemplo, a consulta a seguir retorna todos os registros de conta sem contatos.

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

Usar tipos de link avançados

Os tipos de entidade de link a seguir não correspondem diretamente aos tipos de operador T-SQL JOIN e, em vez disso, utilizam subconsultas. Esses tipos fornecem recursos mais avançados que você pode usar para melhorar o desempenho da consulta e definir consultas mais complexas.

Usar exists ou in vincular tipos

Os tipos de link exists e in são variantes do tipo de link inner. Eles usam condições diferentes (EXISTS e IN respectivamente) na cláusula where para que a consulta não retorne várias cópias da linha pai. Nenhum desses tipos de link retorna os valores de coluna das linhas da entidade vinculada.

exists

Esses exemplos FetchXML e SQL mostram os padrões aplicados com 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

Esses exemplos FetchXML e SQL mostram os padrões aplicados com 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)

Utilizar tipos de link exists ou in pode reduzir o tamanho dos resultados da consulta intermediários ou finais. Essa redução é especialmente útil quando existem muitas linhas vinculadas correspondentes para as mesmas linhas pai ou quando várias entidades de vínculo são usadas com o mesmo pai. Usando tipos de link exists ou in, você pode melhorar o desempenho da consulta em comparação com o tipo de link inner, pois a consulta não precisa retornar um produto Cartesiano que contenha todas as permutações possíveis de linhas de entidades diferentes vinculadas para cada linha pai.

Usando esses tipos de link, o Dataverse pode precisar encontrar apenas a primeira linha de entidade vinculada correspondente para cada linha pai. Essa abordagem é mais eficiente do que encontrar todas as linhas correspondentes na entidade vinculada em uma junção inner .

Utilize o tipo de link matchfirstrowusingcrossapply

Esse tipo de link produz um operador CROSS APPLY com uma subconsulta usando top 1 este padrão a seguir:

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

O tipo de link matchfirstrowusingcrossapply é equivalente ao tipo inner, exceto pelo fato de que ele retorna a linha pai no máximo uma única vez. A linha pai será retornada somente se houver linhas correspondentes na entidade vinculada, mas, diferentemente dos tipos in e exists, ela realmente retornará valores de coluna de uma das linhas correspondentes na entidade vinculada. Use esse tipo quando apenas um único exemplo de uma linha correspondente da entidade vinculada for suficiente e os resultados não precisarem de várias cópias da linha pai.

Os nomes de atributo e propriedade de tabela relacionados são inconsistentes

Quando você usa o matchfirstrowusingcrossapply tipo de link, os nomes das propriedades retornadas usando a API Web ou os valores da coleção SDK Keys para as colunas de tabela relacionadas diferem de outros tipos de junções. Normalmente, esses nomes seguem o <tablealias>.<logicalname> formato. No entanto, para o matchfirstrowusingcrossapply tipo de link, os valores SchemaName são usados sem o prefixo de alias da tabela.

Usando o exemplo de consulta anterior com qualquer outro tipo de link, você pode esperar que as propriedades ou chaves tenham esses nomes:

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

Porém, usando o matchfirstrowusingcrossapply tipo de link, as propriedades ou chaves têm estes nomes:

• fullname
• contactid
• AccountId
• Name

Próximas Etapas 

Saiba como ordenar linhas.