Megosztás a következőn keresztül:

XML tömeges betöltési példák (SQLXML 4.0)

A következőkre vonatkozik:SQL ServerAzure SQL Database

Az alábbi példák szemlélteti az XML Bulk Load funkcióját a Microsoft SQL Serverben. Minden példa tartalmaz egy XSD sémát és annak megfelelő XDR sémát.

Bulk Loader Script (ValidateAndBulkload.vbs)

A következő szkript, amelyet a Microsoft Visual Basic Scripting Edition (VBScript) írt, egy XML dokumentumot tölt be az XML DOM-ba; megerősíti egy sémához képest; és ha a dokumentum érvényes, XML tömeges betöltést hajt végre, hogy az XML-t egy SQL Server táblába töltse be. Ez a szkript használható minden egyes példával, amely később hivatkozik rá ebben a témában.

Megjegyzés:

Az XML Bulk Load nem ad figyelmeztetést vagy hibát, ha nem töltik fel tartalmat az adatfájlból. Ezért jó gyakorlat az XML adatfájl érvényesítése a tömeges betöltési művelet végrehajtása előtt.

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. XML tömeges betöltése egy táblában

Ez a példa egy kapcsolatot hoz létre az SQL Server példányával, amelyet a ConnectionString tulajdonság (MyServer) határoz meg. A példa megadja a ErrorLogFile tulajdonságot is. Ezért a hiba kimenete a megadott fájlba kerül ("C:\error.log"), amelyet szintén megváltoztathatsz egy másik helyre. Figyeljük meg azt is, hogy az Execute metódus paraméterei mind a leképezési séma fájlt (SampleSchema.xml), mind az XML adatfájlt (SampleXMLData.xml). Amikor a tömeges betöltés elindul, a tempdb adatbázisban létrehozott Cust tábla új rekordokat fog tartalmazni az XML adatfájl tartalmán alapulva.

Mintatömegterhelés tesztelésére

  1. Hozza létre ezt a táblát:

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

  2. Hozz létre egy fájlt a kedvenc szövegedben vagy XML szerkesztőben, és mentsd SampleSchema.xml. Ehhez a fájlhoz adjuk hozzá a következő XSD sémát:

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

  3. Hozz létre egy fájlt a kedvenc szövegedben vagy XML szerkesztőben, és mentsd SampleXMLData.xml. Ehhez a fájlhoz adjuk hozzá a következő XML dokumentumot:

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

  4. Hozz létre egy fájlt a kedvenc szövegedben vagy XML szerkesztőben, és mentsd el ValidateAndBulkload.vbs néven. Ehhez a fájlhoz add hozzá a fentebb megadott VBScript kódot a téma elején. Módosítsd a kapcsolati láncot a megfelelő szervernév megadására. Határozd meg a megfelelő útvonalat azoknak a fájloknak, amelyek paraméterként vannak megadva az Execute metódushoz.

  5. Hajtsd végre a VBScript kódot. Az XML Bulk Load betölti az XML-t a Cust táblába.

Ez a megfelelő XDR-séma:

  
<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. XML adatok tömeges betöltése több táblába

Ebben a példában az XML dokumentum az <Ügyfél> - és <Rendelés-elemekből> áll.

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

Ez a példa tömegesen betölti az XML adatokat két táblába, Custba és CustOrderbe:

  • Cust(CustomerID, Cégnév, Város)

  • CustOrder(OrderID, CustomerID)

A következő XSD séma határozza meg ezeknek a táblázatoknak az XML nézetét. A séma meghatározza az Ügyfél> és Rendelés elemek közötti szülő-gyermek kapcsolatot<.><

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

Az XML Bulk Load a fent megadott elsődleges kulcs/idegen kulcs kapcsolatot használja a <Cust> és <CustOrder> elemek között, hogy az adatokat tömegesen betöltse mindkét táblába.

Mintatömegterhelés tesztelésére

  1. Hozz létre két táblát a tempdb adatbázisban:

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

  2. Hozz létre egy fájlt a kedvenc szövegedben vagy XML szerkesztőben, és mentsd SampleSchema.xml. Hozzáadjuk a példában található XSD sémát a fájlhoz.

  3. Hozz létre egy fájlt a kedvenc szövegedben vagy XML szerkesztőben, és mentsd SampleData.xml. Hozzáadjuk a korábbi példában megadott XML dokumentumot a fájlhoz.

  4. Hozz létre egy fájlt a kedvenc szövegedben vagy XML szerkesztőben, és mentsd el ValidateAndBulkload.vbs néven. Ehhez a fájlhoz add hozzá a fentebb megadott VBScript kódot a téma elején. Módosítsd a kapcsolati láncsort, hogy megadja a megfelelő szerver- és adatbázisnevet. Határozd meg a megfelelő útvonalat azoknak a fájloknak, amelyek paraméterként vannak megadva az Execute metódushoz.

  5. Hajtsd végre a fenti VBScript kódot. Az XML Bulk Load betölti az XML dokumentumot a Cust és CustOrder táblákba.

Ez a megfelelő XDR-séma:

  
<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. Lánckapcsolatok használata a sémában XML tömeges betöltéséhez

Ez a példa bemutatja, hogyan használja az XML Bulk Load által az M:N kapcsolatot egy olyan táblázatba, amely M:N kapcsolatot ábrázol, az M:N viszonyban megadott M:N viszonyban történő betöltésére.

Vegyük például ezt az XSD-sémát:

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

A séma egy <Order> elemet jelöl meg egy <Product> gyermekelemmel. A< Order> elem az Ord táblához, a <Product> elem pedig az adatbázis Product táblájához leképezi. A Product> elemen megadott< lánckapcsolat egy M:N kapcsolatot jelöl, amelyet a OrderDetail tábla képvisel. (Egy rendelés sok terméket tartalmazhat, és egy termék sok rendelésben is szerepelhet.)

Amikor ezzel a sémával tömegesen töltünk be XML dokumentumot, a rekordokat az Ord, Product és OrderDetail táblákba adják fel.

Egy működő minta teszteléséhez

  1. Hozz létre három táblázatot:

    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

  2. A fenti példában megadott sémát SampleSchema.xml.

  3. A következő XML adat mintaadatokat SampleXMLData.xmlalatt tároljuk:

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

  4. Hozz létre egy fájlt a kedvenc szövegedben vagy XML szerkesztőben, és mentsd el ValidateAndBulkload.vbs néven. Ehhez a fájlhoz add hozzá a fentebb megadott VBScript kódot a téma elején. Módosítsd a kapcsolati láncsort, hogy megadja a megfelelő szerver- és adatbázisnevet. Töröld a következő sorokat a forráskódból ehhez a példához.

    objBL.CheckConstraints = True  
objBL.Transaction=True

  5. Hajtsd végre a VBScript kódot. Az XML Bulk Load betölti az XML dokumentumot az Ord és Product táblákba.

D. Tömeges betöltés identitástípus-oszlopokban

Ez a példa szemlélteti, hogyan kezeli a tömeges terhelés az identitástípusú oszlopokat. A példában az adatok három táblázatba (Ord, Product és OrderDetail) tömve vannak betöltve.

Ezekben a táblázatokban:

  • Az Ord táblában a OrderID egy identitástípus-oszlop

  • A Product ID a Termék táblában egy identitástípus-oszlop.

  • A OrderID és ProductID oszlopok a OrderDetailben idegen kulcsoszlopok, amelyek az Ord és Product táblák megfelelő elsődleges kulcsoszlopaira utalnak.

Az alábbiakban a táblázat sémái láthatók ehhez a példához:

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

Ebben az XML Bulk Load példában a BulkLoad objektummodell KeepIdentity tulajdonsága false-nak van állítva. Ezért az SQL Server identitásértékeket generál a ProductID és OrderID oszlopokhoz a Product és Ord táblákban, rendre (a dokumentumokban megadott értékeket figyelmen kívül hagyják).

Ebben az esetben az XML Bulk Load azonosítja a táblák közötti elsődleges kulcs/idegen kulcs kapcsolatot. A tömeges betöltés először a táblákba helyezi be a rekordokat az elsődleges kulccsal, majd az SQL Server által generált identitásértéket terjeszti az idegen kulcsoszlopokkal rendelkező táblákba. A következő példában az XML Bulk Load az alábbi sorrendben helyezi be az adatokat táblázatokba:

  1. Termék

  2. Ord

  3. OrderDetail

    Megjegyzés:

    Ahhoz, hogy a Termékek és Rendelések táblákban generált identitásértékeket terjesztsék, a feldolgozási logika XML Bulk Load-ra van szükség, hogy nyomon kövesse ezeket az értékeket későbbi OrderDetails táblába való beillesztéshez. Ehhez az XML Bulk Load köztes táblákat hoz létre, feltölti az adatokat ezekben a táblákban, majd később eltávolítja azokat.

Egy működő minta teszteléséhez

  1. Hozza létre a következő táblázatokat:

    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

  2. Hozz létre egy fájlt a kedvenc szövegedben vagy XML szerkesztőben, és mentsd SampleSchema.xml. Hozzáadjuk ezt az XSD sémát ebbe a fájlba.

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

  3. Hozz létre egy fájlt a kedvenc szövegedben vagy XML szerkesztőben, és mentsd SampleXMLData.xml. Add hozzá a következő XML dokumentumot.

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

  4. Hozz létre egy fájlt a kedvenc szövegedben vagy XML szerkesztőben, és mentsd el ValidateAndBulkload.vbs néven. Ehhez a fájlhoz add hozzá a következő VBScript kódot. Módosítsd a kapcsolati láncsort, hogy megadja a megfelelő szerver- és adatbázisnevet. Határozd meg a megfelelő útvonalat azoknak a fájloknak, amelyek paraméterként szolgálnak az Execute metódushoz.

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

  5. Hajtsd végre a VBScript kódot. Az XML Bulk Load betölti az adatokat a megfelelő táblákba.

E. Táblázat sémák generálása tömeges betöltés előtt

Az XML Bulk Load opcionálisan generálhatja a táblákat, ha azok nem léteznek a tömeges betöltés előtt. Az SQLXMLBulkLoad objektum SchemaGen tulajdonságának TRUE-ra állításával ezt megteszi. Opcionálisan kérheted az XML Bulk Load-ot, hogy eltávolítsd a meglévő táblákat és újrahozd őket, ha az SGDropTables tulajdonságot TRUE-ra állítod. A következő VBScript példa szemlélteti ezeknek a tulajdonságoknak a használatát.

Ez a példa két további tulajdonságot is beállít a TRUE-hoz:

  • CheckConstraints. Ennek a tulajdonságnak a TRUE-ra állítása biztosítja, hogy a táblákba beillesztett adatok ne sértsék meg a táblákon meghatározott korlátokat (ebben az esetben a Cust és CustOrder táblák között meghatározott PRIMARY KEY/FOREIGN KEY korlátokat). Ha korlátozás megsértődik, a tömegterhelés meghibásodik.

  • XMLFragment. Ezt a tulajdonságot TRUE-ra kell állítani, mert a mintaXML dokumentum (adatforrás) nem tartalmaz egyetlen, felső szintű elemet (így fragmentum).

Ez a VBScript kód:

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

Egy működő minta teszteléséhez

  1. Hozz létre egy fájlt a kedvenc szövegedben vagy XML szerkesztőben, és mentsd SampleSchema.xml. Add hozzá a korábbi példában szereplő XSD sémát, amely "Lánckapcsolatok a sémában a XML tömeges betöltéséhez" című műsorban szerepel.

  2. Hozz létre egy fájlt a kedvenc szövegedben vagy XML szerkesztőben, és mentsd SampleXMLData.xml. Hozzáadjuk a korábbi példában megadott XML dokumentumot, "Lánckapcsolatok a sémában az XML tömeges betöltéséhez" fájlhoz. Távolítsd el a <ROOT> elemet a dokumentumból (hogy töredék legyen).

  3. Hozz létre egy fájlt a kedvenc szövegedben vagy XML szerkesztőben, és mentsd el ValidateAndBulkload.vbs néven. Ehhez a fájlhoz add hozzá a VBScript kódot ebben a példában. Módosítsd a kapcsolati láncsort, hogy megadja a megfelelő szerver- és adatbázisnevet. Határozd meg a megfelelő útvonalat azoknak a fájloknak, amelyek paraméterként vannak megadva az Execute metódushoz.

  4. Hajtsd végre a VBScript kódot. Az XML Bulk Load a rendelkezésre álló leképezési séma alapján hozza létre a szükséges táblákat, és tömegesen betölti az adatokat.

F. Tömeges betöltés egy patakból

Az XML Bulk Load objektummodell Execute módszere két paramétert igényel. Az első paraméter a leképezési séma fájl. A második paraméter megadja az adatbázisba betöltött XML adatokat. Kétféleképpen lehet átadni az XML adatokat az XML Bulk Load Execute módszeréhez:

  • A fájlnevet paraméterként adjuk meg.

  • Passzolj egy olyan streamet, amely tartalmazza az XML adatokat.

Ez a példa bemutatja, hogyan lehet tömeges terhelést egy folyamból.

A VBScript először egy SELECT utasítást hajt végre, hogy az ügyféladatokat a Northwind adatbázis Ügyfelek táblájából szerezze meg. Mivel a FOR XML záradék meg van jelölve (az ELEMENTS opcióval) a SELECT utasításban, a lekérdezés egy elemközpontú XML dokumentumot ad vissza az alábbi formában:

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

A szkript ezután az XML-t folyamként továbbítja az Execute metódnak második paraméterként. Az Execute metódus tömegesen betölti az adatokat a Cust táblába.

Mivel ez a szkript a SchemaGen tulajdonságot TRUE-ra, SGDropTables tulajdonságot pedig TRUE-ra állítja, az XML Bulk Load létrehozza a Cust táblát a megadott adatbázisban. (Ha a tábla már létezik, először ledobja a táblát, majd újraalkotja.)

Ez a VBScript példa:

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

A következő XSD leképezési séma biztosítja a tábla létrehozásához szükséges információkat:

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

Ez az XDR séma ekvivalens változata:

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

Stream megnyitása egy meglévő fájlon

Megnyithatsz egy streamet egy meglévő XML adatfájlon is, és átadhatod az áramlatot paraméterként az Execute metódusnak (ahelyett, hogy a fájlnevet adnád meg paraméterként).

Ez egy Visual Basic példa arra, hogyan passzol egy áramlatot paraméterként:

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

Az alkalmazás teszteléséhez használja a következő XML dokumentumot egy fájlban (SampleData.xml) és az ebben a példában található XSD sémát:

Ez az XML forrásadat (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>

Ez a megfelelő XDR-sé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="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. Tömeges terhelés túlcsordulás oszlopokban

Ha a leképezési séma a sql:overflow-field annotációval megad egy túlfolyó oszlopot, akkor az XML Bulk Load az összes felmerült adatot a forrásdokumentumból bemásolja ebbe az oszlopba.

Vegyük ezt az XSD sémát:

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

A séma egy túlfolyó oszlopot (OverflowColumn) azonosít a Cust táblához. Ennek eredményeként minden ügyfélelemre> tartozó összes fel nem használt XML-adatot< hozzáadják ebbe az oszlopba.

Megjegyzés:

Minden absztrakt elem (olyan elemek, amelyekhez az abstract="true" meg van jelölve) és minden tiltott attribútumot (olyan attribútumokat, amelyekhez a tilted="true" van megadva) az XML Bulk Load által túlcsordulásnak számít, és ha megadják a túlfolyó oszlopba, ha megadják őket. (Ellenkező esetben figyelmen kívül hagyják őket.)

Egy működő minta teszteléséhez

  1. Hozz létre két táblát a tempdb adatbázisban:

    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

  2. Hozz létre egy fájlt a kedvenc szövegedben vagy XML szerkesztőben, és mentsd SampleSchema.xml. Hozzáadjuk a példában található XSD sémát a fájlhoz.

  3. Hozz létre egy fájlt a kedvenc szövegedben vagy XML szerkesztőben, és mentsd SampleXMLData.xml. Csatoljuk a következő XML dokumentumot a fájlhoz:

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

  4. Hozz létre egy fájlt a kedvenc szövegedben vagy XML szerkesztőben, és mentsd el ValidateAndBulkload.vbs néven. Ehhez a fájlhoz adjuk hozzá a következő Microsoft Visual Basic Scripting Edition (VBScript) kódot. Módosítsd a kapcsolati láncsort, hogy megadja a megfelelő szerver- és adatbázisnevet. Határozd meg a megfelelő útvonalat azoknak a fájloknak, amelyek paraméterként vannak megadva az Execute metódushoz.

    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

  5. Hajtsd végre a VBScript kódot.

Ez a megfelelő XDR-sé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="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. A fájlút meghatározása ideiglenes fájlok tranzakciós módban

Amikor tranzakciós módban tömegesen töltünk (azaz amikor a Transaction tulajdonság TRUE-ra van állítva), akkor is be kell állítanod a TempFilePath tulajdonságot, ha az alábbi feltételek közül bármelyik érvényes:

  • Tömegesen töltesz be egy távoli szerverre.

  • Egy alternatív helyi meghajtót vagy mappát szeretnél használni (nem az út, amit a TEMP környezeti változó jelöl), hogy tárold a tranzakciós módban létrehozott ideiglenes fájlokat.

Például a következő VBScript kód tömegesen tölti be az adatokat a SampleXMLData.xml fájlból az adatbázis tábláiba tranzakciós módban. A TempFilePath tulajdonság úgy van megadva, hogy beállítsa az út az ideiglenes fájlokhoz, amelyek tranzakciós módban generálódnak.

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

Megjegyzés:

Az ideiglenes fájlútnak egy megosztott helynek kell lennie, amely elérhető az SQL Server célpéldányának szolgáltatási fiókjának és a tömeges terhelésű alkalmazást futtató fióknak. Hacsak nem tölt tömegesen egy helyi szerveren, az ideiglenes fájlútnak UNC útnak kell lennie (például \\servername\sharename).

Egy működő minta teszteléséhez

  1. Hozza létre ezt a táblázatot a tempdb adatbázisban:

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

  2. Hozz létre egy fájlt a kedvenc szövegedben vagy XML szerkesztőben, és mentsd SampleSchema.xml. A következő XSD sémát adjuk hozzá a fájlhoz:

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

  3. Hozz létre egy fájlt a kedvenc szövegedben vagy XML szerkesztőben, és mentsd SampleXMLData.xml. Csatoljuk a következő XML dokumentumot a fájlhoz:

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

  4. Hozz létre egy fájlt a kedvenc szövegedben vagy XML szerkesztőben, és mentsd el ValidateAndBulkload.vbs néven. Ehhez a fájlhoz add hozzá a következő VBScript kódot. Módosítsd a kapcsolati láncsort, hogy megadja a megfelelő szerver- és adatbázisnevet. Határozd meg a megfelelő útvonalat azoknak a fájloknak, amelyek paraméterként vannak megadva az Execute metódushoz. Megadjuk a megfelelő útvonalat a TempFilePath tulajdonsághoz is.

    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

  5. Hajtsd végre a VBScript kódot.

    A sémának meg kell határoznia a megfelelő sql:datatype típust a CustomerID attribútumhoz, amikor a CustomerID értéke egy GUID-ként van megadva, amely tartalmaz fogszabályzókat ({ és }), például:

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

    Ez a frissített sé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>

    Amikor a sql:datatype egyedi azonosítóként azonosítja az oszloptípust, a tömeges betöltési művelet eltávolítja a mereveket ({ és }) a CustomerID értékből, mielőtt beillesztené azokat az oszlopba.

Ez a megfelelő XDR-séma:

<?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. Egy meglévő adatbázis-kapcsolat használata a ConnectionCommand tulajdonsággal

Egy meglévő ADO kapcsolatot használhatsz XML-t tömeges betöltéshez. Ez akkor hasznos, ha az XML Bulk Load csak egy a sok adatforráson végrehajtandó művelet közül.

A ConnectionCommand tulajdonság lehetővé teszi, hogy egy meglévő ADO kapcsolatot használj egy ADO parancsobjektum segítségével. Ezt a következő Visual Basic példa szemlélteti:

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

Egy működő minta teszteléséhez

  1. Hozz létre két táblát a tempdb adatbázisban:

    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

  2. Hozz létre egy fájlt a kedvenc szövegedben vagy XML szerkesztőben, és mentsd SampleSchema.xml. A következő XSD sémát adjuk hozzá a fájlhoz:

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

  3. Hozz létre egy fájlt a kedvenc szövegedben vagy XML szerkesztőben, és mentsd SampleXMLData.xml. Csatoljuk a következő XML dokumentumot a fájlhoz:

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

  4. Készíts egy Visual Basic (Standard EXE) alkalmazást és az előző kódot. Ezeket a hivatkozásokat adjuk hozzá a projekthez:

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

  5. Hajtsa végre az alkalmazást.

Ez a megfelelő XDR-sé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" />  
      <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. Tömeges betöltés xml Data Type oszlopokban

Ha a leképezési séma xml adattípus oszlopot ad meg a sql:datatype="xml" annotációval együtt, akkor az XML Bulk Load képes átmásolni a leképezett mező XML gyermekelemeit a forrásdokumentumból ebbe az oszlopba.

Vegyük a következő XSD sémát, amely a Production.ProductModel tábla nézetét térképezi az AdventureWorks mintaadatbázisban. Ebben a táblázatban az xml adattípus CatalogDescription mezője egy Desc> elemhez van leképezve< a sql:field és sql:datatype="xml" annotációk segítségével.

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

Egy működő minta teszteléséhez

  1. Ellenőrizd, hogy az AdventureWorks mintaadatbázis telepítve van-e.

  2. Hozz létre egy fájlt a kedvenc szövegedben vagy XML szerkesztőben, és mentsd SampleSchema.xml. Másold le a fenti XSD sémát, illeszted be a fájlba, és mentsd el.

  3. Hozz létre egy fájlt a kedvenc szövegedben vagy XML szerkesztőben, és mentsd SampleXMLData.xml. Kopiod le az alábbi XML dokumentumot, ragasztod be a fájlba, és elmentsd ugyanabba a mappába, amit az előző lépésnél használtak.

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

  4. Hozz létre egy fájlt a kedvenc szövegedben vagy XML szerkesztőben, és mentsd el BulkloadXml.vbs néven. Másold le a következő VBScript kódot, és illeszted be a fájlba. Mentsék el ugyanabba a mappába, amit az előző XML adatokhoz és sémafájlokhoz használtak.

    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

  5. Futtatd a BulkloadXml.vbs szkriptet.

  • Last updated on