XPath contains(text(),'some string') doesn't work when used with node with more than one Text subnode

Question

I have a small problem with XPath contains with dom4j ...

Let's say my XML is

<Home>
    <Addr>
        <Street>ABC</Street>
        <Number>5</Number>
        <Comment>BLAH BLAH BLAH <br/><br/>ABC</Comment>
    </Addr>
</Home>

Let's say I want to find all the nodes that have ABC in the text given the root Element...

So the XPath that I would needed to write would be

//*[contains(text(),'ABC')]

However this is not what dom4j returns .... is this a dom4j problem or my understanding how XPath works, since that query returns only the Street element and not the Comment element?

The DOM makes the Comment element a composite element with four tags two

[Text = 'XYZ'][BR][BR][Text = 'ABC'] 

I would assume that the query should still return the element since it should find the element and run contains on it, but it doesn't ...

The following query returns the element, but it returns far more then just the element – it returns the parent elements as well, which is undesirable to the problem.

//*[contains(text(),'ABC')]

Does any one know the XPath query that would return just the elements <Street/> and <Comment/> ?

Answer 1

^{Modern answer that covers XPath 1.0 vs XPath 2.0+ behavior ...}

This XPath,

//*[contains(text(),'ABC')]

behaves differently with XPath 1.0 and later versions of XPath (2.0+).

Common behavior

• //* selects all elements within a document.
• [] filters those elements according to the predicate expressed therein.
• contains(string, substring) within the predicate will filter those elements for which substring is a substring in string.

XPath 1.0 behavior

• contains(arg1, substring): If the first argument evaluates to a node set, contains() will convert the node set to a string by taking the string value of the first node in the node set. (If arg1 is text(), only the first of all matching text nodes will be considered by contains().) If you find this odd, you are not alone.
• For //*[contains(text(),'ABC')] that node set will be all child text nodes of each element in the document.
• Since only the first text node child is used, the expectation that all child text nodes are tested for 'ABC' substring containment is violated.
• This leads to counter-intuitive results to anyone unfamiliar with the above conversion rules.

XPath 1.0 online example shows that only one 'ABC' is selected.

XPath 2.0+ behavior

• It is an error to call contains(arg1, substring) with a sequence of more than one item as the first argument.
• This corrected the counter-intuitive behavior described above in XPath 1.0.

XPath 2.0 online example shows a typical error message due to the conversion error particular to XPath 2.0+.

Common solutions

1. If you wish to include descendent elements (beyond children), test against the string value of an element as a single string, rather than the individual string values of the child text nodes, this XPath,

   //*[contains(.,'ABC')]
   

   selects your targeted Street and Comment elements and also their Addr and Home ancestor elements because those too have 'ABC' as substrings of their string values.

   Online example shows ancestors being selected too.

2. If you wish to exclude descendent elements (beyond children), this XPath,

   //*[text()[contains(.,'ABC')]]
   

   selects only your targeted Street and Comment because only those elements have text node children whose string values contain the 'ABC' substring. This will be true for all versions of XPath

   Online example shows only Street and Comment being selected.

Answer 2

Here is an alternate way to match nodes which contain a given text string. First query for the text node itself, then get the parent:

//text()[contains(., "ABC")]/..

For me this is easy to read and understand.

Answer 3

//*[text()='ABC'] 

returns

<street>ABC</street>
<comment>BLAH BLAH BLAH <br><br>ABC</comment>

Answer 4

The accepted answer will return all the parent nodes too. To get only the actual nodes with ABC even if the string is after
:

//*[text()[contains(.,'ABC')]]/text()[contains(.,"ABC")]

Answer 5

The XML document:

<Home>
    <Addr>
        <Street>ABC</Street>
        <Number>5</Number>
        <Comment>BLAH BLAH BLAH <br/><br/>ABC</Comment>
    </Addr>
</Home>

The XPath expression:

//*[contains(text(), 'ABC')]

//* matches any descendant element of the root node. That is, any element but the root node.

[...] is a predicate, it filters the node-set. It returns nodes for which ... is true:

A predicate filters a node-set [...] to produce a new node-set. For each node in the node-set to be filtered, the PredicateExpr is evaluated [...]; if PredicateExpr evaluates to true for that node, the node is included in the new node-set; otherwise, it is not included.

contains('haystack', 'needle') returns true if haystack contains needle:

Function: boolean contains(string, string)

The contains function returns true if the first argument string contains the second argument string, and otherwise returns false.

But contains() takes a string as its first parameter. And it's passed nodes. To deal with that every node or node-set passed as the first parameter is converted to a string by the string() function:

An argument is converted to type string as if by calling the string function.

string() function returns string-value of the first node:

A node-set is converted to a string by returning the string-value of the node in the node-set that is first in document order. If the node-set is empty, an empty string is returned.

string-value of an element node:

The string-value of an element node is the concatenation of the string-values of all text node descendants of the element node in document order.

string-value of a text node:

The string-value of a text node is the character data.

So, basically string-value is all text that is contained in a node (concatenation of all descendant text nodes).

text() is a node test that matches any text node:

The node test text() is true for any text node. For example, child::text() will select the text node children of the context node.

Having that said, //*[contains(text(), 'ABC')] matches any element (but the root node), the first text node of which contains ABC. Since text() returns a node-set that contains all child text nodes of the context node (relative to which an expression is evaluated). But contains() takes only the first one. So for the document above the path matches the Street element.

The following expression //*[text()[contains(., 'ABC')]] matches any element (but the root node), that has at least one child text node, that contains ABC. . represents the context node. In this case, it's a child text node of any element but the root node. So for the document above the path matches the Street, and the Comment elements.

Now then, //*[contains(., 'ABC')] matches any element (but the root node) that contains ABC (in the concatenation of the descendant text nodes). For the document above it matches the Home, the Addr, the Street, and the Comment elements. As such, //*[contains(., 'BLAH ABC')] matches the Home, the Addr, and the Comment elements.

Answer 6

The <Comment> tag contains two text nodes and two <br> nodes as children.

Your xpath expression was

//*[contains(text(),'ABC')]

To break this down,

1. * is a selector that matches any element (i.e. tag) -- it returns a node-set.
2. The [] are a conditional that operates on each individual node in that node set. It matches if any of the individual nodes it operates on match the conditions inside the brackets.
3. text() is a selector that matches all of the text nodes that are children of the context node -- it returns a node set.
4. contains is a function that operates on a string. If it is passed a node set, the node set is converted into a string by returning the string-value of the node in the node-set that is first in document order. Hence, it can match only the first text node in your <Comment> element -- namely BLAH BLAH BLAH. Since that doesn't match, you don't get a <Comment> in your results.

You need to change this to

//*[text()[contains(.,'ABC')]]

1. * is a selector that matches any element (i.e. tag) -- it returns a node-set.
2. The outer [] are a conditional that operates on each individual node in that node set -- here it operates on each element in the document.
3. text() is a selector that matches all of the text nodes that are children of the context node -- it returns a node set.
4. The inner [] are a conditional that operates on each node in that node set -- here each individual text node. Each individual text node is the starting point for any path in the brackets, and can also be referred to explicitly as . within the brackets. It matches if any of the individual nodes it operates on match the conditions inside the brackets.
5. contains is a function that operates on a string. Here it is passed an individual text node (.). Since it is passed the second text node in the <Comment> tag individually, it will see the 'ABC' string and be able to match it.