Numeric predicates allow you to select a node based on its position relative to another node in the document (that is, based on its context).

For example, consider the document presented in XQuery: A Brief Introduction. This document contains three <Node3> elements. If you simply enter the XQuery expression:

all <Node3> elements in the document are returned. To return, say, the second <Node3> element, use a predicate:

Boolean predicates filter a query result so that only those elements of the result are kept if the expression evaluates to true. For example, suppose you want to select a node only if its text node is equal to some value. Then:

Just like Unix filesystem paths, any path that does not begin with a slash (/) is relative to your current location in a document. Your current location in a document is determined by your context. Thus, if in the document presented in XQuery: A Brief Introduction your context is set to Node2, you can refer to Node3 with the simple notation:

Further, you can refer to a parent node using the following familiar notation:

and to the current node using:

Natural language and, therefore, tag names can be imprecise. Two different tags can have identical names and yet hold entirely different sorts of information. Namespaces are intended to resolve any such sources of confusion.

Consider the following document:

<?xml version="1.0"?>
<definition>
    <ring>
        Jewelry that you wear.
    </ring>
    <ring>
        A sound that a telephone makes.
    </ring>
    <ring>
        A circular space for exhibitions.              
    </ring>
</definition> 

As constructed, this document makes it difficult (though not impossible) to select the node for, say, a ringing telephone.

To resolve any potential confusion in your schema or supporting code, you can introduce namespaces to your documents. For example:

<?xml version="1.0"?>
<definition>
    <jewelry:ring xmlns:jewelry="http://myDefinition.dbxml/jewelry">
        Jewelry that you wear.
    </jewelry:ring>
    <sounds:ring xmlns:sounds="http://myDefinition.dbxml/sounds">
        A sound a telephone makes.
    </sounds:ring>
    <showplaces:ring 
        xmlns:showplaces="http://myDefinition.dbxml/showplaces">
        A circular space for exhibitions.
    </showplaces:ring>
</definition> 

Now that the document has defined namespaces, you can precisely query any given node:

By identifying the namespace to which the node belongs, you are declaring a context for the query.

The URI used in the namespace definition is not required to actually resolve to anything. The only criteria is that it be unique within the scope of any document set(s) in which it might be used.

Also, the namespace is only required to be declared once in the document. All subsequent usages need only use the relevant prefix. For example, we could have added the following to our previous document:

<jewelry:diamond>
    The centerpiece of many rings.
</jewelry:diamond>
<showplaces:diamond>
    A place where baseball is played.     
</showplaces:diamond>

Finally, namespaces can be used with attributes too. For an example:

<clubMembers>
    <surveyResults school:class="English" 
        xmlns:school="http://myExampleDefinitions.dbxml/school" 
        number="200"/>
    <surveyResults school:class="Mathematics" 
        number="165"/>
    <surveyResults social:class="Middle" 
        xmlns:social="http://myExampleDefinitions.dbxml/social"      
        number="543"/>
</clubMembers>

Once you have declared a namespace for an attribute, you can query the attribute in the following way:

And to retrieve the value set for the attribute:

Within XQuery, collection() is a function that allows you to create a named sequence. From within BDB XML, however, it is also used to navigate to a specific container. In this case, you must identify to collection() the literal name of the container. You do this either by passing the container name directly to the function, or by declaring a default container name using the XmlQueryContext.setDefaultCollection() method.

Note that the container must have already been opened by the XmlManager in order for collection to reference that container. The exception to this is if XmlManager was opened using the XmlManagerConfig.setAllowAutoOpen() method.

For example, suppose you want to perform a query against a container named container1.dbxml. In this case, first open the container using XmlManager.openContainer() and then specify the collection() function on the query. For example:

Note that this is actually short-hand for:

dbxml:/ is the default base URI for BDB XML. You can change the base URI using XmlQueryContext.setBaseURI().

If you want to perform a query against multiple containers, use the union ("|") operator. For example, to query against containers c1.dbxml and c2.dbxml, you would use the following expression:

See Retrieving BDB XML Documents using XQuery for more information on how to prepare and perform queries.

XQuery provides the doc() function so that you can trivially navigate to the root of a named document. doc() is required to take a URI.

To use doc() to navigate to a specific document stored in BDB XML, provide an XQuery path that uses the dbxml: base URI, and that identifies the container in which the document can be found. The actual document name that you provide is the same name that was set for the document when it was added to the container (see Adding Documents for more information).

For example, suppose you have a document named "mydoc1.xml" in container "container1.dbxml". Then to perform a query against that specific document, first open container1.dbxml and then provide a query something like this:

See Retrieving BDB XML Documents using XQuery for more information on how to prepare and perform queries.