使用WSS的Lists.UpdateListItems()方法之被截断的CAML

    Microsoft的WSS（Windows Sharepoint Services）公开了很多用于访问和管理Sharepoint站点的方法，在调用这些方法时可以通过CAML（Collaborative Application Markup Language）进行一些操作。其中Lists.UpdateListItems()方法提供了用于向Sharepoint List增、删、改数据的方法，但是需要通过CAML语句告诉Sharepoint如何更新数据，有关如何使用CAML以及如何编写CAML进行List数据更新，读者可以参考微软的MSDN文档。

http://msdn.microsoft.com/zh-cn/library/websvclists.lists.updatelistitems.aspx

   顺便再给出调用Sharepoint站点的Web Service的地址：

http://Sitename/_vit_bin/lists.asmx?op=UpdateListItems

   在使用Lists.UpdateListItems方法时，所使用的用于更新数据的CAML类似于下面这样：

<Batch OnError="Continue">
    <Method ID="1" Cmd="New">
        <Field Name="Title">Hello<Field>
        <Field Name="Document">5</Field>
   </Method>
   <Method ID="2" Cmd="New">
        <Field Name="Title" >World</Field>
        <Field Name="Document">5</Field>
   </Method>
</Batch>

   也就是说我们可以在同一段CAML中批量操作数据。不过最近在实际应用中遇到了一个问题，那就是当我要更新的记录太多，比如20000行，可能我需要写一段特别长的CAML，这个时候当我们在程序中调用Web Service时WSS会给出这样的错误。

Some part of your SQL statement is nested too deeply. Rewrite the query or break it up into smaller queries.

   就是说你所使用的CAML语句太长而被自动截断了。细心观察一下，发现被截断的CAML的前半部分已经成功执行到List中了，而后半部分没有被执行，看来我们需要自己动手来处理这个Bug了。最好的办法就是将过长的CAML分批进行处理，一部分一部分地执行。

 1 /// <summary>
 2         /// Breaks a larg CAML query into smaller batches to avoid the error "Some part of your SQL statement is nested too deeply. Rewrite the query or break it up into smaller queries."
 3         /// </summary>
 4         /// <param name="listService">The SharePoint list service to execute the CAML against.</param>
 5         /// <param name="listName">The name of the list to execute the CAML against.</param>
 6         /// <param name="elementLargeBatch">The CAML batch list of commands to be broken up.</param>
 7         /// <param name="intBatchSize">The size of batches to use.  If unsure use 300, it seems to work fairly well.</param>
 8         /// <returns>Returns the status of each method block posted through the updates parameter and can 
 9         /// be assigned to a System.Xml.XmlNode object.</returns>
         public static XmlNode UpdateListItems(SqlClrSharePointSynchronizer.Lists.Lists listService, string listName, XmlElement elementLargeBatch, int intBatchSize)
         {
             // calculate useful information
             int intMethodCount = elementLargeBatch.ChildNodes.Count;
             int intBatchCount = (int)Math.Ceiling((double)intMethodCount / (double)intBatchSize);
 
             // prepare xml documents for batches and results
             XmlDocument xmlDocBatch = new XmlDocument();
             XmlDocument xmlDocResults = new XmlDocument();
             XmlElement elementResults = xmlDocResults.CreateElement("Results");
 
             try
             {
                 // for each batch
                 for (int intCurrentBatch = 0; intCurrentBatch < intBatchCount; intCurrentBatch++)
                 {
                     int intMethodStart = intCurrentBatch * intBatchSize;
                     int intMethodEnd = Math.Min(intMethodStart + intBatchSize - 1, intMethodCount - 1);
 
                     XmlElement elementSmallBatch = CreateBatch(xmlDocBatch);
 
                     // for each method in the batch
                     for (int intCurrentMethod = intMethodStart; intCurrentMethod <= intMethodEnd; intCurrentMethod++)
                     {
                         XmlElement element = (XmlElement)elementLargeBatch.ChildNodes[intCurrentMethod];
                         elementSmallBatch.AppendChild(xmlDocBatch.ImportNode(element, true));
                     }
 
                     // execute the batch
                     XmlNode nodeBatchResult = listService.UpdateListItems(listName, elementSmallBatch);
 
                     // add the results of the batch into the results xml document
                     foreach (XmlElement elementResult in nodeBatchResult.ChildNodes)
                     {
                         elementResults.AppendChild(xmlDocResults.ImportNode(elementResult, true));
                     }
 
                     // clean up
                     xmlDocBatch.RemoveAll();
                 }
             }
             catch (SoapException ex)
             {
                 if (ex.Detail == null)
                 {
                     throw;
                 }
 
                 //copy the exception detail into the Message so it will be available to SQL.
                 throw new SoapException(ex.Detail.InnerText, ex.Code, ex.Actor, ex.Detail, ex);
             }
 
             return (XmlNode)elementResults;
         }
 
 /// <summary>
         /// Create the batch element. e.g. &lt;Batch OnError="Continue"&gt;&lt;/Batch&gt;
         /// </summary>
         /// <param name="xmlDoc">The object of XmlDocument.</param>
         /// <returns>Return the Batch element.</returns>
         private static XmlElement CreateBatch(XmlDocument xmlDoc) 
         {
             XmlElement elementBatch = xmlDoc.CreateElement("Batch");
             elementBatch.SetAttribute("OnError", "Continue");
             return elementBatch;
         }

   我在使用的过程中发现超过600行的数据更新就会出现CAML被截断的情况，所以我干脆将intBatchSize设置为300，超过300行的CAML将会被分批执行。在Web Service中使用CAML经常会遇到这样或那样的问题，查询用的CAML问题更多，不过Microsoft在SP对象中对CAML的支持还是不错的，毕竟是经过封装的，使用起来要顺手许多。