Registrar processo de geração (SQLXML 4.0)

Escopo de um nó

Um nó (elemento ou atributo) em um documento XML entra no escopo quando o Carregamento em massa XML o encontra no fluxo de dados de entrada XML. Para um nó de elemento, a marca inicial do elemento coloca o elemento no escopo. Para um nó de atributo, o nome do atributo coloca o atributo no escopo.

Um nó sai do escopo quando não há mais dados para ele: seja na marca final (no caso de um nó de elemento) ou no final do valor de um atributo (no caso de um nó de atributo).

Regra de geração de registro

Quando um nó (elemento ou atributo) entra no escopo, existe uma possibilidade de geração de um registro a partir desse nó. O registro dura enquanto o nó associado estiver no escopo. Quando o nó sair do escopo, o Carregamento em massa XML considera o registro gerado completo (com dados) e o envia ao SQL Server para inserção.

Por exemplo, considere o seguinte fragmento de esquema XSD:

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
            xmlns:sql="urn:schemas-microsoft-com:mapping-schema">
  <xsd:element name="Customer" sql:relation="Customers" >
   <xsd:complexType>
     <xsd:attribute name="CustomerID" type="xsd:string" />
     <xsd:attribute name="CompanyName" type="xsd:string" />
    </xsd:complexType>
  </xsd:element>
</xsd:schema>

O esquema especifica um elemento <Customer> com os atributos CustomerID e CompanyName. A anotação sql:relation mapeia o elemento <Customer> elemento para a tabela Customers.

Considere este fragmento de um documento XML:

<Customer CustomerID="1" CompanyName="xyz" />
<Customer CustomerID="2" CompanyName="abc" />
...

Quando um Carregamento em massa XML é fornecido com o esquema descrito nos parágrafos anteriores e os dados XML são fornecidos como entrada, ele processa os nós (elementos e atributos) nos dados de origem, conforme indicado a seguir:

• A marca inicial do primeiro elemento <Customer> coloca esse elemento no escopo. Este nó é mapeado para a tabela Customers. Portanto, o Carregamento em massa XML gera um registro para a tabela Customers.

• No esquema, todos os atributos do elemento <Customer> são mapeados para colunas da tabela Customers. À medida que esses atributos entram no escopo, o Carregamento em massa XML copia seus valores para o registro do cliente que já foi gerado pelo escopo pai.

• Quando o Carregamento em massa XML chega à marca final do elemento <Customer>, o elemento sai do escopo. Isto faz o Carregamento em massa XML considerar o registro completo e enviá-lo ao SQL Server.

O Carregamento em massa XML segue esse processo para cada elemento <Customer> subseqüente.

Importante
Nesse modelo, como um registro é inserido quando uma marca final é atingida (ou o nó fica fora do escopo), você deve definir todos os dados que estão associados ao registro dentro do escopo do nó.

Subconjunto de registro e regra de ordenação de chaves

Quando você especifica um esquema de mapeamento que usa <sql:relationship>, o termo subconjunto refere-se ao conjunto dos registros que é gerado no lado externo do relacionamento. No seguinte exemplo, os registros CustOrder estão no lado externo, <sql:relationship>.

Por exemplo, suponha que um banco de dados contenha as seguintes tabelas:

• Cust (CustomerID, CompanyName, City)

• CustOrder (CustomerID, OrderID)

O CustomerID na tabela CustOrder é uma chave estrangeira que faz referência à chave primária CustomerID na tabela Cust.

Agora, considere a exibição XML conforme especificado no seguinte esquema XSD anotado. Esse esquema usa <sql:relationship> para especificar a relação entre as tabelas Cust e CustOrder.

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
            xmlns:sql="urn:schemas-microsoft-com:mapping-schema">
<xsd:annotation>
  <xsd:appinfo>
    <sql:relationship name="CustCustOrder"
          parent="Cust"
          parent-key="CustomerID"
          child="CustOrder"
          child-key="CustomerID" />
  </xsd:appinfo>
</xsd:annotation>

  <xsd:element name="Customers" sql:relation="Cust" >
   <xsd:complexType>
     <xsd:sequence>
       <xsd:element name="CustomerID"  type="xsd:integer" />
       <xsd:element name="CompanyName" type="xsd:string" />
       <xsd:element name="City"        type="xsd:string" />
       <xsd:element name="Order" 
                          sql:relation="CustOrder"
                          sql:relationship="CustCustOrder" >
         <xsd:complexType>
          <xsd:attribute name="OrderID" type="xsd:integer" />
         </xsd:complexType>
       </xsd:element>
     </xsd:sequence>
    </xsd:complexType>
  </xsd:element>
</xsd:schema>

Os dados XML de exemplo e as etapas para criar um exemplo de funcionamento são dados a seguir.

• Quando um nó de elemento <Customer> no arquivo de dados XML entra no escopo, o Carregamento em massa XML gera um registro para a tabela Cust. O Carregamento em massa XML, então, copia os valores das colunas necessárias (CustomerID, CompanyName e City) dos elementos filho <CustomerID>, <CompanyName> e <City> à medida que esses elementos entrarem no escopo.

• Quando um nó de elemento <Order> entra no escopo, o Carregamento em massa XML gera um registro para a tabela CustOrder. O Carregamento em massa XML copia o valor do atributo OrderID nesse registro. O valor necessário para a coluna CustomerID é obtido do elemento filho <CustomerID> do elemento <Customer>. O Carregamento em massa XML usa as informações que estão especificadas em <sql:relationship> para obter o valor da chave estrangeira CustomerID para este registro, a menos que o atributo CustomerID tenha sido especificado no elemento <Order>. A regra geral é que, se o elemento filho especifica explicitamente um valor para o atributo de chave estrangeira, o Carregamento em massa XML usará esse valor e não obterá o valor do elemento pai usando o <sql:relationship> especificado. À medida que este nó de elemento <Order> sai do escopo, o Carregamento em massa XML envia o registro para o SQL Server e, em seguida, processa todos os nós de elemento <Order> subseqüentes da mesma maneira.

• Finalmente, o nó de elemento <Customer> sai do escopo. Nesse instante, o Carregamento em massa XML envia o registro do cliente ao SQL Server. O Carregamento em massa XML segue este processo para todos os clientes subseqüentes no fluxo de dados XML.

Existem duas observações sobre o esquema de mapeamento:

• Quando o esquema obedece à regra de "contenção" (por exemplo, todos os dados associados ao cliente e ao pedido estão definidos dentro do escopo dos nós de elemento <Customer> e <Order>), o Carregamento em massa é bem-sucedido.

• Ao descrever o elemento <Customer>, seus elementos filhos são especificados na ordem apropriada. Neste caso, o elemento filho <CustomerID> é especificado antes do elemento filho <Order>. Isso significa que, no arquivo de dados de entrada XML, o valor do elemento <CustomerID> está disponível como valor de chave estrangeira quando o elemento <Order> entra no escopo. Os atributos de chave são especificados primeiro; esta é a “regra de ordenação de chaves".

  Se você especificar o elemento filho <CustomerID> depois do elemento filho <Order>, o valor não estará disponível quando o elemento filho <Order> entrar no escopo. Quando a marca final </Order> for lida, então o registro para a tabela CustOrder será considerado completo e será inserido na tabela CustOrder com valor NULL para a coluna CustomerID, o que não é o resultado desejado.

Para criar um exemplo de funcionamento

Exceções à regra de geração de registros

O Carregamento em massa XML não gera um registro para um nó quando ele entra no escopo, se esse nó for do tipo IDREF ou IDREFS. Você deve ter certeza de que há uma descrição completa do registro em algum lugar do esquema. As anotações dt:type="nmtokens" são ignoradas da mesma maneira que o tipo IDREFS é ignorado.

Por exemplo, considere o seguinte esquema XSD, que descreve os elementos <Customer> e <Order>. O elemento <Customer> inclui um atributo OrderList do tipo IDREFS. A marca <sql:relationship> especifica a relação um-para-muitos entre o cliente e lista de pedidos.

Este é o esquema:

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
            xmlns:sql="urn:schemas-microsoft-com:mapping-schema">
<xsd:annotation>
  <xsd:appinfo>
    <sql:relationship name="CustCustOrder"
                 parent="Cust"
                 parent-key="CustomerID"
                 child="CustOrder"
                 child-key="CustomerID" />
  </xsd:appinfo>
</xsd:annotation>

  <xsd:element name="Customers" sql:relation="Cust" >
   <xsd:complexType>
    <xsd:attribute name="CustomerID" type="xsd:integer" />
    <xsd:attribute name="CompanyName" type="xsd:string" />
    <xsd:attribute name="City" type="xsd:string" />
    <xsd:attribute name="OrderList" 
                       type="xsd:IDREFS" 
                       sql:relation="CustOrder" 
                       sql:field="OrderID"
                       sql:relationship="CustCustOrder" >
    </xsd:attribute>
  </xsd:complexType>
 </xsd:element>

  <xsd:element name="Order" sql:relation="CustOrder" >
   <xsd:complexType>
    <xsd:attribute name="OrderID" type="xsd:string" />
    <xsd:attribute name="CustomerID" type="xsd:integer" />
    <xsd:attribute name="OrderDate" type="xsd:date" />
  </xsd:complexType>
 </xsd:element>
</xsd:schema>

Como o Carregamento em massa ignora os nós do tipo IDREFS, não será gerado nenhum registro quando o nó de atributo OrderList entrar no escopo. Portanto, se você quiser que os registros de ordem sejam adicionados à tabela Orders, deve descrever esses pedidos ordens em algum lugar no esquema. Nesse esquema, especificar o elemento <Ordem> garante que o Carregamento em massa XML adicionará os registros de pedido à tabela Orders. O elemento <Order> descreve todos os atributos que necessários para preencher o registro para a tabela CustOrder.

Você deve garantir que os valores de CustomerID e OrderID no elemento <Customer> correspondam aos valores no elemento <Order>. Você é responsável por manter a integridade referencial.

Para testar um exemplo de funcionamento