XML 大容量加载示例 (SQLXML 4.0)

项目
04/26/2023

以下示例演示 Microsoft SQL Server 中的 XML 大容量加载功能。每个示例都提供了 XSD 架构及其等效的 XDR 架构。

Bulk Loader 脚本 (ValidateAndBulkload.vbs)

以下脚本在 Microsoft Visual Basic Scripting Edition (VBScript) 中编写，将 XML 文档加载到 XML DOM 中;根据架构验证它;如果文档有效，则执行 XML 大容量加载，将 XML 加载到SQL Server表中。此脚本可用于本主题后面提到它的每个单独示例。

注意

如果未从数据文件中上载任何内容，XML 大容量加载将不引发警告或错误。因此，最好在执行大容量加载操作之前验证您的 XML 数据文件。

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 大容量加载到表中

此示例建立与 SQL Server 实例的连接，该实例在 MyServer) 的 ConnectionString 属性 (指定。该示例还指定 ErrorLogFile 属性。因此，错误输出将保存在指定的文件（“C:\error.log”）中，您也可以决定将其更改为其他位置。另请注意，Execute 方法的参数包括映射架构文件 (SampleSchema.xml) 和 XML 数据文件 (SampleXMLData.xml) 。执行大容量加载时，在 tempdb 数据库中创建的 Cust 表将包含基于 XML 数据文件内容的新记录。

测试示例大容量加载

创建下表：

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

在您首选的文本编辑器或 XML 编辑器中创建文件，然后将其另存为 SampleSchema.xml。在此文件中，添加以下 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>

在您首选的文本编辑器或 XML 编辑器中创建文件，然后将其另存为 SampleXMLData.xml。在此文件中，添加以下 XML 文档：

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

在您首选的文本编辑器或 XML 编辑器中创建文件，然后将其另存为 ValidateAndBulkload.vbs。在此文件中，添加本主题前面开头部分提供的 VBScript 代码。修改连接字符串以提供适当的服务器名称。为指定为 Execute 方法的参数的文件指定适当的路径。
执行 VBScript 代码。 XML 大容量加载会将 XML 加载到 Cust 表中。

这是等效的 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. 将 XML 数据大容量加载到多个表中

在此示例中，XML 文档由 Customer> 和 Order 元素组成<。><

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

此示例将 XML 数据大容量加载到两个表中： Cust 和 CustOrder：

Cust (CustomerID、CompanyName、City)
CustOrder (OrderID、CustomerID)

以下 XSD 架构定义这些表的 XML 视图。架构指定 Customer> 和 Order 元素之间的<父子关系。><

<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 大容量加载使用上面指定的 Cust> 和 CustOrder 元素之间的<主键/外键关系将数据大容量加载到这两个表中。><

测试示例大容量加载

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

在您首选的文本编辑器或 XML 编辑器中创建文件，然后将其另存为 SampleSchema.xml。将在本示例中提供的 XSD 架构添加到此文件中。
在您首选的文本编辑器或 XML 编辑器中创建文件，然后将其另存为 SampleData.xml。将在本示例前面提供的 XML 文档添加到此文件中。
在您首选的文本编辑器或 XML 编辑器中创建文件，然后将其另存为 ValidateAndBulkload.vbs。在此文件中，添加本主题前面开头部分提供的 VBScript 代码。修改连接字符串以提供适当的服务器和数据库名称。为指定为 Execute 方法的参数的文件指定适当的路径。
执行上面的 VBScript 代码。 XML 大容量加载会将 XML 文档加载到 Cust 表和 CustOrder 表中。

这是等效的 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. 使用架构中的链关系大容量加载 XML

本示例说明 XML 大容量加载如何使用在映射架构中指定的 M:N 关系在表中加载表示 M:N 关系的数据。

例如，请看此 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>

架构指定具有 <Product 子元素的 Order> 元素。<> <Order> 元素映射到 Ord 表，<Product> 元素映射到数据库中的 Product 表。 Product> 元素上<指定的链关系标识由 OrderDetail 表表示的 M：N 关系。（一个订单可能包含许多产品，而一个产品可能包含在许多订单中。）

当您使用此架构大容量加载 XML 文档时，记录将添加到 Ord、Product 和 OrderDetail 表中。

测试工作示例

创建三个表：

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

将本示例中上面提供的架构另存为 SampleSchema.xml。

将以下示例 XML 数据另存为 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>

在您首选的文本编辑器或 XML 编辑器中创建文件，然后将其另存为 ValidateAndBulkload.vbs。在此文件中，添加本主题前面开头部分提供的 VBScript 代码。修改连接字符串以提供适当的服务器和数据库名称。从该示例的源代码中取消以下各行的注释。
```
objBL.CheckConstraints = True  
objBL.Transaction=True  
```
执行 VBScript 代码。 XML 大容量加载会将 XML 文档加载到 Ord 表和 Product 表中。

D. 在标识类型列中执行大容量加载

本示例说明大容量加载如何处理标识类型列。在此示例中，数据将被大容量加载到三个表（Ord、Product 和 OrderDetail）中。

在这些表中：

Ord 表中的 OrderID 是标识类型列。
Product 表中的 ProductID 是标识类型列。
OrderDetail 中的 OrderID 和 ProductID 列是外键列，它们引用 Ord 和 Product 表中的对应主键列。

以下是此示例的表架构：

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

在此 XML 大容量加载示例中，BulkLoad 对象模型的 KeepIdentity 属性设置为 false。因此，SQL Server为 Product 和 Ord 表中的 ProductID 和 OrderID 列生成标识值，分别 (将忽略文档中要大容量加载的任何值) 。

在这种情况下，XML 大容量加载将标识各表之间的主键/外键关系。大容量加载首先在具有主键的表中插入记录，然后将SQL Server生成的标识值传播到具有外键列的表中。在下面的示例中，XML 大容量加载按以下顺序在表中插入数据：

产品
Ord
OrderDetail

注意

为了传播在 Products 和 Orders 表中生成的标识值，处理逻辑要求 XML 大容量加载对这些值保持跟踪，以便以后插入到 OrderDetails 表中。为此，XML 大容量加载创建中间表，在这些表中填充数据，之后删除这些表。

测试工作示例

创建以下表：

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

在您首选的文本编辑器或 XML 编辑器中创建文件，然后将其另存为 SampleSchema.xml。将此 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="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>

在您首选的文本编辑器或 XML 编辑器中创建文件，然后将其另存为 SampleXMLData.xml。添加下列 XML 文档。

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

在您首选的文本编辑器或 XML 编辑器中创建文件，然后将其另存为 ValidateAndBulkload.vbs。在此文件中，添加以下 VBScript 代码。修改连接字符串以提供适当的服务器和数据库名称。为用作 Execute 方法参数的文件指定适当的路径。

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

执行 VBScript 代码。 XML 大容量加载会将数据加载到适当的表中。

E. 在大容量加载之前生成表架构

如果在大容量加载之前表不存在，则 XML 大容量加载可以选择生成这些表。将 SQLXMLBulkLoad 对象的 SchemaGen 属性设置为 TRUE 可执行此操作。还可以选择请求 XML 大容量加载以删除任何现有表，并通过将 SGDropTables 属性设置为 TRUE 来重新创建它们。下面的 VBScript 示例阐释了这些属性的用法。

此外，此示例将另外两个属性设置为 TRUE：

CheckConstraints。通过将此属性设置为 TRUE，可确保要插入表中的数据不违反已在表上指定的任何约束（在此情况下，在 Cust 表与 CustOrder 表之间指定了 PRIMARY KEY/FOREIGN KEY 约束）。如果存在约束冲突，则大容量加载失败。
XMLFragment。因为示例 XML 文档（数据源）不包含单一顶级元素（因此它是片段），所以此属性必须设置为 TRUE。

以下是 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

测试工作示例

在您首选的文本编辑器或 XML 编辑器中创建文件，然后将其另存为 SampleSchema.xml。将在前面的示例“使用架构中的链关系大容量加载 XML”中提供的 XSD 架构添加到此文件中。
在您首选的文本编辑器或 XML 编辑器中创建文件，然后将其另存为 SampleXMLData.xml。将在前面的示例“使用架构中的链关系大容量加载 XML”中提供的 XML 文档添加到此文件中。 <从文档 (中删除 ROOT> 元素，使其成为) 片段。
在您首选的文本编辑器或 XML 编辑器中创建文件，然后将其另存为 ValidateAndBulkload.vbs。在此文件中，添加本示例中的 VBScript 代码。修改连接字符串以提供适当的服务器和数据库名称。为指定为 Execute 方法参数的文件指定适当的路径。
执行 VBScript 代码。 XML 大容量加载将根据所提供的映射架构创建必需的表，然后将数据大容量加载到其中。

F. 从流中执行大容量加载

XML 大容量加载对象模型的 Execute 方法采用两个参数。第一个参数是映射架构文件。第二个参数提供要加载到数据库中的 XML 数据。可通过两种方法将 XML 数据传递到 XML 大容量加载的 Execute 方法：

指定文件名作为参数。
传递包含 XML 数据的流。

本示例说明如何从流中执行大容量加载。

VBScript 首先执行 SELECT 语句从 Northwind 数据库的 Customers 表中检索客户信息。因为在 SELECT 语句中指定了 FOR XML 子句（具有 ELEMENTS 选项），所以，查询将以如下格式返回以元素为中心的 XML 文档：

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

然后，该脚本将 XML 作为流传递给 Execute 方法作为其第二个参数。 Execute 方法将数据大容量加载到 Cust 表中。

由于此脚本将 SchemaGen 属性设置为 TRUE，将 SGDropTables 属性设置为 TRUE，因此 XML 大容量加载会在指定数据库中创建 Cust 表。（如果该表已经存在，它首先删除此表，然后重新创建该表。）

以下是 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

以下 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: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>

以下是等效的 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" />  
    </ElementType>  
</Schema>

在现有文件中打开流

还可以在现有 XML 数据文件上打开流，并将流作为参数传递给 Execute 方法 (，而不是将文件名作为参数传递) 。

以下是将流作为参数传递的 Visual Basic 示例：

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

为了测试应用程序，请使用文件 (SampleData.xml) 中的以下 XML 文档和本示例中提供的 XSD 架构：

以下是 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>

这是等效的 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. 在溢出列中执行大容量加载

如果映射架构使用 sql：overflow-field 注释指定溢出列，则 XML 大容量加载会将源文档中的所有未用数据复制到此列中。

请看下面的 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>

此架构标识 Cust 表的溢出列 (OverflowColumn)。因此，每个 <Customer> 元素的所有未用 XML 数据都会添加到此列。

注意

所有抽象元素 () 指定 了 abstract=“true” 的元素，并且指定了 禁止=“true” 的所有 (禁止属性) XML 大容量加载被视为溢出，并添加到溢出列（如果指定）。（否则，将忽略它们。）

测试工作示例

在 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

在您首选的文本编辑器或 XML 编辑器中创建文件，然后将其另存为 SampleSchema.xml。将在本示例中提供的 XSD 架构添加到此文件中。

在您首选的文本编辑器或 XML 编辑器中创建文件，然后将其另存为 SampleXMLData.xml。将以下 XML 文档添加到此文件中：

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

在您首选的文本编辑器或 XML 编辑器中创建文件，然后将其另存为 ValidateAndBulkload.vbs。在此文件中，添加以下 Microsoft Visual Basic Scripting Edition (VBScript) 代码。修改连接字符串以提供适当的服务器和数据库名称。为指定为 Execute 方法参数的文件指定适当的路径。
```
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  
```
执行 VBScript 代码。

这是等效的 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. 在事务模式下为 temp 文件指定文件路径

在事务模式下批量加载 (即，当 Transaction 属性设置为 TRUE) 时，还必须在以下任一条件为 true 时设置 TempFilePath 属性：

您要大容量加载到远程服务器。
您要使用备用本地驱动器或文件夹（不同于由 TEMP 环境变量指定的路径）存储在事务模式下创建的临时文件。

例如，以下 VBScript 代码在事务模式下将 SampleXMLData.xml 文件中的数据大容量加载到数据库表中。指定 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\MyDir"  
objBL.Execute "SampleSchema.xml", "SampleXMLData.xml"  
set objBL=Nothing

注意

临时文件路径必须是一个共享位置，SQL Server的目标实例的服务帐户和运行大容量加载应用程序的帐户可以访问该共享位置。除非您在本地服务器上执行大容量加载，否则，临时文件路径必须为 UNC 路径（例如，\\servername\sharename）。

测试工作示例

在 tempdb 数据库中创建此表：

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

在您首选的文本编辑器或 XML 编辑器中创建文件，然后将其另存为 SampleSchema.xml。将以下 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>

在您首选的文本编辑器或 XML 编辑器中创建文件，然后将其另存为 SampleXMLData.xml。将以下 XML 文档添加到此文件中：
```
<ROOT>  
<Customers CustomerID="6F9619FF-8B86-D011-B42D-00C04FC964FF"   
           LastName="Smith" />  
</ROOT>  
```

在您首选的文本编辑器或 XML 编辑器中创建文件，然后将其另存为 ValidateAndBulkload.vbs。在此文件中，添加以下 VBScript 代码。修改连接字符串以提供适当的服务器和数据库名称。为指定为 Execute 方法参数的文件指定适当的路径。此外，请为 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

执行 VBScript 代码。

当 CustomerID 的值指定为包含大括号 ({ 和 }) 的 GUID 时，架构必须为 CustomerID 属性指定相应的 sql：datatype，例如：

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

以下是更新后的架构：

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

指定 sql：datatype 将列类型标识为 uniqueidentifier 时，大容量加载操作会先从 CustomerID 值中删除大括号 ({ 和 }) ，然后再将其插入列中。

这是等效的 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. 将现有数据库连接用于 ConnectionCommand 属性

可以使用现有 ADO 连接以大容量加载 XML。如果 XML 大容量加载只是将对数据源执行的许多操作之一，则这一点很有用。

ConnectionCommand 属性使你能够通过使用 ADO 命令对象来使用现有的 ADO 连接。下面的 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

测试工作示例

在 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

在您首选的文本编辑器或 XML 编辑器中创建文件，然后将其另存为 SampleSchema.xml。将以下 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>

在您首选的文本编辑器或 XML 编辑器中创建文件，然后将其另存为 SampleXMLData.xml。将以下 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 OrderID="4" />  
</Customers>  
</ROOT>

创建 Visual Basic（标准 EXE）应用程序以及以上代码。将这些引用添加到项目中：

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

执行应用程序。

这是等效的 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. 在 xml 数据类型列中执行大容量加载

如果映射架构使用 sql：datatype=“xml”注释指定 xml 数据类型列，则 XML 大容量加载可以将映射字段的 XML 子元素从源文档复制到此列中。

请看以下 XSD 架构，它映射 AdventureWorks 示例数据库中 Production.ProductModel 表的视图。在此表中，xml 数据类型的 CatalogDescription 字段使用 sql：field 和 sql：datatype=“xml” 注释映射到 <Desc> 元素。

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

测试工作示例

验证已安装了 AdventureWorks 示例数据库。
在您首选的文本编辑器或 XML 编辑器中创建文件，然后将其另存为 SampleSchema.xml。复制上面的 XSD 架构并将其粘贴到文件中，然后保存该文件。

在您首选的文本编辑器或 XML 编辑器中创建文件，然后将其另存为 SampleXMLData.xml。复制以下 XML 文档并将其粘贴到该文件中，然后将其保存到上一步中所用的同一个文件夹中。

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

在您首选的文本编辑器或 XML 编辑器中创建文件，然后将其另存为 BulkloadXml.vbs。复制下面的 VBScript 代码并将其粘贴到该文件中。将其保存到用于先前的 XML 数据和架构文件的相同文件夹中。

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

执行 BulkloadXml.vbs 脚本。

XML 大容量加载示例 (SQLXML 4.0)

Bulk Loader 脚本 (ValidateAndBulkload.vbs)

A. 将 XML 大容量加载到表中

测试示例大容量加载

B. 将 XML 数据大容量加载到多个表中

测试示例大容量加载

C. 使用架构中的链关系大容量加载 XML

测试工作示例

D. 在标识类型列中执行大容量加载

测试工作示例

E. 在大容量加载之前生成表架构

测试工作示例

F. 从流中执行大容量加载

在现有文件中打开流

G. 在溢出列中执行大容量加载

测试工作示例

H. 在事务模式下为 temp 文件指定文件路径

测试工作示例

I. 将现有数据库连接用于 ConnectionCommand 属性

测试工作示例

J. 在 xml 数据类型列中执行大容量加载

测试工作示例

反馈

反馈

其他资源