anchor.diff:                         if (root.Parent = -1 && root.Entry = rootId) then yield row'.ID
              } @>
   
  -    
  -    let xp0 = child ./. child //                                                        /*/*
  -    let xp1 = descendant ./. parent //                                                  //*/parent::*
  -    let xp2 = descendant ./. (Filter(followingsibling .%. "dirn")) //                   //*[following-sibling::d]
  -    let xp3 = descendant .%. "year" ./. Filter(ancestor ./. preceding .%. "dir") //     //f[ancestor::*/preceding::b]
  +
  +
  +    let xp0 = Path.Child / Path.Child                                                       //  /*/*
  +    let xp1 = Path.Descendant / Path.Parent                                                 //  //*/parent::*
  +    let xp2 = Path.Descendant / (Filter(Path.FollowingSibling % "dirn"))                    //  //*[following-sibling::d]
  +    let xp3 = Path.Descendant % "year" / Filter(Path.Ancestor / Path.Preceding % "dir")     //  //f[ancestor::*/preceding::b]
   
       [<TestFixture>]
       type TestClass() =
  
positive.code: /// <summary>
  /// Contains example queries and operations on the Xml database. 
  /// The queries here are further wrapped in quotations to allow for their evaluation in different contexts (see Utils.fs).  
  /// <para>These tests require the schema from sql/xml.sql in a database referred to in app.config </para>
  /// </summary>
  module Xml =
      [<Literal>]
  
negative.code:         | Name of string
          | Filter of Path
  
          static member Child = Axis Child
          static member Self = Axis Self
          static member Descendant = Axis Descendant
          static member DescendantOrSelf = Axis DescendantOrSelf
          static member Parent = Axis(Rev Child)
          static member Ancestor = Axis(Rev Descendant)
          static member AncestorOrSelf = Axis(Rev DescendantOrSelf)
          static member Following = Axis Following
          static member FollowingSibling = Axis FollowingSibling
          static member Preceding = Axis(Rev Following)
          static member PrecedingSibling = Axis(Rev FollowingSibling)
  
          /// <summary>
          /// Indicates the concatenation of two paths. 
          /// </summary>
          /// <param name="p1">The first path. </param>
          /// <param name="p2">The second path. </param>
          static member (/) (p1, p2) = Seq(p1, p2)
  
          /// <summary>
          /// Indicates the concatenation of a path with an element name filter. 
          /// </summary>
          /// <param name="path">The initial path. </param>
          /// <param name="name">The name filter for the element. </param>
          static member (%) (path, name) = Seq(path, Name name)
  
          /// <summary>
          /// Indicates the concatenation of a path with a path filter. 
          /// </summary>
          /// <param name="path1">The initial path. </param>
          /// <param name="path2">The path filter. </param>
          static member (^^) (path1, path2) = Seq(path1, Filter(path2))
  
      let internal db = schema.GetDataContext()
      let internal data = db.Data
      let internal text = db.Text
      let internal attributes = db.Attribute
  
      // XML document loading/shredding
  
      let mutable idx = 0
      let new_id() =
          let i = idx
          idx <- i + 1
          i
  
      // Walks the XML document
      let rec traverseXml entry parent i (node : XNode) =
          // creates an attribute record
          let traverseAttribute entry parent (att : XAttribute) =
              let a = new Attribute()
              a.Element <- parent
              a.Name <- att.Name.LocalName
              a.Value <- att.Value
              attributes.InsertOnSubmit(a)
  
          // recursively traverse all child nodes
          let traverseChildren entry parent i (xmls) = 
              Seq.fold (traverseXml entry parent) i xmls
  
          match node with
          | :? XElement as xml ->
              let id = new_id()
              let j = Seq.iter (traverseAttribute entry id) (xml.Attributes())
              let j = traverseChildren entry id (i + 1) (xml.Nodes())
  
              let d = new Data()
              d.Name <- xml.Name.ToString()
              d.ID <- id
  