View source for XPath

{{Short description|Expression language for XML documents}}
{{More citations needed|date=August 2010}}

{{Infobox programming language
| name                   = XPath
| paradigm               = [[Query language]]
| year                   = 1998
| designer               = 
| developer              = [[W3C]]
| latest_release_version = 3.1
| latest_release_date    = {{Start date and age|2017|03|21}}
| typing                 =
| implementations        = 
| dialects               = 
| influenced_by          = [[XSLT]], [[XPointer]]
| influenced             = [[XML Schema (W3C)|XML Schema]], [[XForms]], [[JSONPath]]
| operating_system       = 
| license                = 
| website                = 
}}
'''XPath''' ('''XML Path Language''') is an [[expression language]] designed to support the query or transformation of [[XML]] documents. It was defined by the [[World Wide Web Consortium]] (W3C) in 1999,<ref name="timelinehistory">{{cite web|url=http://www.dblab.ntua.gr/~bikakis/XML%20and%20Semantic%20Web%20W3C%20Standards%20Timeline-History.pdf |title=XML and Semantic Web W3C Standards Timeline | date=2012-02-04}}</ref> and can be used to compute values (e.g., [[String (computer science)|strings]], numbers, or [[Boolean value]]s) from the content of an XML document. Support for XPath exists in applications that support XML, such as web browsers, and many programming languages.

The XPath language is based on a [[XML tree|tree representation of the XML document]], and provides the ability to navigate around the tree, selecting nodes by a variety of criteria.<ref>{{cite magazine | url=http://www.sqlmag.com/article/xml/xpath-151-retrieving-nodes-from-an-xml-document.aspx | title=XPath—Retrieving Nodes from an XML Document | author=Bergeron, Randy | magazine=SQL Server Magazine | date=2000-10-31 | access-date=2011-02-24 | archive-url=https://web.archive.org/web/20100726204716/http://www.sqlmag.com/article/xml/xpath-151-retrieving-nodes-from-an-xml-document.aspx | archive-date=2010-07-26 | url-status=dead }}</ref><ref>{{cite web | url=http://wam.inrialpes.fr/courses/PG-MoSIG12/xpath.pdf | title=Course: The XPath Language| author=Pierre Geneves| author-link=Pierre Geneves| date=2012}}</ref> In popular use (though not in the official specification), an XPath expression is often referred to simply as "an XPath".

Originally motivated by a desire to provide a common syntax and behavior model between [[XPointer]] and [[XSLT]], subsets of the XPath [[query language]] are used in other [[W3C]] specifications such as [[W3C XML Schema|XML Schema]], [[XForms]] and the [[Internationalization Tag Set|Internationalization Tag Set (ITS)]].

XPath has been adopted by a number of XML processing libraries and tools, many of which also offer [[Cascading Style Sheets|CSS Selectors]], another W3C standard, as a simpler alternative to XPath.

== Versions ==
There are several versions of XPath in use. XPath 1.0 was published in 1999, XPath 2.0 in 2007 (with a second edition in 2010), XPath 3.0 in 2014, and XPath 3.1 in 2017. However, XPath 1.0 is still the version that is most widely available.<ref name="timelinehistory" />

*XPath 1.0 became a Recommendation on 16 November 1999 and is widely implemented and used, either on its own (called via an API from languages such as [[Java (programming language)|Java]], [[C Sharp (programming language)|C#]], [[Python (programming language)|Python]] or [[JavaScript]]), or embedded in languages such as [[XSLT]], [[XProc]], [[XML Schema (W3C)|XML Schema]] or [[XForms]].
*[[XPath 2.0]] became a Recommendation on 23 January 2007, with a second edition published on 14 December 2010. A number of implementations exist but are not as widely used as XPath 1.0. The XPath 2.0 language specification is much larger than XPath 1.0 and changes some of the fundamental concepts of the language such as the type system.
*:The most notable change is that XPath 2.0 is built around the [[XQuery and XPath Data Model]] (XDM) that has a much richer type system.{{efn|XPath 2.0 supports atomic types, defined as built-in types in [[W3C XML Schema|XML Schema]], and may also import user-defined types from a schema.}} Every value is now a sequence (a single atomic value or node is regarded as a sequence of length one). XPath 1.0 node-sets are replaced by node sequences, which may be in any order.
*:To support richer type sets, XPath 2.0 offers a greatly expanded set of functions and operators.
*:XPath 2.0 is in fact a subset of [[XQuery]] 1.0. They share the same data model ([[XQuery and XPath Data Model|XDM]]). It offers a <code>for</code> expression that is a cut-down version of the "[[FLWOR]]" expressions in XQuery. It is possible to describe the language by listing the parts of XQuery that it leaves out: the main examples are the query prolog, element and attribute constructors, the remainder of the "FLWOR" syntax, and the <code>typeswitch</code> expression.
*[[XPath 3.0]] became a Recommendation on 8 April 2014.<ref>{{cite web | title=XML Path Language (XPath) 3.0 | website=World Wide Web Consortium (W3C) | date=2014-04-02 | url=https://www.w3.org/TR/xpath-30/ | access-date=2021-07-16}}</ref> The most significant new feature is support for functions as first-class values.<ref>{{cite web |last1=Kay |first1=Michael |title=What's new in 3.0 (XSLT/XPath/XQuery) (plus XML Schema 1.1) |url=https://archive.xmlprague.cz/2012/presentations/Whats_new_3.0_XPath_XSLT_XSD_1_1.pdf |website=XML Prague 2012 | date=2012-02-10 |access-date=2021-07-16}}</ref>  XPath 3.0 is a subset of XQuery 3.0, and most current implementations (April 2014) exist as part of an XQuery 3.0 engine.
*XPath 3.1 became a Recommendation on 21 March 2017.<ref>{{cite web | title=XML Path Language (XPath) 3.1 | website=World Wide Web Consortium (W3C) | date=2017-03-21 | url=https://www.w3.org/TR/xpath-31/ | access-date=2021-07-16}}</ref> This version adds new data types: maps and arrays, largely to underpin support for [[JSON]].

[[Image:XPath example.svg|300px|thumb|XPath expression applied to an XML file]]

==Syntax and semantics (XPath 1.0)==

The most important kind of expression in XPath is a ''location path''. A location path consists of a sequence of ''location steps''. Each location step has three components:

* an ''[[#Axis_specifiers|axis]]''
* a ''[[#Node_tests|node test]]''
* zero or more ''[[#Predicates|predicates]]''.

An XPath expression is evaluated with respect to a ''context node''. An Axis Specifier such as 'child' or 'descendant' specifies the direction to navigate from the context node. The node test and the predicate are used to filter the nodes specified by the axis specifier: For example, the node test 'A' requires that all nodes navigated to must have label 'A'. A predicate can be used to specify that the selected nodes have certain properties, which are specified by XPath expressions themselves.

The XPath syntax comes in two flavors: the ''abbreviated syntax'', is more compact and allows XPaths to be written and read easily using intuitive and, in many cases, familiar characters and constructs. The ''full syntax'' is more verbose, but allows for more options to be specified, and is more descriptive if read carefully.

===Abbreviated syntax===
The compact notation allows many defaults and abbreviations for common cases. Given source XML containing at least

<syntaxhighlight lang="xml">
<A>
  <B>
    <C/>
  </B>
</A>
</syntaxhighlight>

the simplest XPath takes a form such as
* <code>/A/B/C</code>
that selects C elements that are children of B elements that are children of the A element that forms the outermost element of the XML document. The XPath syntax is designed to mimic URI ([[Uniform Resource Identifier]]) and [[File path#Unix style|Unix-style file path]] syntax.

More complex expressions can be constructed by specifying an axis other than the default 'child' axis, a node test other than a simple name, or predicates, which can be written in square brackets after any step. For example, the expression
* <code>A//B/*[1]</code>
selects the first child ('<code>*[1]</code>'), whatever its name, of every B element that itself is a child or other, deeper descendant ('<code>//</code>') of an A element that is a child of the current context node (the expression does not begin with a '<code>/</code>'). The predicate <code>[1]</code> binds more tightly than the <code>/</code> operator. To select the first node selected by the expression <code>A//B/*</code>, write <code>(A//B/*)[1]</code>. Note also, index values in XPath predicates (technically, 'proximity positions' of XPath node sets) start from 1, not 0 as common in languages like C and Java.

===Expanded syntax===
In the full, unabbreviated syntax, the two examples above would be written
* {{code|2=xquery|1=/child::A/child::B/child::C}}
* {{code|2=xquery|1=child::A/descendant-or-self::node()/child::B/child::node()[position()=1]}}

Here, in each step of the XPath, the '''axis''' (e.g. <code>child</code> or <code>descendant-or-self</code>) is explicitly specified, followed by <code>::</code> and then the '''node test''', such as <code>A</code> or <code>node()</code> in the examples above.

Here the same, but shorter: {{code|2=xquery|1=A//B/*[position()=1]}}

===Axis specifiers===
Axis specifiers indicate navigation direction within the tree representation of the XML document. The axes available are:{{efn|group=axis|name=WalshAxisViz|XML authority Normal Walsh maintains an excellent online visualization of the axis specifiers.<ref name=Walsh1999>{{cite web 
  |url=https://nwalsh.com/docs/tutorials/xsl/xsl/foil22.html 
  |accessdate=2021-02-25
  |title=Axis Specifiers 
  |last1=Walsh 
  |first1=Norman 
  |date=1999 
  |website=nwalsh.com 
  |publisher=Personal blog of venerated XML sage graybeard.  
}}</ref> It appears from the illustration that ''preceding'', ''ancestor'', ''self'', ''descendant'', and ''following'' form a complete, ordered, non-overlapping partition of document element tree.}}

{|class="wikitable"
|+Axis specifiers in XPath
!scope="col"|Full syntax
!scope="col"|Abbreviated syntax
!scope="col"| Notes
|-
|{{code|ancestor}}|| ||
|-
|{{code|ancestor-or-self}}|| ||
|-
|{{code|attribute}}
|align="center"|{{code|@}}
|{{code|@abc}} is short for {{code|attribute::abc}}
|-
|{{code|child}}||||{{code|xyz}} is short for {{code|child::xyz}}
|-
|{{code|descendant}}
|align="center"|{{code|//}}
|{{code|//}} is short for {{code|/descendant-or-self::node()/}}
|-
|{{code|descendant-or-self}}|| ||
|-
|{{code|following}}|| ||
|-
|{{code|following-sibling}}|| ||
|-
|{{code|namespace}}|| ||
|-
|{{code|parent}}
|align="center"|{{code|..}}
|{{code|..}} is short for {{code|parent::node()}}
|-
|{{code|preceding}}|| ||
|-
|{{code|preceding-sibling}}|| ||
|-
|{{code|self}}
|align="center"|{{code|.}}
|{{code|.}} is short for {{code|self::node()}}
|}

As an example of using the '''attribute''' axis in abbreviated syntax, <code>//a/@href</code> selects the attribute called <code>href</code> in <code>a</code> elements anywhere in the document tree.
The expression '''.''' (an abbreviation for '''self::node()''') is most commonly used within a predicate to refer to the currently selected node.
For example, <code>h3[.='See also']</code> selects an element called <code>h3</code> in the current context, whose text content is <code>See also</code>.

===Node tests===
Node tests may consist of specific node names or more general expressions. In the case of an XML document in which the namespace prefix <code>gs</code> has been defined, <code>//gs:enquiry</code> will find all the <code>enquiry</code> elements in that namespace, and <code>//gs:*</code> will find all elements, regardless of local name, in that namespace.

Other node test formats are:
;{{mono|comment()}} :finds an XML comment node, e.g. <code><nowiki><!-- Comment --></nowiki></code>
;{{mono|text()}} :finds a node of type text excluding any children, e.g. the <code>hello</code> in <code><k>hello<m> world</m></k></code>
;{{mono|processing-instruction()}} :finds XML [[processing instruction]]s such as {{code|2=php|1=<?php echo $a; ?>}}. In this case, <code>processing-instruction('php')</code> would match.
;{{mono|node()}} :finds any node at all.

===Predicates===
Predicates, written as expressions in square brackets, can be used to [[Filter (higher-order function)|filter]] a node-set according to some condition. For example, <code>a</code> returns a node-set (all the <code>a</code> elements which are children of the context node), and {{code|2=xquery|1=a[@href='help.php']}} keeps only those elements having an <code>href</code> attribute with the value <code>help.php</code>.

There is no limit to the number of predicates in a step, and they need not be confined to the last step in an XPath. They can also be nested to any depth. Paths specified in predicates begin at the context of the current step (i.e. that of the immediately preceding node test) and do not alter that context. All predicates must be satisfied for a match to occur.

When the value of the predicate is numeric, it is syntactic-sugar for comparing against the node's position in the node-set (as given by the function <code>position()</code>).  So <code>p[1]</code> is shorthand for {{code|2=xquery|1=p[position()=1]}} and selects the first <code>p</code> element child, while <code>p[last()]</code> is shorthand for {{code|2=xquery|1=p[position()=last()]}} and selects the last <code>p</code> child of the context node.

In other cases, the value of the predicate is automatically converted to a Boolean. When the predicate evaluates to a node-set, the result is true when the node-set is {{clarify span|non-empty|date=December 2015}}. Thus <code>p[@x]</code> selects those <code>p</code> elements that have an attribute named <code>x</code>.

A more complex example: the expression {{code|2=xquery|1=a[/html/@lang='en'][@href='help.php'][1]/@target}} selects the value of the <code>target</code> attribute of the first <code>a</code> element among the children of the context node that has its <code>href</code> attribute set to <code>help.php</code>, provided the document's <code>html</code> top-level element also has a <code>lang</code> attribute set to <code>en</code>. The reference to an attribute of the top-level element in the first predicate affects neither the context of other predicates nor that of the location step itself.

Predicate order is significant if predicates test the position of a node. Each predicate takes a node-set returns a (potentially) smaller node-set. So {{code|2=xquery|1=a[1][@href='help.php']}} will find a match only if the first <code>a</code> child of the context node satisfies the condition <code>@href='help.php'</code>, while {{code|2=xquery|1=a[@href='help.php'][1]}} will find the first <code>a</code> child that satisfies this condition.

===Functions and operators===
XPath 1.0 defines four data types: node-sets (sets of nodes with no intrinsic order), strings, numbers and Booleans.

The available operators are:

* The {{code|1=/}}, {{code|1=//}} and {{code|1=[...]}} operators, used in path expressions, as described above.
* A union operator, {{code|1={{!}}}}, which forms the union of two node-sets.
* Boolean operators {{code|1=and}} and {{code|1=or}}, and a function {{code|1=not()}}
* Arithmetic operators {{code|1=+}}, {{code|1=-}}, {{code|1=*}}, {{code|1=div}} (divide), and {{code|1=mod}}
* Comparison operators {{code|1==}}, {{code|1=!=}}, {{code|1=<}}, {{code|1=>}}, {{code|1=<=}}, {{code|1=>=}}

The function library includes:

* Functions to manipulate strings: {{mono|concat(), substring(), contains(), substring-before(), substring-after(), translate(), normalize-space(), string-length()}}
* Functions to manipulate numbers: {{mono|sum(), round(), floor(), ceiling()}}
* Functions to get properties of nodes: {{mono|name(), local-name(), namespace-uri()}}
* Functions to get information about the processing context: {{mono|position(), last()}}
* Type conversion functions: {{mono|string(), number(), boolean()}}

Some of the more commonly useful functions are detailed below.{{efn|For a complete description, see [http://www.w3.org/TR/xpath the W3C Recommendation document].}}

====Node set functions====
;{{mono|position()}} :returns a number representing the position of this node in the sequence of nodes currently being processed (for example, the nodes selected by an xsl:for-each instruction in XSLT).
;{{mono|count(''node-set'')}} :returns the number of nodes in the node-set supplied as its argument.

====String functions====
;{{mono|string(''object''?)}} :converts any of the four XPath data types into a string according to built-in rules. If the value of the argument is a node-set, the function returns the string-value of the first node in document order, ignoring any further nodes.
;{{mono|concat(''string'', ''string'', ''string''*)}} :[[Concatenation|concatenates]] two or more strings
;{{mono|starts-with(''s1'', ''s2'')}} : returns <code>true</code> if <code>s1</code> starts with <code>s2</code>
;{{mono|contains(''s1'', ''s2'')}} :returns <code>true</code> if <code>s1</code> contains <code>s2</code>
;{{mono|substring(''string'', ''start'', ''length''?)}} :example: <code>substring("ABCDEF",2,3)</code> returns {{code|1=BCD}}.
;{{mono|substring-before(''s1'', ''s2'')}} :example: <code>substring-before("1999/04/01","/")</code> returns <code>1999</code>
;{{mono|substring-after(''s1'', ''s2'')}} :example: <code>substring-after("1999/04/01","/")</code> returns <code>04/01</code>
;{{mono|string-length(string?)}} :returns number of characters in string
;{{mono|normalize-space(''string''?)}} :all leading and trailing [[Whitespace (computer science)|whitespace]] is removed and any sequences of whitespace characters are replaced by a single space. This is very useful when the original XML may have been [[prettyprint]] formatted, which could make further string processing unreliable.

====Boolean functions====
;{{mono|not(''boolean'')}} :negates any Boolean expression.

;{{mono|true()}} :evaluates to ''true''.

;{{mono|false()}} :evaluates to ''false''.

====Number functions====
;{{mono|sum(''node-set'')}} :converts the string values of all the nodes found by the XPath argument into numbers, according to the built-in casting rules, then returns the sum of these numbers.

===Usage examples===
Expressions can be created inside predicates using the operators: <code><nowiki>=, !=, <=, <, >=</nowiki></code> and <code><nowiki>></nowiki></code>. Boolean expressions may be combined with brackets <code>()</code> and the Boolean operators <code>and</code> and <code>or</code> as well as the <code>not()</code> function described above. Numeric calculations can use <code><nowiki>*, +, -, div</nowiki></code> and <code><nowiki>mod</nowiki></code>. Strings can consist of any [[Unicode]] characters.

{{code|2=xquery|1=//item[@price > 2*@discount]}} selects items whose price attribute is greater than twice the numeric value of their discount attribute.

Entire node-sets can be combined ([[Union (set theory)|'unioned']]) using the vertical bar character |. Node sets that meet one or more of several conditions can be found by combining the conditions inside a predicate with '<code>or</code>'.

<code>v[x or y] | w[z]</code> will return a single node-set consisting of all the <code>v</code> elements that have <code>x</code> or <code>y</code> child-elements, as well as all the <code>w</code> elements that have <code>z</code> child-elements, that were found in the current context.

==Syntax and semantics (XPath 2.0)==

{{main|XPath 2.0}}

==Syntax and semantics (XPath 3)==

{{main|XPath 3}}

==Examples==
Given a sample XML document
<syntaxhighlight lang="xml">
<?xml version="1.0" encoding="utf-8"?>
<Wikimedia>
  <projects>
    <project name="Wikipedia" launch="2001-01-05">
      <editions>
        <edition language="English">en.wikipedia.org</edition>
        <edition language="German">de.wikipedia.org</edition>
        <edition language="French">fr.wikipedia.org</edition>
        <edition language="Polish">pl.wikipedia.org</edition>
        <edition language="Spanish">es.wikipedia.org</edition>
      </editions>
    </project>
    <project name="Wiktionary" launch="2002-12-12">
      <editions>
        <edition language="English">en.wiktionary.org</edition>
        <edition language="French">fr.wiktionary.org</edition>
        <edition language="Vietnamese">vi.wiktionary.org</edition>
        <edition language="Turkish">tr.wiktionary.org</edition>
        <edition language="Spanish">es.wiktionary.org</edition>
      </editions>
    </project>
  </projects>
</Wikimedia>
</syntaxhighlight>

The XPath expression
 /Wikimedia/projects/project/@name
selects name attributes for all projects, and
 /Wikimedia//editions
selects all editions of all projects, and
 {{code|2=xquery|1=/Wikimedia/projects/project/editions/edition[@language='English']/text()}}
selects addresses of all English Wikimedia projects (text of all <code>edition</code> elements where <code>language</code> attribute is equal to ''English''). And the following
 {{code|2=xquery|1=/Wikimedia/projects/project[@name='Wikipedia']/editions/edition/text()}}
selects addresses of all Wikipedias (text of all <code>edition</code> elements that exist under <code>project</code> element with a name attribute of ''Wikipedia'').

==Implementations==
=== Command-line tools ===
* [[XMLStarlet]]
* [[libxml2|xmllint (libxml2)]]
* RaptorXML Server from Altova supports XPath 1.0, 2.0, and 3.0
* [http://www.videlibri.de/xidel.html Xidel]

=== C/C++ ===
* [[libxml2]]
* Pathan<ref>[https://web.archive.org/web/20150408041815/http://www.corefiling.com/opensource/pathan.html http://www.corefiling.com/opensource/pathan.html]</ref>
* pugixml<ref>http://pugixml.org/</ref>
* [[Sedna (database)|Sedna XML Database]]
* [[VTD-XML]]
* [[Xalan]]
* XQilla<ref>http://xqilla.sourceforge.net/HomePage</ref>

=== Free Pascal ===
* The unit XPath is included in the default libraries

=== Implementations for database engines ===
* [[Virtuoso Universal Server|OpenLink Virtuoso]]

=== Java ===
* [[Saxon XSLT]] supports XPath 1.0, XPath 2.0 and XPath 3.0 (as well as XSLT 2.0, XQuery 3.0, and XPath 3.0)
* [[BaseX]] (also supports XPath 2.0 and XQuery)
* [[VTD-XML]]
* Sedna XML Database Both XML:DB and proprietary.
* QuiXPath,<ref>http://code.google.com/p/quixpath</ref> a [[Streaming XML|streaming]] [[open source]] implementation by Innovimax
* [[Xalan]]
* [[Dom4j]]
The [[Java (programming language)|Java]]
package '''{{Javadoc:SE|package=javax.xml.xpath|javax/xml/xpath|module=java.xml}}''' has been part of Java standard edition since Java 5<ref>{{cite web | title=javax.xml.xpath (Java SE 10 & JDK 10) | website=Java® Platform, Standard Edition & Java Development Kit Version 10 API Specification | url=https://docs.oracle.com/javase/10/docs/api/javax/xml/xpath/package-summary.html | access-date=2021-07-17 | quote=Since: 1.5}}</ref> via the [[Java API for XML Processing]]. Technically this is an XPath [[API]] rather than an XPath implementation, and it allows the programmer the ability to select a specific implementation that conforms to the interface.

=== JavaScript ===
* jQuery XPath plugin<ref>https://github.com/ilinsky/jquery-xpath/</ref> based on Open-source XPath 2.0 implementation in JavaScript<ref>https://github.com/ilinsky/xpath.js</ref>
* FontoXPath<ref>https://github.com/FontoXML/fontoxpath</ref> Open source XPath 3.1 implementation in JavaScript. Currently under development.

=== .NET Framework ===
* In the System.Xml and System.Xml.XPath namespaces<ref>{{cite web | title=System.Xml Namespace | website=Microsoft Docs | date=2020-10-25 | url=https://docs.microsoft.com/en-us/dotnet/api/system.xml | access-date=2021-07-16}}</ref>
* Sedna XML Database

=== Perl ===
* XML::LibXML<ref>https://metacpan.org/pod/XML::LibXML</ref> (libxml2)

=== PHP ===
* Sedna XML Database
* DOMXPath<ref>https://www.php.net/manual/en/class.domxpath.php</ref> via libxml extension

=== Python ===
* The ElementTree XML API<ref>https://docs.python.org/3/library/xml.etree.elementtree.html</ref> in the Python Standard Library includes [https://docs.python.org/3/library/xml.etree.elementtree.html#xpath-support limited support] for XPath expressions
* libxml2
* [[Amara (software)|Amara]]
* Sedna XML Database
* lxml<ref>http://lxml.de/</ref>
* [[Scrapy]]<ref>
{{cite web
 |url= https://www.digitalocean.com/community/tutorials/how-to-crawl-a-web-page-with-scrapy-and-python-3
 |title= How To Crawl A Web Page with Scrapy and Python 3 
 |access-date = 2017-11-24
 |last= Duke
 |first= Justin
 |date= 2016-09-29
 |website= [[Digital Ocean]]
 |quote= Selectors are patterns we can use to find one or more elements on a page so we can then work with the data within the element. scrapy supports either CSS selectors or XPath selectors.
}}</ref>

=== Ruby ===
* [[libxml2]]
* [[Nokogiri (software)|Nokogiri]]

=== Scheme ===
* Sedna XML Database

=== SQL ===
* [[MySQL]] supports a subset of XPath from version 5.1.5 onwards<ref name="dev.mysql.com 2016">{{cite web | title=MySQL :: MySQL 5.1 Reference Manual :: 12.11 XML Functions | website=dev.mysql.com | date=2016-04-06 | url=http://dev.mysql.com/doc/refman/5.1/en/xml-functions.html | archive-url=https://web.archive.org/web/20160406093208/http://dev.mysql.com/doc/refman/5.1/en/xml-functions.html | archive-date=2016-04-06 | url-status=unfit | access-date=2021-07-17}}</ref>
* [[PostgreSQL]] supports XPath and XSLT from version 8.4 onwards<ref>{{cite web | title=xml2 | website=PostgreSQL Documentation | date=2014-07-24 | url=https://www.postgresql.org/docs/8.4/xml2.html | access-date=2021-07-16}}</ref>

=== Tcl ===
* The {{Not a typo|tDOM}} package provides a complete, compliant, and fast XPath implementation in C<ref>{{cite journal | last1=Loewer | first1=Jochen | title=tDOM – A fast XML/DOM/XPath package for Tcl written in C | journal=Proceedings of First European TCL/Tk User Meeting | date=2000 | url=http://www.tdom.org/documents/tDOM3.pdf | access-date=16 July 2021}}</ref>

==Use in schema languages==
XPath is increasingly used to express constraints in schema languages for XML.
* The (now [[International Organization for Standardization|ISO standard]]) schema language [[Schematron]] pioneered the approach.
* A streaming subset of XPath is used in W3C XML Schema 1.0 for expressing uniqueness and key constraints. In XSD 1.1, the use of XPath is extended to support conditional type assignment based on attribute values, and to allow arbitrary Boolean assertions to be evaluated against the content of elements.
* XForms uses XPath to bind types to values.
*The approach has even found use in non-XML applications, such as the source code analyzer for Java called [[PMD (software)|PMD]]: the Java is converted to a [[Document Object Model|DOM]]-like parse tree, then XPath rules are defined over the tree.

==See also==
* [[XPath 3]]
* [[Navigational database]]
* [[XLink]]
* [[XML database]]
* [[Extensible Stylesheet Language|XSL]]
* [[XSL-FO]]

== Notes ==
{{notelist}}

==References==
{{Reflist|2}}

==External links==
{{Wikibooks}}
* [http://www.w3.org/TR/xpath10 XPath 1.0 specification]
* [http://www.w3.org/TR/xpath20/ XPath 2.0 specification]
* [http://www.w3.org/TR/xpath-30/ XPath 3.0 specification]
* [http://www.w3.org/TR/xpath-31/ XPath 3.1 specification]
* [http://www.xml.com/pub/a/2002/03/20/xpath2.html What's New in XPath 2.0]
* [http://msdn.microsoft.com/en-us/library/ms256115.aspx XPath Reference (MSDN)]
* [http://saxon.sourceforge.net/saxon6.5.5/expressions.html XPath Expression Syntax (Saxon)]
* [http://saxon.sourceforge.net/saxon7.2/expressions.html XPath 2.0 Expression Syntax (Saxon)], [http://saxon.sourceforge.net/saxon7.5/expressions.html]
* [https://developer.mozilla.org/en/Web/XPath XPath - MDC Docs] by [https://developer.mozilla.org Mozilla Developer Network]
* [http://www.data2type.de/en/xml-xslt-xslfo/xpath/xpath-introduction/ XPath introduction/tutorial]
* [http://www.data2type.de/en/xml-xslt-xslfo/xslt/xslt-xpath-function-reference/ XSLT and XPath function reference]

{{XSL}}
{{W3C standards}}
{{Query languages}}

{{Authority control}}

{{DEFAULTSORT:Xpath}}
[[Category:Query languages]]
[[Category:XML data access]]