Příklady hromadného načítání XML (SQLXML 4.0)

platí pro:SQL Server azure SQL Database

Následující příklady ilustrují funkci XML Bulk Load v Microsoft SQL Serveru. Každý příklad poskytuje schéma XSD a jeho ekvivalentní schéma XDR.

Bulk Loader Script (ValidateAndBulkload.vbs)

Následující skript, napsaný v Microsoft Visual Basic Scripting Edition (VBScript), načítá XML dokument do XML DOM; ověřuje ji proti schématu; a pokud je dokument platný, vykoná hromadné načtení XML pro načtení XML do tabulky SQL Serveru. Toto písmo lze použít s každým z jednotlivých příkladů, které se na něj později v tomto tématu zmíní.

Poznámka:

XML Bulk Load nevyhodí varování ani chybu, pokud není z datového souboru nahrán žádný obsah. Proto je dobré ověřit svůj XML datový soubor před provedením hromadného načítání.

Dim FileValid  
  
set objBL = CreateObject("SQLXMLBulkLoad.SQLXMLBulkload.4.0")  
objBL.ConnectionString = "provider=SQLOLEDB;data source=MyServer;database=tempdb;integrated security=SSPI"  
objBL.ErrorLogFile = "c:\error.log"  
  
'Validate the data file prior to bulkload  
Dim sOutput   
sOutput = ValidateFile("SampleXMLData.xml", "", "SampleSchema.xml")  
WScript.Echo sOutput  
  
If FileValid Then  
   ' Check constraints and initiate transaction (if needed)  
   ' objBL.CheckConstraints = True  
   ' objBL.Transaction=True  
  'Execute XML bulkload using file.  
  objBL.Execute "SampleSchema.xml", "SampleXMLData.xml"  
  set objBL=Nothing  
End If  
  
Function ValidateFile(strXmlFile,strUrn,strXsdFile)  
  
   ' Create a schema cache and add SampleSchema.xml to it.  
   Dim xs, fso, sAppPath  
   Set fso = CreateObject("Scripting.FileSystemObject")   
   Set xs = CreateObject("MSXML2.XMLSchemaCache.6.0")  
   sAppPath = fso.GetFolder(".")   
   xs.Add strUrn, sAppPath & "\" & strXsdFile  
  
   ' Create an XML DOMDocument object.  
   Dim xd   
   Set xd = CreateObject("MSXML2.DOMDocument.6.0")  
  
   ' Assign the schema cache to the DOM document.  
   ' schemas collection.  
   Set xd.schemas = xs  
  
   ' Load XML document as DOM document.  
   xd.async = False  
   xd.Load sAppPath & "\" & strXmlFile  
  
   ' Return validation results in message to the user.  
   If xd.parseError.errorCode <> 0 Then  
        ValidateFile = "Validation failed on " & _  
             strXmlFile & vbCrLf & _  
             "=======" & vbCrLf & _  
             "Reason: " & xd.parseError.reason & _  
             vbCrLf & "Source: " & _  
             xd.parseError.srcText & _  
             vbCrLf & "Line: " & _  
             xd.parseError.Line & vbCrLf  
             FileValid = False  
    Else  
        ValidateFile = "Validation succeeded for " & _  
             strXmlFile & vbCrLf & _  
             "========" & _  
             vbCrLf & "Contents to be bulkloaded" & vbCrLf  
             FileValid = True  
    End If  
End Function

A. Hromadné načítání XML v tabulce

Tento příklad navazuje spojení s instancí SQL Serveru, která je specifikována ve vlastnosti ConnectionString (MyServer). Příklad také specifikuje vlastnost ErrorLogFile. Proto se výstup chyby uloží do určeného souboru ("C:\error.log"), který můžete také změnit na jiné místo. Všimněte si také, že metoda Execute má jako své parametry jak soubor mapovacího schématu (SampleSchema.xml), tak XML datový soubor (SampleXMLData.xml). Když se hromadné načítání spustí, tabulka Cust, kterou jste vytvořili v databázi tempdb , bude obsahovat nové záznamy založené na obsahu XML datového souboru.

Pro testování vzorku hromadného zatížení

Vytvořte tuto tabulku:

CREATE TABLE Cust(CustomerID  int PRIMARY KEY,  
                  CompanyName varchar(20),  
                  City        varchar(20));  
GO

Vytvořte soubor ve svém oblíbeném textovém nebo XML editoru a uložte ho jako SampleSchema.xml. Do tohoto souboru přidejte následující schéma XSD:

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"  
            xmlns:sql="urn:schemas-microsoft-com:mapping-schema">  
   <xsd:element name="ROOT" sql:is-constant="1" >  
     <xsd:complexType>  
       <xsd:sequence>  
         <xsd:element name="Customers" sql:relation="Cust" maxOccurs="unbounded">  
           <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:sequence>  
           </xsd:complexType>  
         </xsd:element>  
       </xsd:sequence>  
      </xsd:complexType>  
     </xsd:element>  
</xsd:schema>

Vytvořte soubor ve svém oblíbeném textovém nebo XML editoru a uložte ho jako SampleXMLData.xml. Do tohoto souboru přidejte následující XML dokument:

<ROOT>  
  <Customers>  
    <CustomerID>1111</CustomerID>  
    <CompanyName>Sean Chai</CompanyName>  
    <City>New York</City>  
  </Customers>  
  <Customers>  
    <CustomerID>1112</CustomerID>  
    <CompanyName>Tom Johnston</CompanyName>  
     <City>Los Angeles</City>  
  </Customers>  
  <Customers>  
    <CustomerID>1113</CustomerID>  
    <CompanyName>Institute of Art</CompanyName>  
    <City>Chicago</City>  
  </Customers>  
</ROOT>

Vytvořte soubor ve svém preferovaném textovém nebo XML editoru a uložte ho jako ValidateAndBulkload.vbs. Do tohoto souboru přidejte VBScript kód, který je uveden výše na začátku tohoto tématu. Upravte spojovací řetězec tak, aby poskytl odpovídající název serveru. Specifikujte vhodnou cestu pro soubory, které jsou specifikovány jako parametry metody Execut.
Spuskutěte VBScript kód. XML Bulk Load načítá XML do tabulky Cust.

Toto je ekvivalentní schéma XDR:

  
<Schema xmlns="urn:schemas-microsoft-com:xml-data"   
        xmlns:dt="urn:schemas-microsoft-com:xml:datatypes"    
        xmlns:sql="urn:schemas-microsoft-com:xml-sql" >   
  
   <ElementType name="CustomerID" dt:type="int" />  
   <ElementType name="CompanyName" dt:type="string" />  
   <ElementType name="City" dt:type="string" />  
  
   <ElementType name="ROOT" sql:is-constant="1">  
      <element type="Customers" />  
   </ElementType>  
  
   <ElementType name="Customers"  sql:relation="Cust" >  
      <element type="CustomerID"  sql:field="CustomerID" />  
      <element type="CompanyName" sql:field="CompanyName" />  
      <element type="City"        sql:field="City" />  
  
   </ElementType>  
</Schema>

B. Hromadné načítání XML dat ve více tabulkách

V tomto příkladu XML dokument obsahuje <prvky Zákazník> a <Objednávka> .

<ROOT>  
  <Customers>  
    <CustomerID>1111</CustomerID>  
    <CompanyName>Sean Chai</CompanyName>  
    <City>NY</City>  
    <Order OrderID="1" />  
    <Order OrderID="2" />  
  </Customers>  
  <Customers>  
    <CustomerID>1112</CustomerID>  
    <CompanyName>Tom Johnston</CompanyName>  
     <City>LA</City>    
    <Order OrderID="3" />  
  </Customers>  
  <Customers>  
    <CustomerID>1113</CustomerID>  
    <CompanyName>Institute of Art</CompanyName>  
    <Order OrderID="4" />  
  </Customers>  
</ROOT>

Tento příklad hromadně načítá XML data do dvou tabulek, Cust a CustOrder:

Cust(CustomerID, název firmy, město)
CustOrder(OrderID, CustomerID)

Následující schéma XSD definuje XML zobrazení těchto tabulek. Schéma specifikuje vztah rodič-dítě mezi <prvky Zákazník> a <Objednávka> .

<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="ROOT" sql:is-constant="1" >  
    <xsd:complexType>  
      <xsd:sequence>  
        <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:sequence>  
    </xsd:complexType>  
  </xsd:element>  
</xsd:schema>

XML Bulk Load využívá výše uvedený vztah primárního klíče/cizího klíče mezi <prvky Cust> a <CustOrder> k hromadnému načtení dat do obou tabulek.

Pro testování vzorku hromadného zatížení

Vytvořte dvě tabulky v databázi tempdb :

USE tempdb;  
CREATE TABLE Cust(  
       CustomerID  int PRIMARY KEY,  
       CompanyName varchar(20),  
       City        varchar(20));  
CREATE TABLE CustOrder(        OrderID     int PRIMARY KEY,   
        CustomerID int FOREIGN KEY REFERENCES Cust(CustomerID));

Vytvořte soubor ve svém oblíbeném textovém nebo XML editoru a uložte ho jako SampleSchema.xml. Přidejte do souboru schéma XSD, které je uvedeno v tomto příkladu.
Vytvořte soubor ve svém oblíbeném textovém nebo XML editoru a uložte ho jako SampleData.xml. Přidejte do souboru XML dokument, který byl dříve poskytnut v tomto příkladu.
Vytvořte soubor ve svém preferovaném textovém nebo XML editoru a uložte ho jako ValidateAndBulkload.vbs. Do tohoto souboru přidejte VBScript kód, který je uveden výše na začátku tohoto tématu. Upravte spojovací řetězec tak, aby poskytl odpovídající název serveru a databáze. Specifikujte vhodnou cestu pro soubory, které jsou specifikovány jako parametry metody Execut.
Spusť výše uvedený VBScript kód. XML Bulk Load načítá XML dokument do tabulek Cust a CustOrder.

Toto je ekvivalentní schéma XDR:

  
<Schema xmlns="urn:schemas-microsoft-com:xml-data"   
        xmlns:dt="urn:schemas-microsoft-com:xml:datatypes"    
        xmlns:sql="urn:schemas-microsoft-com:xml-sql" >   
   <ElementType name="CustomerID" dt:type="int" />  
   <ElementType name="CompanyName" dt:type="string" />  
   <ElementType name="City" dt:type="string" />  
  
   <ElementType name="ROOT" sql:is-constant="1">  
      <element type="Customers" />  
   </ElementType>  
  
   <ElementType name="Customers" sql:relation="Cust" >  
      <element type="CustomerID" sql:field="CustomerID" />  
      <element type="CompanyName" sql:field="CompanyName" />  
      <element type="City" sql:field="City" />  
      <element type="Order" >  
<sql:relationship  
                key-relation="Cust"  
                key="CustomerID"  
                foreign-key="CustomerID"  
                foreign-relation="CustOrder" />  
      </element>  
   </ElementType>  
    <ElementType name="Order" sql:relation="CustOrder" >  
      <AttributeType name="OrderID" />  
      <AttributeType name="CustomerID" />  
      <attribute type="OrderID" />  
      <attribute type="CustomerID" />  
    </ElementType>  
</Schema>

C. Použití řetězových vztahů ve schématu pro hromadné načítání XML

Tento příklad ilustruje, jak je vztah M:N specifikovaný v mapovacím schématu využit XML Bulk Load k načtení dat v tabulce reprezentující vztah M:N.

Představte si například toto schéma XSD:

<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="OrderOD"  
          parent="Ord"  
          parent-key="OrderID"  
          child="OrderDetail"  
          child-key="OrderID" />  
  
    <sql:relationship name="ODProduct"  
          parent="OrderDetail"  
          parent-key="ProductID"  
          child="Product"  
          child-key="ProductID"   
          inverse="true"/>  
  </xsd:appinfo>  
</xsd:annotation>  
  
  <xsd:element name="ROOT" sql:is-constant="1" >  
    <xsd:complexType>  
      <xsd:sequence>  
        <xsd:element name="Order"   
                     sql:relation="Ord"   
                     sql:key-fields="OrderID" >  
          <xsd:complexType>  
            <xsd:sequence>  
             <xsd:element name="Product"  
                          sql:relation="Product"   
                          sql:key-fields="ProductID"  
                          sql:relationship="OrderOD ODProduct">  
               <xsd:complexType>  
                 <xsd:attribute name="ProductID" type="xsd:int" />  
                 <xsd:attribute name="ProductName" type="xsd:string" />  
               </xsd:complexType>  
             </xsd:element>  
           </xsd:sequence>  
           <xsd:attribute name="OrderID"   type="xsd:integer" />   
           <xsd:attribute name="CustomerID"   type="xsd:string" />  
         </xsd:complexType>  
       </xsd:element>  
      </xsd:sequence>  
    </xsd:complexType>  
  </xsd:element>  
</xsd:schema>

Schéma specifikuje prvek <Order>s<> produktovým potomkem. Prvek <Order> mapuje tabulku Ord a <element Product> mapuje tabulku Product v databázi. Řetězový vztah specifikovaný na elementu <produktu> identifikuje vztah M:N reprezentovaný tabulkou OrderDetail. (Objednávka může obsahovat mnoho produktů a produkt může být zahrnut v mnoha objednávkách.)

Když hromadně načítáte XML dokument s tímto schématem, záznamy se přidávají do tabulek Ord, Product a OrderDetail.

Pro testování pracovního vzorku

Vytvořte tři tabulky:

CREATE TABLE Ord (  
         OrderID     int  PRIMARY KEY,  
         CustomerID  varchar(5));  
GO  
CREATE TABLE Product (  
         ProductID   int PRIMARY KEY,  
         ProductName varchar(20));  
GO  
CREATE TABLE OrderDetail (  
       OrderID     int FOREIGN KEY REFERENCES Ord(OrderID),  
       ProductID   int FOREIGN KEY REFERENCES Product(ProductID),  
                   CONSTRAINT OD_key PRIMARY KEY (OrderID, ProductID));  
GO

Uložte schéma, které je uvedeno výše v tomto příkladu, jako SampleSchema.xml.

Uložte následující ukázková XML data jako SampleXMLData.xml:

<ROOT>    
  <Order OrderID="1" CustomerID="ALFKI">  
    <Product ProductID="1" ProductName="Chai" />  
    <Product ProductID="2" ProductName="Chang" />  
  </Order>  
  <Order OrderID="2" CustomerID="ANATR">  
    <Product ProductID="3" ProductName="Aniseed Syrup" />  
    <Product ProductID="4" ProductName="Gumbo Mix" />  
  </Order>  
</ROOT>

Vytvořte soubor ve svém preferovaném textovém nebo XML editoru a uložte ho jako ValidateAndBulkload.vbs. Do tohoto souboru přidejte VBScript kód, který je uveden výše na začátku tohoto tématu. Upravte spojovací řetězec tak, aby poskytl odpovídající název serveru a databáze. Pro tento příklad odkomentujte následující řádky ze zdrojového kódu.
```
objBL.CheckConstraints = True  
objBL.Transaction=True  
```
Spuskutěte VBScript kód. XML Bulk Load načítá XML dokument do tabulek Ord a Product.

D. Hromadné načítání ve sloupcích typu identity

Tento příklad ilustruje, jak hromadné načítání zpracovává sloupce identitních typů. V příkladu jsou data hromadně načtena do tří tabulek (Ord, Produkt a OrderDetail).

V těchto tabulkách:

OrderID v tabulce Ord je sloupec typu identity
ProductID v tabulce Product je sloupec typu identity.
Sloupce OrderID a ProductID v OrderDetail jsou sloupce cizích klíčů, které odkazují na odpovídající sloupce primárních klíčů v tabulkách Ord a Product.

Následující jsou tabulková schémata pro tento příklad:

Ord (OrderID, CustomerID)  
Product (ProductID, ProductName)  
OrderDetail (OrderID, ProductID)

V tomto příkladu XML Bulk Load je vlastnost KeepIdentity objektového modelu BulkLoad nastavena na false. Proto SQL Server generuje hodnoty identity pro sloupce ProductID a OrderID v tabulkách Product a Ord (všechny hodnoty uvedené v dokumentech pro hromadné načítání jsou ignorovány).

V tomto případě XML Bulk Load identifikuje vztah primárního klíče a cizího klíče mezi tabulkami. Hromadné načítání nejprve vloží záznamy do tabulek s primárním klíčem, poté propaguje identitní hodnotu generovanou SQL Serverem do tabulek s sloupci cizího klíče. V následujícím příkladu XML Bulk Load vkládá data do tabulek v tomto pořadí:

Product
Ord
OrderDetail

Poznámka:

Pro šíření identitních hodnot generovaných v tabulkách Produkty a Objednávky vyžaduje logika zpracování XML Bulk Load, aby tyto hodnoty byly sledovány pro pozdější vložení do tabulky OrderDetails. K tomu XML Bulk Load vytváří mezilehlé tabulky, vyplní data v těchto tabulkách a později je odstraní.

Pro testování pracovního vzorku

Vytvořte tyto tabulky:

CREATE TABLE Ord (  
         OrderID     int identity(1,1)  PRIMARY KEY,  
         CustomerID  varchar(5));  
GO  
CREATE TABLE Product (  
         ProductID   int identity(1,1) PRIMARY KEY,  
         ProductName varchar(20));  
GO  
CREATE TABLE OrderDetail (  
       OrderID     int FOREIGN KEY REFERENCES Ord(OrderID),  
       ProductID   int FOREIGN KEY REFERENCES Product(ProductID),  
                   CONSTRAINT OD_key PRIMARY KEY (OrderID, ProductID));  
GO

Vytvořte soubor ve svém oblíbeném textovém nebo XML editoru a uložte ho jako SampleSchema.xml. Přidejte toto schéma XSD do tohoto souboru.

<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="OrderOD"  
          parent="Ord"  
          parent-key="OrderID"  
          child="OrderDetail"  
          child-key="OrderID" />  
    <sql:relationship name="ODProduct"  
          parent="OrderDetail"  
          parent-key="ProductID"  
          child="Product"  
          child-key="ProductID"   
          inverse="true"/>  
   </xsd:appinfo>  
 </xsd:annotation>  

  <xsd:element name="Order" sql:relation="Ord"   
                            sql:key-fields="OrderID" >  
   <xsd:complexType>  
     <xsd:sequence>  
        <xsd:element name="Product" sql:relation="Product"   
                     sql:key-fields="ProductID"  
                     sql:relationship="OrderOD ODProduct">  
          <xsd:complexType>  
             <xsd:attribute name="ProductID" type="xsd:int" />  
             <xsd:attribute name="ProductName" type="xsd:string" />  
          </xsd:complexType>  
        </xsd:element>  
     </xsd:sequence>  
        <xsd:attribute name="OrderID"   type="xsd:integer" />   
        <xsd:attribute name="CustomerID"   type="xsd:string" />  
    </xsd:complexType>  
  </xsd:element>  
</xsd:schema>

Vytvořte soubor ve svém oblíbeném textovém nebo XML editoru a uložte ho jako SampleXMLData.xml. Přidejte následující XML dokument.

<ROOT>    
  <Order OrderID="11" CustomerID="ALFKI">  
    <Product ProductID="11" ProductName="Chai" />  
    <Product ProductID="22" ProductName="Chang" />  
  </Order>  
  <Order OrderID="22" CustomerID="ANATR">  
     <Product ProductID="33" ProductName="Aniseed Syrup" />  
    <Product ProductID="44" ProductName="Gumbo Mix" />  
  </Order>  
</ROOT>

Vytvořte soubor ve svém preferovaném textovém nebo XML editoru a uložte ho jako ValidateAndBulkload.vbs. Do tohoto souboru přidejte následující kód VBScript. Upravte spojovací řetězec tak, aby poskytl odpovídající název serveru a databáze. Zadejte vhodnou cestu pro soubory, které slouží jako parametry metody Execut .

Set objBL = CreateObject("SQLXMLBulkLoad.SQLXMLBulkload.4.0")  
objBL.ConnectionString = "provider=SQLOLEDB;data source=localhost;database=tempdb;integrated security=SSPI"  
objBL.ErrorLogFile = "C:\error.log"  
objBL.CheckConstraints = True  
objBL.Transaction = False  
objBL.KeepIdentity = False  
objBL.Execute "SampleSchema.xml", "SampleXMLData.xml"  
Set objBL = Nothing  
MsgBox "Done."

Spuskutěte VBScript kód. XML hromadné načítání načte data do příslušných tabulek.

E. Generování schémat tabulek před hromadným načítáním

XML Bulk Load může volitelně generovat tabulky, pokud neexistují, před hromadným načítáním. Nastavení vlastnosti SchemaGen objektu SQLXMLBulkLoad na TRUE to způsobí. Můžete také volitelně požádat XML Bulk Load, aby se odstranily existující tabulky a znovu je vytvořily nastavením vlastnosti SGDropTables na TRUE. Následující příklad VBScriptu ilustruje využití těchto vlastností.

Tento příklad také nastavuje dvě další vlastnosti na TRUE:

CheckConstraints. Nastavení této vlastnosti na TRUE zajišťuje, že data vkládaná do tabulek neporušují žádná omezení specifikovaná v tabulkách (v tomto případě omezení PRIMARY KEY/FOREIGN KEY určená mezi tabulkami Cust a CustOrder). Pokud dojde k porušení omezení, hromadné zatížení selže.
XMLFragment. Tato vlastnost musí být nastavena na TRUE, protože vzorový XML dokument (datový zdroj) neobsahuje žádný jediný vrcholný prvek (a je tedy fragmentem).

Toto je kód VBScript:

Dim objBL   
Set objBL = CreateObject("SQLXMLBulkLoad.SQLXMLBulkload.4.0")  
objBL.ConnectionString = "provider=SQLOLEDB;data source=localhost;database=tempdb;integrated security=SSPI"  
objBL.ErrorLogFile = "c:\error.log"  
  
objBL.CheckConstraints=true  
objBL.XMLFragment = True  
objBL.SchemaGen = True  
objBL.SGDropTables = True  
  
objBL.Execute "SampleSchema.xml", "SampleXMLData.xml"  
Set objBL = Nothing

Pro testování pracovního vzorku

Vytvořte soubor ve svém oblíbeném textovém nebo XML editoru a uložte ho jako SampleSchema.xml. Přidejte do souboru schéma XSD, které je uvedeno v předchozím příkladu "Použití řetězových vztahů ve schématu pro hromadné načítání XML".
Vytvořte soubor ve svém oblíbeném textovém nebo XML editoru a uložte ho jako SampleXMLData.xml. Přidejte do souboru XML dokument uvedený v předchozím příkladu "Použití řetězových vztahů ve schématu pro hromadné načítání XML". Odstraňte z dokumentu kořenový prvek <> (aby se stal fragmentem).
Vytvořte soubor ve svém preferovaném textovém nebo XML editoru a uložte ho jako ValidateAndBulkload.vbs. Do tohoto souboru přidejte kód VBScript v tomto příkladu. Upravte spojovací řetězec tak, aby poskytl odpovídající název serveru a databáze. Specifikujte vhodnou cestu pro soubory, které jsou specifikovány jako parametry metody Execut.
Spuskutěte VBScript kód. XML Bulk Load vytváří potřebné tabulky na základě poskytnutého mapovacího schématu a hromadně načítá data do nich.

F. Hromadné nakládání z potoka

Metoda Execute v modelu objektu XML Bulk Load má dva parametry. Prvním parametrem je soubor mapovacího schématu. Druhý parametr poskytuje XML data, která mají být načtena do databáze. Existují dva způsoby, jak předat XML data metodě Execute XML Bulk Load:

Zadejte název souboru jako parametr.
Předejte stream, který obsahuje XML data.

Tento příklad ukazuje, jak hromadně načítat ze streamu.

VBScript nejprve spustí příkaz SELECT pro získání informací o zákazníkovi z tabulky Customers v databázi Northwind. Protože je XML klauzule FOR specifikována (s volbou ELEMENTS) v příkazu SELECT, dotaz vrací element-centrický XML dokument tohoto tvaru:

<Customer>  
  <CustomerID>..</CustomerID>  
  <CompanyName>..</CompanyName>  
  <City>..</City>  
</Customer>  
...

Skript pak předá XML jako proud metodě Execute jako druhému parametru. Metoda Execute hromadně načítá data do tabulky Cust.

Protože tento skript nastavuje vlastnost SchemaGen na TRUE a vlastnost SGDropTables na TRUE, XML Bulk Load vytváří tabulku Cust ve specifikované databázi. (Pokud už tabulka existuje, nejprve ji upustí a pak ji znovu vytvoří.)

Toto je příklad VBScript:

Set objBL = CreateObject("SQLXMLBulkLoad.SQLXMLBulkload.4.0")  
Set objCmd = CreateObject("ADODB.Command")  
Set objConn = CreateObject("ADODB.Connection")  
Set objStrmOut = CreateObject ("ADODB.Stream")  
  
objBL.ConnectionString = "provider=SQLOLEDB;data source=localhost;database=tempdb;integrated security=SSPI"  
objBL.ErrorLogFile     = "c:\error.log"  
objBL.CheckConstraints = True  
objBL.SchemaGen        = True  
objBL.SGDropTables     = True  
objBL.XMLFragment      = True  
' Open a connection to the instance of SQL Server to get the source data.  
  
objConn.Open "provider=SQLOLEDB;server=(local);database=tempdb;integrated security=SSPI"  
Set objCmd.ActiveConnection = objConn  
objCmd.CommandText = "SELECT CustomerID, CompanyName, City FROM Customers FOR XML AUTO, ELEMENTS"  
  
' Open the return stream and execute the command.  
Const adCRLF = -1  
Const adExecuteStream = 1024  
objStrmOut.Open  
objStrmOut.LineSeparator = adCRLF  
objCmd.Properties("Output Stream").Value = objStrmOut  
objCmd.Execute , , adExecuteStream  
objStrmOut.Position = 0  
  
' Execute bulk load. Read source XML data from the stream.  
objBL.Execute "SampleSchema.xml", objStrmOut  
  
Set objBL = Nothing

Následující schéma mapování XSD poskytuje potřebné informace pro vytvoření tabulky:

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"  
            xmlns:sql="urn:schemas-microsoft-com:mapping-schema">  
<xsd:element name="ROOT" sql:is-constant="true" >  
  <xsd:complexType>  
    <xsd:sequence>  
      <xsd:element ref="Customers"/>  
    </xsd:sequence>  
  </xsd:complexType>  
</xsd:element>  
<xsd:element name="Customers" sql:relation="Cust" >  
  <xsd:complexType>  
    <xsd:sequence>  
      <xsd:element name="CustomerID"  
                   type="xsd:string"  
                   sql:datatype="nvarchar(5)"/>  
      <xsd:element name="CompanyName"  
                   type="xsd:string"  
                   sql:datatype="nvarchar(40)"/>  
      <xsd:element name="City"  
                   type="xsd:string"  
                   sql:datatype="nvarchar(40)"/>  
    </xsd:sequence>  
  </xsd:complexType>  
</xsd:element>  
</xsd:schema>

Toto je ekvivalentní XDR schéma:

<?xml version="1.0" ?>  
<Schema xmlns="urn:schemas-microsoft-com:xml-data"   
        xmlns:dt="urn:schemas-microsoft-com:xml:datatypes"    
        xmlns:sql="urn:schemas-microsoft-com:xml-sql" >  
   <ElementType name="CustomerID" dt:type="int" />  
   <ElementType name="CompanyName" dt:type="string" />  
   <ElementType name="City" dt:type="string" />  
  
   <ElementType name="root" sql:is-constant="1">  
      <element type="Customers" />  
   </ElementType>  
  
   <ElementType name="Customers" sql:relation="Cust"  >  
      <element type="CustomerID" sql:field="CustomerID" />  
      <element type="CompanyName" sql:field="CompanyName" />  
      <element type="City" sql:field="City" />  
    </ElementType>  
</Schema>

Otevření streamu na existujícím souboru

Můžete také otevřít stream na existujícím XML datovém souboru a předat stream jako parametr metodě Execute (místo předávání názvu souboru jako parametru).

Toto je příklad z Visual Basic, kdy se proud předá jako parametr:

Private Sub Form_Load()  
Dim objBL As New SQLXMLBulkLoad  
Dim objStrm As New ADODB.Stream  
Dim objFileSystem As New Scripting.FileSystemObject  
Dim objFile As Scripting.TextStream  
  
MsgBox "Begin BulkLoad..."  
objBL.ConnectionString = "provider=SQLOLEDB;data source=localhost;database=tempdb;integrated security=SSPI"  
objBL.ErrorLogFile = "c:\error.log"  
objBL.CheckConstraints = True  
objBL.SchemaGen = True  
objBL.SGDropTables = True  
' Here again a stream is specified that contains the source data   
' (instead of the file name). But this is just an illustration.  
' Usually this is useful if you have an XML data   
' stream that is created by some other means that you want to bulk   
' load. This example starts with an XML text file, so it may not be the   
' best to use a stream (you can specify the file name directly).  
' Here you could have specified the file name itself.   
Set objFile = objFileSystem.OpenTextFile("c:\SampleData.xml")  
objStrm.Open  
objStrm.WriteText objFile.ReadAll  
objStrm.Position = 0  
objBL.Execute "c:\SampleSchema.xml", objStrm  
  
Set objBL = Nothing  
MsgBox "Done."  
End Sub

Pro testování aplikace použijte následující XML dokument v souboru (SampleData.xml) a schéma XSD, které je uvedeno v tomto příkladu:

Toto jsou zdrojová data XML (SampleData.xml):

<ROOT>  
  <Customers>  
    <CustomerID>1111</CustomerID>  
    <CompanyName>Hanari Carnes</CompanyName>  
    <City>NY</City>  
    <Order OrderID="1" />  
    <Order OrderID="2" />  
  </Customers>  
  
  <Customers>  
    <CustomerID>1112</CustomerID>  
    <CompanyName>Toms Spezialitten</CompanyName>  
     <City>LA</City>  
    <Order OrderID="3" />  
  </Customers>  
  <Customers>  
    <CustomerID>1113</CustomerID>  
    <CompanyName>Victuailles en stock</CompanyName>  
    <Order CustomerID= "4444" OrderID="4" />  
</Customers>  
</ROOT>

Toto je ekvivalentní schéma XDR:

<?xml version="1.0" ?>  
<Schema xmlns="urn:schemas-microsoft-com:xml-data"   
        xmlns:dt="urn:schemas-microsoft-com:xml:datatypes"    
        xmlns:sql="urn:schemas-microsoft-com:xml-sql" >  
  
    <ElementType name="Order" sql:relation="CustOrder" >  
      <AttributeType name="OrderID" />  
      <AttributeType name="CustomerID" />  
      <attribute type="OrderID" />  
      <attribute type="CustomerID" />  
    </ElementType>  
  
   <ElementType name="CustomerID" dt:type="int" />  
   <ElementType name="CompanyName" dt:type="string" />  
   <ElementType name="City" dt:type="string" />  
  
   <ElementType name="root" sql:is-constant="1">  
      <element type="Customers" />  
   </ElementType>  
  
   <ElementType name="Customers" sql:relation="Cust"  >  
      <element type="CustomerID" sql:field="CustomerID" />  
      <element type="CompanyName" sql:field="CompanyName" />  
      <element type="City" sql:field="City" />  
      <element type="Order" >  
             <sql:relationship  
                key-relation="Cust"  
                key="CustomerID"  
                foreign-key="CustomerID"  
                foreign-relation="CustOrder" />  
      </element>  
   </ElementType>  
</Schema>

G. Hromadné zatížení v přepadových sloupcích

Pokud mapovací schéma specifikuje sloupec přetečení pomocí sql :overflow-pole anotace, XML Bulk Load zkopíruje všechna nevyužitá data ze zdrojového dokumentu do tohoto sloupce.

Uvažujme toto schéma XSD:

<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"  
                                sql:overflow-field="OverflowColumn" >  
   <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:attribute name="CustomerID" type="xsd:integer" />  
         </xsd:complexType>  
       </xsd:element>  
     </xsd:sequence>  
    </xsd:complexType>  
  </xsd:element>  
</xsd:schema>

Schéma identifikuje sloupec přetečení (OverflowColumn) pro tabulku Cust. Výsledkem je, že všechna nevyužitá XML data pro každý <element zákazníka> jsou do tohoto sloupce přidána.

Poznámka:

Všechny abstraktní prvky (prvky, pro které je specifikováno abstraktní="pravda ") a všechny zakázané atributy (atributy, pro které je specifikováno zakázané="pravda") jsou považovány za přetečení pomocí XML Bulk Load a jsou přidány do sloupce přetečení, pokud je uvedeno. (Jinak jsou ignorovány.)

Pro testování pracovního vzorku

Vytvořte dvě tabulky v databázi tempdb :

USE tempdb;  
CREATE TABLE Cust (  
              CustomerID     int         PRIMARY KEY,  
              CompanyName    varchar(20) NOT NULL,  
              City           varchar(20) DEFAULT 'Seattle',  
              OverflowColumn nvarchar(200));  
GO  
CREATE TABLE CustOrder (  
              OrderID    int PRIMARY KEY,  
              CustomerID int FOREIGN KEY   
                             REFERENCES Cust(CustomerID));  
GO

Vytvořte soubor ve svém oblíbeném textovém nebo XML editoru a uložte ho jako SampleSchema.xml. Přidejte do souboru schéma XSD, které je uvedeno v tomto příkladu.

Vytvořte soubor ve svém oblíbeném textovém nebo XML editoru a uložte ho jako SampleXMLData.xml. Přidejte do souboru následující XML dokument:

<ROOT>  
  <Customers>  
    <CustomerID>1111</CustomerID>  
    <CompanyName>Hanari Carnes</CompanyName>  
    <City><![CDATA[NY]]> </City>  
    <Junk>garbage in overflow</Junk>  
    <Order OrderID="1" />  
    <Order OrderID="2" />  
  </Customers>  

  <Customers>  
    <CustomerID>1112</CustomerID>  
    <CompanyName>Toms Spezialitten</CompanyName>  
     <![CDATA[LA]]>   
    <!-- <xyz><address>111 Maple, Seattle</address></xyz>   -->  
    <Order OrderID="3" />  
  </Customers>  
  <Customers>  
    <CustomerID>1113</CustomerID>  
    <CompanyName>Victuailles en stock</CompanyName>  
    <Order OrderID="4" />  
</Customers>  
</ROOT>

Vytvořte soubor ve svém preferovaném textovém nebo XML editoru a uložte ho jako ValidateAndBulkload.vbs. Do tohoto souboru přidejte následující kód Microsoft Visual Basic Scripting Edition (VBScript). Upravte spojovací řetězec tak, aby poskytl odpovídající název serveru a databáze. Specifikujte vhodnou cestu pro soubory, které jsou specifikovány jako parametry metody Execut.
```
set objBL = CreateObject("SQLXMLBulkLoad.SQLXMLBulkload.4.0")  
objBL.ConnectionString = "provider=SQLOLEDB;data source=localhost;database=tempdb;integrated security=SSPI"  
objBL.ErrorLogFile = "c:\error.log"  
objBL.CheckConstraints = True  
objBL.Execute "SampleSchema.xml", "SampleXMLData.xml"  
set objBL=Nothing  
```
Spuskutěte VBScript kód.

Toto je ekvivalentní schéma XDR:

<?xml version="1.0" ?>  
<Schema xmlns="urn:schemas-microsoft-com:xml-data"   
        xmlns:dt="urn:schemas-microsoft-com:xml:datatypes"    
        xmlns:sql="urn:schemas-microsoft-com:xml-sql" >  
  
    <ElementType name="Order" sql:relation="CustOrder" >  
      <AttributeType name="OrderID" />  
      <AttributeType name="CustomerID" />  
      <attribute type="OrderID" />  
      <attribute type="CustomerID" />  
    </ElementType>  
  
   <ElementType name="CustomerID" dt:type="int" />  
   <ElementType name="CompanyName" dt:type="string" />  
   <ElementType name="City" dt:type="string" />  
  
   <ElementType name="root" sql:is-constant="1">  
      <element type="Customers" />  
   </ElementType>  
  
   <ElementType name="Customers" sql:relation="Cust"   
                       sql:overflow-field="OverflowColumn"  >  
      <element type="CustomerID" sql:field="CustomerID" />  
      <element type="CompanyName" sql:field="CompanyName" />  
      <element type="City" sql:field="City" />  
      <element type="Order" >  
             <sql:relationship  
                key-relation="Cust"  
                key="CustomerID"  
                foreign-key="CustomerID"  
                foreign-relation="CustOrder" />  
      </element>  
   </ElementType>  
</Schema>

H. Specifikace cesty k souboru pro dočasné soubory v transakčním režimu

Když hromadně načítáte v režimu transakce (tedy když je vlastnost Transaction nastavena na TRUE), musíte také nastavit vlastnost TempFilePath, pokud platí některá z následujících podmínek:

Načítáte hromadně na vzdálený server.
Chcete použít alternativní lokální disk nebo složku (jinou než cestu určenou proměnnou TEMP prostředí) k ukládání dočasných souborů vytvořených v transakčním režimu.

Například následující VBScript kód hromadně načítá data ze SampleXMLData.xml souboru do databázových tabulek v transakčním režimu. Vlastnost TempFilePath je určena pro nastavení cesty pro dočasné soubory, které jsou generovány v transakčním režimu.

set objBL = CreateObject("SQLXMLBulkLoad.SQLXMLBulkload.4.0")  
objBL.ConnectionString = "provider=SQLOLEDB;data source=localhost;database=tempdb;integrated security=SSPI"  
objBL.ErrorLogFile = "c:\error.log"  
objBL.CheckConstraints = True  
objBL.Transaction=True  
objBL.TempFilePath="\\Server\MyDir"  
objBL.Execute "SampleSchema.xml", "SampleXMLData.xml"  
set objBL=Nothing

Poznámka:

Dočasná cesta k souboru musí být sdílené místo, které je přístupné servisnímu účtu cílové instance SQL Serveru a účtu, který spouští aplikaci hromadného načítání. Pokud nenačítáte hromadně na lokálním serveru, dočasná cesta k souboru musí být cesta k UNC (například \\servername\sharename).

Pro testování pracovního vzorku

Vytvořte tuto tabulku v databázi tempdb :

USE tempdb;  
CREATE TABLE Cust (     CustomerID uniqueidentifier,   
      LastName  varchar(20));  
GO

Vytvořte soubor ve svém oblíbeném textovém nebo XML editoru a uložte ho jako SampleSchema.xml. Přidejte do souboru následující schéma XSD:

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"  
            xmlns:sql="urn:schemas-microsoft-com:mapping-schema">  
  <xsd:element name="ROOT" sql:is-constant="true" >  
    <xsd:complexType>  
      <xsd:sequence>  
        <xsd:element ref="Customers" />  
      </xsd:sequence>  
    </xsd:complexType>  
  </xsd:element>  

  <xsd:element name="Customers" sql:relation="Cust" >  
   <xsd:complexType>  
     <xsd:attribute name="CustomerID"  type="xsd:string" />  
     <xsd:attribute name="LastName" type="xsd:string" />  
   </xsd:complexType>  
  </xsd:element>  
</xsd:schema>

Vytvořte soubor ve svém oblíbeném textovém nebo XML editoru a uložte ho jako SampleXMLData.xml. Přidejte do souboru následující XML dokument:
```
<ROOT>  
<Customers CustomerID="6F9619FF-8B86-D011-B42D-00C04FC964FF"   
           LastName="Smith" />  
</ROOT>  
```
Vytvořte soubor ve svém preferovaném textovém nebo XML editoru a uložte ho jako ValidateAndBulkload.vbs. Do tohoto souboru přidejte následující kód VBScript. Upravte spojovací řetězec tak, aby poskytl odpovídající název serveru a databáze. Specifikujte vhodnou cestu pro soubory, které jsou specifikovány jako parametry metody Execut. Také určete vhodnou cestu pro vlastnost TempFilePath.
```
set objBL = CreateObject("SQLXMLBulkLoad.SQLXMLBulkload.4.0")  
objBL.ConnectionString = "provider=SQLOLEDB;data source=localhost;database=tempdb;integrated security=SSPI"  
objBL.ErrorLogFile = "c:\error.log"  
objBL.CheckConstraints = True  
objBL.Transaction=True  
objBL.TempFilePath="\\server\folder"  
objBL.Execute "SampleSchema.xml", "SampleXMLData.xml"  
set objBL=Nothing  
```

Spuskutěte VBScript kód.

Schéma musí specifikovat odpovídající sql:datatyp pro atribut CustomerID , pokud je hodnota pro CustomerID určena jako GUID obsahující závorky ({ a }), například:

<ROOT>  
<Customers CustomerID="{6F9619FF-8B86-D011-B42D-00C04FC964FF}"   
           LastName="Smith" />  
</ROOT>

Toto je aktualizované schéma:

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"  
            xmlns:sql="urn:schemas-microsoft-com:mapping-schema">  
  <xsd:element name="ROOT" sql:is-constant="true" >  
    <xsd:complexType>  
      <xsd:sequence>  
        <xsd:element ref="Customers" />  
      </xsd:sequence>  
    </xsd:complexType>  
  </xsd:element>  

  <xsd:element name="Customers" sql:relation="Cust" >  
   <xsd:complexType>  
     <xsd:attribute name="CustomerID"  type="xsd:string"   
                    sql:datatype="uniqueidentifier" />  
     <xsd:attribute name="LastName" type="xsd:string" />  
   </xsd:complexType>  
  </xsd:element>  
</xsd:schema>

Když je sql:datatype určen identifikující typ sloupce jako uniqueidentifier, operace hromadného načítání odstraní závorky ({ a }) z hodnoty CustomerID před jejím vložením do sloupce.

Toto je ekvivalentní schéma XDR:

<?xml version="1.0" ?>  
<Schema xmlns="urn:schemas-microsoft-com:xml-data"   
        xmlns:dt="urn:schemas-microsoft-com:datatypes"    
        xmlns:sql="urn:schemas-microsoft-com:xml-sql" >  
<ElementType name="ROOT" sql:is-constant="1">  
      <element type="Customers" />  
</ElementType>  
<ElementType name="Customers" sql:relation="Cust" >  
  <AttributeType name="CustomerID"  sql:datatype="uniqueidentifier" />  
  <AttributeType name="LastName"   />  
  
  <attribute type="CustomerID" />  
  <attribute type="LastName"   />  
</ElementType>  
</Schema>

I. Použití existujícího databázového spojení s vlastností ConnectionCommand

Můžete použít existující ADO připojení k hromadnému načtení XML. To je užitečné, pokud je XML Bulk Load jen jednou z mnoha operací, které budou prováděny na datovém zdroji.

Vlastnost ConnectionCommand vám umožňuje použít existující ADO spojení pomocí ADO příkazového objektu. To je znázorněno v následujícím příkladu Visual Basic:

Private Sub Form_Load()  
Dim objBL As New SQLXMLBulkLoad4  
Dim objCmd As New ADODB.Command  
Dim objConn As New ADODB.Connection  
  
'Open a connection to an instance of SQL Server.  
objConn.Open "provider=SQLOLEDB;data source=(local);database=tempdb;integrated security=SSPI"  
'Ask the Command object to use the connection just established.  
Set objCmd.ActiveConnection = objConn  
  
'Tell Bulk Load to use the active command object that is using the Connection obj.  
objBL.ConnectionCommand = objCmd  
objBL.ErrorLogFile = "c:\error.log"  
objBL.CheckConstraints = True  
'The Transaction property must be set to True if you use ConnectionCommand.  
objBL.Transaction = True  
objBL.Execute "SampleSchema.xml", "SampleXMLData.xml"  
Set objBL = Nothing  
End Sub

Pro testování pracovního vzorku

Vytvořte dvě tabulky v databázi tempdb :

USE tempdb;  
CREATE TABLE Cust(  
               CustomerID   varchar(5) PRIMARY KEY,  
               CompanyName  varchar(30),  
               City         varchar(20));  
GO  
CREATE TABLE CustOrder(  
               CustomerID  varchar(5) references Cust (CustomerID),  
               OrderID     varchar(5) PRIMARY KEY);  
GO

Vytvořte soubor ve svém oblíbeném textovém nebo XML editoru a uložte ho jako SampleSchema.xml. Přidejte do souboru následující schéma XSD:

<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="ROOT" sql:is-constant="true" >  
    <xsd:complexType>  
      <xsd:sequence>  
        <xsd:element ref="Customers" />  
      </xsd:sequence>  
    </xsd:complexType>  
  </xsd:element>  
  <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:attribute name="CustomerID" type="xsd:integer" />  
         </xsd:complexType>  
       </xsd:element>  
     </xsd:sequence>  
    </xsd:complexType>  
  </xsd:element>  
</xsd:schema>

Vytvořte soubor ve svém oblíbeném textovém nebo XML editoru a uložte ho jako SampleXMLData.xml. Přidejte do souboru následující XML dokument:

<ROOT>  
  <Customers>  
    <CustomerID>1111</CustomerID>  
    <CompanyName>Hanari Carnes</CompanyName>  
    <City>NY</City>  
    <Order OrderID="1" />  
    <Order OrderID="2" />  
  </Customers>  

  <Customers>  
    <CustomerID>1112</CustomerID>  
    <CompanyName>Toms Spezialitten</CompanyName>  
     <City>LA</City>  
    <Order OrderID="3" />  
  </Customers>  
  <Customers>  
    <CustomerID>1113</CustomerID>  
    <CompanyName>Victuailles en stock</CompanyName>  
    <Order OrderID="4" />  
</Customers>  
</ROOT>

Vytvořte aplikaci ve Visual Basicu (Standard EXE) a předchozí kód. Přidejte tyto odkazy do projektu:

Microsoft XML BulkLoad for SQL Server 4.0 Type Library  
Microsoft ActiveX Data objects 2.6 Library

Spusťte aplikaci.

Toto je ekvivalentní schéma XDR:

<?xml version="1.0" ?>  
<Schema xmlns="urn:schemas-microsoft-com:xml-data"   
        xmlns:dt="urn:schemas-microsoft-com:xml:datatypes"    
        xmlns:sql="urn:schemas-microsoft-com:xml-sql" >  
  
   <ElementType name="CustomerID" dt:type="int" />  
   <ElementType name="CompanyName" dt:type="string" />  
   <ElementType name="City" dt:type="string" />  
  
   <ElementType name="root" sql:is-constant="1">  
      <element type="Customers" />  
   </ElementType>  
  
   <ElementType name="Customers" sql:relation="Cust"  >  
      <element type="CustomerID" sql:field="CustomerID" />  
      <element type="CompanyName" sql:field="CompanyName" />  
      <element type="City" sql:field="City" />  
      <element type="Order" >  
         <sql:relationship  
                key-relation="Cust"  
                key="CustomerID"  
                foreign-key="CustomerID"  
                foreign-relation="CustOrder" />  
      </element>  
   </ElementType>  
    <ElementType name="Order" sql:relation="CustOrder" >  
      <AttributeType name="OrderID" />  
      <AttributeType name="CustomerID" />  
      <attribute type="OrderID" />  
      <attribute type="CustomerID" />  
    </ElementType>  
</Schema>

J. Hromadné načítání ve sloupcích XML datových typů

Pokud mapovací schéma specifikuje sloupec XML datového typu pomocí anotace sql:datatype="xml", XML Bulk Load může zkopírovat XML podprvky pro mapované pole ze zdrojového dokumentu do tohoto sloupce.

Zvažte následující schéma XSD, které mapuje pohled na tabulku Production.ProductModel v databázi AdventureWorks. V této tabulce je pole CatalogDescription xml datového typu mapováno na prvek <Desc> pomocí anotací sql:field a sql:datatype="xml".

<?xml version="1.0" encoding="utf-8" ?>  
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"   
           xmlns:sql="urn:schemas-microsoft-com:mapping-schema"  
           xmlns="http://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelDescription">   
  <xsd:element name="ProductModel"  sql:relation="Production.ProductModel" >  
    <xsd:complexType>  
      <xsd:sequence>  
        <xsd:element name="Name" type="xs:string"></xsd:element>  
        <xsd:element name="Desc" sql:field="CatalogDescription" sql:datatype="xml">  
        <xsd:complexType>  
          <xsd:sequence>  
            <xsd:element name="ProductDescription">  
              <xsd:complexType>  
                <xsd:sequence>  
                  <xsd:element name="Summary" type="xs:anyType"/>  
                </xsd:sequence>  
              </xsd:complexType>  
            </xsd:element>  
          </xsd:sequence>  
        </xsd:complexType>  
        </xsd:element>   
     </xsd:sequence>  
     <xsd:attribute name="ProductModelID" sql:field="ProductModelID" />  
    </xsd:complexType>  
  </xsd:element>  
</xsd:schema>

Pro testování pracovního vzorku

Ověřte, že je nainstalována ukázková databáze AdventureWorks.
Vytvořte soubor ve svém oblíbeném textovém nebo XML editoru a uložte ho jako SampleSchema.xml. Zkopírujte výše uvedené schéma XSD, vložte ho do souboru a uložte.

Vytvořte soubor ve svém oblíbeném textovém nebo XML editoru a uložte ho jako SampleXMLData.xml. Zkopírujte následující XML dokument níže, vložte jej do souboru a uložite do stejné složky, kde byl použit v předchozím kroku.

<ProductModel ProductModelID="2005">  
    <Name>Mountain-100 (2005 model)</Name>  
    <Desc><?xml-stylesheet href="ProductDescription.xsl" type="text/xsl"?>  
        <p1:ProductDescription xmlns:p1="https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelDescription"   
              xmlns:wm="https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelWarrAndMain"   
              xmlns:wf="https://www.adventure-works.com/schemas/OtherFeatures"   
              xmlns:html="http://www.w3.org/1999/xhtml"   
              xmlns="">  
            <p1:Summary>  
                <html:p>Our top-of-the-line competition mountain bike.   
      Performance-enhancing options include the innovative HL Frame,   
      super-smooth front suspension, and traction for all terrain.  
                        </html:p>  
            </p1:Summary>  
            <p1:Manufacturer>  
                <p1:Name>AdventureWorks</p1:Name>  
                <p1:Copyright>2002-2005</p1:Copyright>  
                <p1:ProductURL>HTTP://www.Adventure-works.com</p1:ProductURL>  
            </p1:Manufacturer>  
            <p1:Features>These are the product highlights.   
                 <wm:Warranty>  
                    <wm:WarrantyPeriod>3 years</wm:WarrantyPeriod>  
                    <wm:Description>parts and labor</wm:Description>  
                </wm:Warranty><wm:Maintenance>  
                    <wm:NoOfYears>10 years</wm:NoOfYears>  
                    <wm:Description>maintenance contract available through your dealer or any AdventureWorks retail store.</wm:Description>  
                </wm:Maintenance><wf:wheel>High performance wheels.</wf:wheel><wf:saddle>  
                    <html:i>Anatomic design</html:i> and made from durable leather for a full-day of riding in comfort.</wf:saddle><wf:pedal>  
                    <html:b>Top-of-the-line</html:b> clipless pedals with adjustable tension.</wf:pedal><wf:BikeFrame>Each frame is hand-crafted in our Bothell facility to the optimum diameter   
      and wall-thickness required of a premium mountain frame.   
      The heat-treated welded aluminum frame has a larger diameter tube that absorbs the bumps.</wf:BikeFrame><wf:crankset> Triple crankset; aluminum crank arm; flawless shifting. </wf:crankset></p1:Features>  
            <!-- add one or more of these elements... one for each specific product in this product model -->  
            <p1:Picture>  
                <p1:Angle>front</p1:Angle>  
                <p1:Size>small</p1:Size>  
                <p1:ProductPhotoID>118</p1:ProductPhotoID>  
            </p1:Picture>  
            <!-- add any tags in <specifications> -->  
            <p1:Specifications> These are the product specifications.  
                   <Material>Aluminum Alloy</Material><Color>Available in most colors</Color><ProductLine>Mountain bike</ProductLine><Style>Unisex</Style><RiderExperience>Advanced to Professional riders</RiderExperience></p1:Specifications>  
        </p1:ProductDescription>  
    </Desc>  
</ProductModel>

Vytvořte soubor ve svém preferovaném textovém nebo XML editoru a uložte ho jako BulkloadXml.vbs. Zkopírujte následující kód VBScript a vložte jej do souboru. Uložit ho do stejné složky, kde byly použity předchozí XML data a schémata soubory.

set objBL = CreateObject("SQLXMLBulkLoad.SQLXMLBulkload.4.0")  
objBL.ConnectionString = "provider=SQLOLEDB;data source=MyServer;database=AdventureWorks;integrated security=SSPI"  

Dim fso, sAppPath  
Set fso = CreateObject("Scripting.FileSystemObject")   
sAppPath = fso.GetFolder(".")   

objBL.ErrorLogFile = sAppPath & "\error.log"  

'Execute XML bulkload using file.  
objBL.Execute "SampleSchema.xml", "SampleXMLData.xml"  
set objBL=Nothing

Spusť skript BulkloadXml.vbs.

Váš názor

Byla tato stránka užitečná?

Last updated on 2025-12-08

Sdílet prostřednictvím

Příklady hromadného načítání XML (SQLXML 4.0)

Bulk Loader Script (ValidateAndBulkload.vbs)

A. Hromadné načítání XML v tabulce

Pro testování vzorku hromadného zatížení

B. Hromadné načítání XML dat ve více tabulkách

Pro testování vzorku hromadného zatížení

C. Použití řetězových vztahů ve schématu pro hromadné načítání XML

Pro testování pracovního vzorku

D. Hromadné načítání ve sloupcích typu identity

Pro testování pracovního vzorku

E. Generování schémat tabulek před hromadným načítáním

Pro testování pracovního vzorku

F. Hromadné nakládání z potoka

Otevření streamu na existujícím souboru

G. Hromadné zatížení v přepadových sloupcích

Pro testování pracovního vzorku

H. Specifikace cesty k souboru pro dočasné soubory v transakčním režimu

Pro testování pracovního vzorku

I. Použití existujícího databázového spojení s vlastností ConnectionCommand

Pro testování pracovního vzorku

J. Hromadné načítání ve sloupcích XML datových typů

Pro testování pracovního vzorku

Váš názor

Další materiály