XML Native Query Processing
Chun-shek ChanMahesh Marathe
Wednesday, February 12, 2003
Topics
• XML Indexing– “Accelerating XPath Location Steps”
Torsten Grust, ACM SIGMOD 2002
• XML Query Optimization– “Multi-level Operator Combination in XML
Query Processing”Shurug Al-Khalifa and H.V. Jagadish,ACM CIKM 2002
XML Query Languages
• XPath– Developed by the World Wide Web
Consortium– Version 1.0 became a W3C Recommendation
on November 16, 1999– Version 2.0 is a working draft.
XML Query Languages
• XQuery– Developed by the World Wide Web
Consortium as well– Currently a working draft
Axes on XPath Tree
• There are 13 axes according to the XPath 2.0 Technical Report– Forward Axes
• child, descendant, attribute, self,descendant-or-self, following-sibling, following, namespace (deprecated)
– Reverse Axes• parent, ancestor, preceding-sibling, preceding,
ancestor-or-self
XML Traversal and Storage
• Tree-based traversal
• Efficient storage is challenging– Especially for relational databases, which
deals with tuples and is not designed to handle recursion or nested elements
Proposed Solutions
• “Querying XML Data for Regular Path Expressions”Li and Moon, VLDB 2001
• “A Fast Index for Semistructured Data”Cooper, Sample, Franklin, Hjaltason and Shadmon, VLDB 2001
• “DataGuides: Enabling Query Formulation and Optimization in Semistructured Databases”Goldman and Widom, VLDB 1997
Problems withProposed Solutions
• Solutions focus on support of / and // location steps. Inadequate support for XPath.
• Proposals rely on technologies outside the relational domain.
Author’s Proposal
• XPath Accelerator
• Works entirely within relational database.
• Uses traditional relational syntax for queries.
• Benefits from advanced index technologies, such as R-tree.
XPath Tree Traversal
• Context Node: starting point of any traversal
• Location Steps: syntactically separatedby /, evaluated from left to right– A step’s axis establishes a subset of
document nodes (a document region)
XPath Forward Axes
• Child• Descendant• Attribute• Self• Descendant-or-self• Following-sibling• Following• Namespace
XPath Reverse Axes
• Parent
• Ancestor
• Preceding-sibling
• Preceding
• Ancestor-or-self
Sample XML Tree
a
b f
c
e d
g h
i j
Encoding XMLDocument Regions
• Formula:v/descendant v/descendant v/following v/preceding v/self
• Each node appears once in this formula
• What are the ways to uniquely identify different nodes?
Numbering Nodes
• Grust: Find out preorder and postorder rank posts
• Tatarinov: Global, Local, Dewey
• Li & Moon: Order-size pairs
XML Document Regions
0
1
2
3
4
5
6
7
8
9
0 1 2 3 4 5 6 7 8 9
Preorder Rank Post
Po
sto
rder
Ran
k P
ost
a
b
c
de
f
g
h
ij
• Descendants?• Ancestors?• Preceding?• Following?
a
b f
c
d e
g h
i j
XPath Tree Node Descriptor
• desc(v) = {pre(v),post(v),par(v),att(v),tag(v)}
• window(α,v) ={condition for each field in desc()}
• Example:window(child,v) = {(pre(v),∞),[0,post(v)),pre(v),false,*}
XPath Query Windows
Axis α pre post par att tag
Child (pre(v),∞) [0,post(v)) pre(v) false *
Descendant (pre(v),∞) [0,post(v)) * false *
Desc-or-self [pre(v),∞) [0,post(v)] * false *
Parent par(v) (post(v),∞) * false *
Ancestor [0,pre(v)) (post(v),∞) * false *
Anc-or-self [0,pre(v)] [post(v),∞) * false *
Following (pre(v),∞) (post(v),∞) * false *
Preceding (0,pre(v)) (0,post(v)) * false *
Fol-sibling (pre(v),∞) (post(v),∞) par(v) false *
Prec-sibling (0,pre(v)) (0,post(v)) par(v) false *
Attribute (pre(v),∞) [0,post(v)) pre(v) true *
XPath Evaluation
• Given an XPath expression e, an axis α, and a node v, we can evaluate this:– query(e/α) =
SELECT v’,*FROM query(e) v, accel v’WHERE v’ INSIDE window(α,v)
• This pseudo-SQL code can be flattened into a plain relational query with a flatn-ary self-join.
XML Instance Loading
• Loading XML Instance into the database means mapping its nodes into the descriptor table.
• Can use callback procedures described in text to load element nodes into relational table.
• Make separate table for element contents.
Potential Issues
• Insertion of node– Need to renumber all nodes to reflect
changes
• Deletion of node– Only need to remove its entry in accelerator
table
Node Descriptor Indexing
• Efficiently supported by R-trees.
• Can also be supported by B-trees.
Example of pre/postrank distribution
Shrink-wrapping the //-axis
• Optimizing window for descendant axis
• For each node, we need to determine the ranges of pre and post ranks for its leftmost and rightmost leaf nodes.
• For any node v in a tree t, we havepre(v) − post(v) + size(v) = level(v)
• For a leaf node v’, size(v’) = 0, thereforepre(v’) − post(v’) = level(v’) ≤ height(t)
Shrink-wrapping the //-axis
• For the rightmost leaf v’ of node v:post(v) = post(v’) + (level(v’) − level(v))
• Using the previous equations, we have:pre(v’) ≤ post(v) + height(t)
• For the leftmost left v’’ of node v, we have a similar result:post(v’’) ≥ pre(v) − height(t)
• Can use these formula to shrink windows
Shrink-wrapping the //-axis
• Original window{ (pre(v),∞), [0,post(v)), *, false, * }
• New window{ (pre(v),post(v)+height(t)], [pre(v)−height(t),post(v)), *, false, * }
• Similar techniques can be used to optimize the query windows of other axes.
Shrink-wrapping the //-axis
Finding Leavesin an XML Tree
XPath Traversals with and without shrunk windows
Query ShrunkNot
Shrunk#
Nodes
//open_auction//description 0.2 53 120
//open_auction//description//listitem 0.32 55.5 126
//open_auction//description//listitem//keyword 0.34 124 90
XPath Acceleratorv. Edge Map
R-Tree v. B-Tree
Performance for the ancestor axis
Performance: XPath Accelerator v. EE/EA-Join
1.150.7
5.41
7
0
1
2
3
4
5
6
7
Tim
e [s
]
Shakespeare[//ACT//SPEECH]
NITF [//block/attribute::dir]
Xpath Accel EE/EA
Capabilities ofXPath Accelerator
• Runs on top of a relational backend to leverage its stability, scalability, and performance.
• Supports the whole family of XPath axes in an adequate manner.
• To originate XPath traversals in arbitrary context nodes.
• Provides the groundwork for an effective cost-estimation for XPath queries.
XML Query Optimization
• Macro-level algebra: manipulates sets of trees directly– heavyweight, but more directly expressive
• Micro-level algebra: manipulates sets of elements
• In both algebra, basic operators are “intuitive” unit operations such as selections, projections, joins and set operations.
XQuery Expression and Pattern Tree
Macro-algebra
• A macro-algebra would implement this entire expression as a single pattern-tree based selection operator (to select matching books), followed by a projection operator (to return titles).
Micro-algebra
• A micro-algebra would break up the selection pattern into one selection operator per node (e.g. (tag=“book”), (tag=“year” && content > 1995)) and one containment join operator per edge.
• Result of sequence of joins would then be projected on the book element, after which its title can be obtained as before.
Query Processing Implementation
1. Identify lists of candidate elements in the database to match each node in the specified structural pattern.
2. Find combinations of candidate elements, one from each list, that satisfy the required structural relationships.
3. Apply any conditions that involve multiple nodes in the structural pattern to eliminate some combinations.
Containment Join
• Given two sets of elements U and V, a containment join returns pairs of elements (u,v) such that– u U and v V– u “contains” v
• i.e. node u is an ancestor of node v in the tree representation
Containment Join Implementation
• Three main options:– Scan the entire database– Use an index to find candidate nodes for one
end of the join, and navigate from there– Use indices to find candidate nodes for both
ends of the join, and compute a containment join between these candidate sets
Projection Merging
Set Operations
• Union compatibility is not an issue.– In the relational world, union compatibility is
an important consideration with respect to set operations.
– In XML, since heterogeneous collections are allowed, this is not an issue.
Union in XML
• Give two pattern trees PT1 and PT2, let PTC be a common component of the two pattern trees such that:– PT1 − PTC = PT’1 and PT2 − PTC = PT’2
where PT’1 and PT’2 are both trees
– Node i in PTC has node j in PT’1 such that edge (i,j) is in PT1, if and only if node i also has some node k in PT’2 such that edge (i,k) is in PT2.
Different PatternTrees and Plans
Micro-operator Merging: New Access Methods
• At macro-level, we considered a pattern tree selection as a single heavyweight operator.
• At micro-level, the approach is to break up a pattern tree selection into multiple containment join operators.
Performance: Union
020406080
100120140160180200
No Push Push
Performance: Intersection
0
20
40
60
80
100
120
No Push Push
Performance byQuery Structure
1
10
100
1000
10000
Pair Twig Chain1 Chain2
Union No Push Union Push
Intersection No Push Intersection Push
Parent-Child Join Performance
0
10
20
30
40
50
60
70
Not Pushed Macro Push Micro Push
Ancestor-Descendant Join Performance
0
10
20
30
40
50
60
Not Pushed Macro Push Micro Push
Performance Comparison for Different Pushes
Conclusions
• It is not enough to consider XML query optimization purely at the micro-algebra or purely at the macro-algebra level, with simple operators.
• One has to consider access methods for combination of operators, switching between the micro and macro levels as needed.
Top Related