TREE EMBEDDING AND XML QUERY EVALUATION

Yangjun Chen

Dept. Applied Computer Science, University of Winnipeg, Canada

Keywords: XML databases, Trees, Paths, XML pattern matching, Twig joins.

Abstract: Tree pattern matching is one of the most fundamental tasks for XML query processing. Prior work has

typically decomposed the tree pattern into binary structural (parent-child and ancestor-descendent)

relationships or paths, and then stitch together these basic matches by join operations. In this paper, we

propose a new algorithm that explores both the document tree and the twig pattern in a bottom-up way and

show that the join operation can be completely avoided. The new algorithm runs in O(|T|⋅|Q|) time and

O(|Q|⋅leaf

T

) space, where T and Q are the document tree and the tree pattern query, respectively; and leaf

T

represents the number of leaf nodes in T.

1 INTRODUCTION

In XML, data is represented as a tree; associated

with each node of the tree is an element type from a

finite alphabet ∑. The children of a node are ordered

from left to right, and represent the content (i.e., list

of subelements) of that element.

To abstract from existing query languages for XML

(e.g. XPath, XQuery, XML-QL, and Quilt), we

express queries as twig patterns (or say, tree

patterns) where nodes are types from ∑ ∪ {*} (* is a

wildcard, matching any node type) and string values,

and edges are parent-child or ancestor-descendant

relationships. As an example, consider the query tree

shown in Fig. 1, which asks for any node of type b

(node 2) that is a child of some node of type a (node

1). In addition, the b type (node 2) is the parent of

some c type (node 4) and an ancestor of some d type

(node 5). Type b (node 3) can also be the parent of

some e type (node 7). The query corresponds to the

following XPath expression:

a[b[c and //d]]/b[c and e//d].

In this figure, there are two kinds of edges: child

edges (c-edges) for parent-child relationships, and

descendant edges (d-edges) for ancestor-descendant

relationships. A c-edge from node v to node u is

denoted by v → u in the text, and represented by a

single arc; u is called a c-child of v. A d-edge is

denoted v ⇒ u in the text, and represented by a

double arc; u is called a d-child of u.

Figure 1: A query tree.

Definition 1. An embedding of a tree pattern Q into

an XML document T is a mapping f: Q → T, from

the nodes of Q to the nodes of T, which satisfies the

following conditions:

(i) Preserve node type: For each u ∈ Q, u and f(u)

are of the same type. (or more generally, u’s

node test is satisfied by f(u).)

(ii) Preserve c/d-child relationships: If u → v in Q,

then f(v) is a child of f(u) in T; if u ⇒ v in Q,

then f(v) is a descendant of f(u) in T.

If there exits a mapping from Q into T, we say, Q

can be imbedded into T, or say, T contains Q. In

addition, if label(T’s root) = label(Q’s root), we say

that the embedding is root-preserving.

As an example, see the document tree and the

tree pattern query shown in Fig. 2(a).

There exits a mapping from Q to T as illustrated

by the dashed lines, by which each node of Q is

mapped to a different node of T. However,

according to the definition, an embedding could map

several nodes of Q (of the same type) to the same

node of T, as shown in Fig. 2(b), by which nodes q

2

and q

5

in Q are mapped onto a single node v

2

in T,

and q

3

and q

4

are mapped onto a single node v

3

in T.

4 c d 5

2 b

d 8

1 a

6 c

b 3

e 7

output node

173

Chen Y. (2008).

TREE EMBEDDING AND XML QUERY EVALUATION.

In Proceedings of the Tenth International Conference on Enterprise Information Systems - DISI, pages 173-178

DOI: 10.5220/0001690301730178

Copyright

c

SciTePress

Figure 2: Illustration for tree embedding.

For the purpose of query evaluation, either of the

mappings is recognized as a tree embedding.

In fact, almost all the existing strategies are

designed to work in this way.

In this paper, we discuss a new algorithm, which

works in a bottom-up way and shows that the join or

join-like operations can be completely avoided. The

algorithm works in O(|T|⋅|Q|) time and O(|Q|⋅leaf

T

)

space, where leaf

Q

is the number of the leaf nodes of

Q.

The remainder of the paper is organized as

follows. In Section 2, we review the related work. In

Section 3, we discuss our main algorithm. In Section

4, we extend this algorithm to general cases that ‘∨’

and ‘¬’ logic operators are included. Finally, a short

conclusion is set forth in Section 5.

2 RELATED WORK

With the growing importance of XML in data

exchange, the tree pattern queries over XML

documents have been extensively studied recently.

Most existing techniques rely on indexing or on the

tree encoding to capture the structural relationships

among document elements, such as the methods

discussed in (Li and Moon, 2001; Goldman and

Widom, 1997; Cooper and et al., 2001; Chung and

et al., 2002; Kaushik and et al., 2002; Wang and et

al., 2003; Wang and Meng, 2005).

All the above mentioned methods need to

decompose a tree pattern into a set of binary

relationships between pairs of nodes, such as parent-

child and ancestor-descendant relations, or into a set

of paths. The sizes of intermediate relations tend to

be very large, even when the input and final result

sizes are much more manageable. As an important

improvement, TwigStack was proposed by Bruno et

al. (Bruno and et al., 2002), which compress the

intermediate results by the stack encoding, which

represents in linear space a potentially exponential

number of answers. However, TwigStack achieves

optimality only for the queries that contain only d-

edges. In the case that a query contains both c-edges

and d-edges, some useless path matchings have to be

performed. In addition, in the worst case, TwigStack

needs O(|D|

|Q|

) time for doing the merge joins as

shown by Chen et al. (see page 287 in (Chen and et

al., 2006)), where D is a largest data stream

associated with a node q in Q, which contains all the

document nodes that match q. Since then, several

methods that improve TwigStack in some way have

been reported. For instance, iTwigJoin (Chen and et

al., 2005) exploits different data partition

possibilities while TJFast (Lu and et al., 2005)

accesses only leaf nodes of document trees by using

Dewey IDs. But both of them still need to do some

useless matchings as shown by the theoretical

analysis made in (Choi and et al., 2003). Twig

2

Stack

(Chen and et al., 2006) is the most recent method

that improves TwigStack. By this method, the stack

encoding is replaced with the hierarchical stack

encoding, by which each stack associated with a

query node contains an ordered sequence of stack

trees. In this way, the path joins are replaced by the

so called result enumeration. In (Chen and et al.,

2006), it is claimed that Twig

2

Stack needs only

O(|D|⋅|Q| + |subTwigResults|) time. But a careful

analysis shows that the time complexity of the

method is actually bounded by O(|D|⋅|Q|

2

+

|subTwigResults|). It is because each time a node is

inserted into a stack associated with a node in Q, not

only the position of this node in a tree within that

stack has to be determined, but a link from this node

to a node in some other stack has to be constructed,

which requires to search all the other stacks. The

number of these stacks is |Q| (see Fig. 4 in (Chen

and et al., 2006) to know the working process.) The

bottom-up method discussed in (Chen, 2007) needs

no join operations.

In this paper, we improve the method proposed

in (Chen, 2007) by removing all the merging

operations, which are needed by that method to form

matching sets associated with each node in T. In

addition, the method is extended to handle general

cases.

3 ALGORITHM

In this section, we discuss our algorithm according

to Definition 1. The main idea of this algorithm is to

search both T and Q bottom-up and checking the

subtree embedding by generating dynamic data

structures. In the process, a tree labeling technique is

c v

3

v

4

b q

3

c q

4

c

(b)

c v

3

v

4

b

b v

2

a v

1

v

8

b

v

6

c

c v

5

v

7

d

q

3

c q

4

c

b q

2

q

1

a

q

5

b

(a)

b v

2

a v

1

v

8

b b q

2

q

1

a

q

5

b

ICEIS 2008 - International Conference on Enterprise Information Systems

174

used to facilitate the recognition of nodes’

relationships. Therefore, in the following, we will

first show the tree labeling in 3.1. Then, in 3.2, we

discuss the main algorithm.

3.1 Tree Labeling

Before we give our main algorithm, we first restate

how to label a tree to speed up the recognition of the

relationships among the nodes of trees.

Consider a tree T. By traversing T in preorder,

each node v will obtain a number (it can an integer

or a real number) pre(v) to record the order in which

the nodes of the tree are visited. In a similar way, by

traversing T in postorder, each node v will get

another number post(v). These two numbers can be

used to characterize the ancestor-descendant

relationships as follows.

Proposition 1. Let v and v’ be two nodes of a tree T.

Then, v’ is a descendant of v iff pre(v’) > pre(v) and

post(v’) < post(v).

Proof. See Exercise 2.3.2-20 in (Knuth, 1969).

If v’ is a descendant of v, then we know that

pre(v’) > pre(v) according to the preorder search.

Now we assume that post(v’) > post(v). Then,

according to the postorder search, either v’ is in

some subtree on the right side of v, or v is in the

subtree rooted at v’, which contradicts the fact that

v’ is a descendant of v. Therefore, post

(v’) must be

less than post(v). The following example helps for

illustration.

Example 1. See the pairs associated with the nodes

of the tree shown in Fig. 3. The first element of each

pair is the preorder number of the corresponding

node and the second is its postorder number. With

such labels, the ancestor-descendant relationships

can be easily checked.

Figure 3: Illustration for tree encoding.

For instance, by checking the label associated

with v

2

against the label for v

6

, we see that v

2

is an

ancestor of v

6

in terms of Proposition 1. Note that

v

2

’s label is (2, 6) and v

6

’s label is (6, 3), and we

have 2 < 6 and 6 > 3. We also see that since the pairs

associated with v

8

and v

5

do not satisfy the condition

given in Proposition 1, v

8

must not be an ancestor of

v

5

and vice versa.

Definition 2. (label pair subsumption) Let (p, q) and

(p’, q’) be two pairs associated with nodes u and v.

We say that (p, q) is subsumed by (p’, q’), denoted

(p, q) (p’, q’), if p > p’ and q < q’. Then, u is a

descendant of v if (p, q) is subsumed by (p’, q’).

In the following, we also use T[v] to represent a

subtree rooted at v in T.

3.2 Algorithm for Twig Pattern

Matching

Now we discuss our algorithm for twig pattern

matching. During the process, both T and Q are

searched bottom-up. That is, the nodes in T and Q

will be accessed along their postorder numbers.

Therefore, for convenience, we refer to the nodes in

T and Q by their postorder numbers, instead of their

node names.

In each step, we will check a node j in T against

all the nodes i in Q.

In order to know whether Q[i] can be embedded

into T[i], we will check whether the following two

conditions are satisfied.

1. label(j) = label(i).

2. Let i

1

, ..., i

k

be the child nodes of i. For each i

a

(a

= 1, ..., k), if (i, i

a

) is a c-edge, there exists a child

node j

b

of j such that T[j

b

] contains Q[i

a

]; if (i, i

a

)

is a d-edge, there is a descendent j’ of j such that

T[j’] contains Q[i

a

].

To facilitate this process, we will associate each j

in T with a set of nodes in Q: {i

1

, ..., i

j

} such that for

each i

a

∈ {i

1

, ..., i

j

} Q[i

a

] can be root-preservingly

embedded into T[j]. This set is denoted as M(j). In

addition, each i in Q is associated with a value β(i),

defined as below.

i) Initially, β(i) is set to φ.

ii) During the computation process, β(i) is

dynamically changed. Concretely, each time we

meet a node j in T, if i appears in M(j

b

) for some

child node j

b

of j, then β(i) is changed to j.

In terms of above discussion, we give the

following algorithm.

Algorithm tree-matching(T, Q)

Input: tree T (with nodes 0, 1, ..., |T|) and tree Q

(with nodes 1, ..., |Q|)

Output: a set of nodes j in T such that T[j] contains

Q.

begin

1. for j := 1, ..., |T| do

2. {let j

1

, ..., j

k

be the children of j;

3. for l := 1, ..., k do

4. {for each i’ ∈ M( j

l

) do β(i’) ← j;

5. remove Μ( j

l

);}

A v

1

B v

2

v

6

B

C v

3

v

4

B

v

5

C

(1, 8)

(2, 6)

(3, 1)

(4, 5)

(5, 2)

(8, 7)

v

5

C v

5

C

(6, 3)

(7, 4)

TREE EMBEDDING AND XML QUERY EVALUATION

175

5. for i := 1, ..., |Q| do

6. if label(i) = label(j) then

7. {let i

1

, ..., i

g

be the children of i;

8. if for each i

l

(l = 1, ..., g) we have

9. (i, i

l

) is a c-edge and β(i

l

) = j, or

10. (i, i

l

) is a d-edge and β(i

l

) is subsumed by j;

11. then {insert i into M(j);

12. if i is the root of Q, then report the

subtree rooted at j as an answer;}

13. }

end

In the above algorithm, each time we meet an j in

T, we will establish the new β values for all those

nodes of Q, which appear in

Μ

(j

1

), ...,

Μ

(j

k

), where

j

1

, ..., j

k

represent the child nodes of j (see lines 1 -

4). Then, all

Μ

(j

l

)’s (l = 1, ..., k) are removed. In a

next step, we will check j against all the nodes i in Q

(see lines 5 - 13). If label(i) = label(j), we will check

β(i

1

), ..., β(i

g

), where i

1

, ..., i

g

are the child nodes of i.

If (i, i

l

) (l ∈ {1, ..., g}) is a c-edge, we need to check

whether β(i

l

) = j (see line 9). If (i, i

l

) (l ∈ {1, ..., g})

is a d-edge, we simply check whether β(i

l

) is

subsumed by j (see line 10). If all the child nodes of

i survive the above checking, we get a root-

preserving embedding of the subtree rooted at i into

the subtree rooted at j. In this case, we will insert j

into M(j) (see line 11) and report j as one of the

answers if i is the root of Q (see line 12).

The time complexity of the algorithm can be

divided into two parts:

1. The first part is the time spent on generating β

values (see lines 2 - 5). For each node j in T, we

will access M(j

l

) for each child node j

l

of j.

Therefore, this part of cost is bounded by

O(

∑

=

⋅

||

1

|)(|

T

j

j

jMd ) ≤ Ο(

∑

=

⋅

||

1

||

T

j

j

Qd ) = O(|T|⋅|Q|),

where d

j

is the outdegree of j.

2. The second part is the time used for constructing

M(j)’s. For each node j in T, we need O(

∑

i

i

c )

time to do the task, where c

i

is the outdegree of i

in Q, which matches j. So this part of cost is

bounded by

O(

∑∑

ji

i

c ) ≤ O(

∑

=

||

1

||

T

j

Q ) = O(|T|⋅|Q|).

The space overhead of the algorithm is easy to

analyze. During the processing, each j in T will be

associated with a M(j). But M(j) will be removed

later once j’s parent is encountered and for each i

∈ M(j) its β value is changed. Therefore, the total

space is bounded by O(leaf

T

⋅|Q| + |T| + |Q|), where

leaf

T

represents the number of the leaf nodes of T. It

is because at any time point for any two nodes on the

same path in T only one is associated with a M.

4 GENERAL CASES

In this section, we extend the algorithm discussed in

the previous section to handle queries containing

‘∧’, ‘∨’ and ‘¬’ logic operators.

Without loss of generality, we assume that in an

XPath expression a predicate is a path, or a

conjunctive normal form. As an example, consider

the following XPath expression:

a[b[c and .//f]]/b[c or e//*]/g[not c].

This expression can be represented as an And-Or

tree Q shown in Fig. 4.

Figure 4: A query tree with different logic operators.

In such a tree, we distinguish between two kinds

of nodes:

- name nodes: nodes corresponding to the node

test.

- operator nodes: nodes labeled with ∧ or ∨.

As with a simple twig pattern, it may contain two

kinds of edges: /-edges and //-edges; but an edge

may be labeled with ‘¬’. If an edge (q, q’) is labeled

with ‘¬’, q’ is called a negative node; otherwise, q’

is called a positive node.

In an And-Or tree Q, the following conditions

always hold:

1. The child nodes of any ∨-node are name nodes.

2. The child nodes of any ∧-node are ∨-nodes.

3. Any name node has no children or has only one

node which is a ∧-node.

According to the above properties, the tree

embedding of Q into a document tree T can be

defined as follows.

a

∧

∨

∨

b

b

∧

∧

∨

∨

∨

∨

c

f

c

e

g

∧

∧

∨

∨

c

*

¬

output node

ICEIS 2008 - International Conference on Enterprise Information Systems

176

Let i be a node in Q with child nodes i

1

, ..., i

k

. Let

j be a node in T with child nodes j

1

, ..., j

l

.

(i) If i is a ∨-node, T[j] contains Q[i] if one of the

following conditions holds:

- There exists a positive //-child q

a

(1 ≤ a

≤

k)

such that T[j] contains Q[i

a

].

- There exists a positive /-child i

a

(1 ≤ a

≤

k) such

that T[j] contains Q[i

a

] and label(j) = label(i

a

).

- There exists a negative //-child i

a

(1 ≤ a

≤

k)

such that T[j] does not contain Q[i

a

].

- There exists a negative /-child i

a

(1 ≤ a

≤

k) such

that T[j] does not contain Q[i

a

] or T[j] contains

Q[i

a

] but label(j) ≠ label(i

a

).

(ii) If i is a ∧-node, T[j] contains Q[i] if the

following conditions hold:

- for every positive node i

a

(1 ≤ a

≤

k), there

exists a j

b

(1 ≤ b

≤

l) such that T[j

b

] contains

Q[i

a

].

- for every nagative node i

a

(1 ≤ a

≤

k), there

exists no j

b

(1 ≤ b

≤

l) such that T[j

b

] contains

Q[i

a

].

(iii) If i is a name node, T[j] contains Q[i] if the

following conditions hold:

- T[j] contains Q[i

1

] (i has only one child node i

1

.)

- label(j) = label(i).

In the following, we give an algorithm to check

the embedding of an And-Or tree Q into a document

tree T. For this purpose, we associate with each j in

T two sets: (j) and H(j). F(j) contains all those name

nodes i in Q such that Q[i] can be imbedded into

T[j]; and H(j). contains all those ∨-nodes i in Q such

that Q[i] can be imbedded into T[j]. Besides, in order

to calculate H(j), we maintain an array N

Q

containing

all the negative nodes in Q.

With F(j) and H(j), we design our general algorithm,

in which three functions are called:

- general-node-check(j, i): It checks whether T[j]

contains Q[i]. If it is the case, return {i}.

Otherwise, it returns an empty set ∅.

- leaf-node-check(j): It returns a set of leaf nodes in

Q: {i

1

, ..., i

k

} such that for each i

a

(1 ≤ a

≤

k)

label(j) = label(i

a

).

- calculate-H(j, F(j)): It compute H(j) based on F(j)

and N

Q

. It is done exactly according to the

conditions given above for checking ∨-node

containment. Especially, in the presence of ‘¬’,

we have to check each negative node in N

Q

to see

whether it appears in F(j).~

Algorithm general-tree-embedding(v)

Input: tree T (with nodes 0, 1, ..., |T|) and tree Q

(with nodes 1, ..., |Q|)

Output: a set of nodes j in T such that T[j] contains

Q.

begin

1. for j := 1, ..., |T| do

2. {if j is not a leaf node in T then

3. {let j

1

, ..., j

k

be the children of j;

3. for l := 1, ..., k do

4. {for each i’ ∈ H( j

l

) do β(i’) ← j;}

5. F ← merge(F(j

1

), ..., F(j

k

)); (*See (Chen,

2007) for the definition of the merge operation.*)

6. assume that F = { i

1

, ..., i

c

};

7. S

1

:= ∅; S

2

:= ∅;

5. for i := 1, ..., |Q| do

6. S

1

:= S

1

∪ general-node-check(j, i);

15. }

16. S

2

:= leaf-node-check(j);

17. F(j) := merge(F, S

1

, S

2

);

18. call calculate-H(j, F(j));

end

Function leaf-node-check(j)

begin

1. S

2

:= ∅;

2. for each leaf node i in Q do

3. {if label(i) = label(j) then {S

2

:= S

2

∪ {i};

4. if i is root then mark j;}

5. return S

2

;

end

Function general-node-check(j, i)

begin

1. S

1

:= ∅;

2. if label(i’s parent) = label(j) then

(*If i is *, the checking is always successful.*)

3. { let i

1

, ..., i

k

be the child nodes of i;

4. if for each i

a

(a = 1, ..., k) β(i

a

) is equal to j

5. then {S

1

:= {i};

6. if i’s parent is root then mark j;}}

7. return S

1

;

end

Function calculate-H(j, F)

begin

1. H := ∅; A := ∅;

2. for each i ∈ F do {

3. if ((i is a /-child and label(i) = label(j)) or

4. i is a //-child)

5. then H := H ∪ {i’s parent});

6. }

7. for each i’ ∈ N

Q

do {

8. if (i’ ∉ F or (i’ ∈ F and

i’ is a /-child with label(i’) ≠ label(j)))

9. then A := A ∪ {i’s parent};}

10. return merge(H, A);

end

Algorithm general-tree-embedding( ) is similar to

Algorithm tree-embedding( ). The only difference is

that M(j) in tree-embedding( ) is replaced with F(j)

TREE EMBEDDING AND XML QUERY EVALUATION

177

in general-tree-embedding( ). In F(j), we maintain

all those query nodes i such that Q[i] can be

embedded (not only root-preservingly embedded) in

T[j]. Although more time is needed for this, the

whole time complexity remains unchanged. See line

5, in which the merge operation is first introduced in

(Chen, 2007). The time complexity of

merge(F(j

1

), ..., F(j

k

)) is bounded by O(k⋅leaf

Q

).

Special attention should be paid to Function general-

node-check( ). It is used to check ∧-nodes in Q.

Since each name node has only one ∧-node as its

child, the checking of name nodes is integrated into

this process to simplify the procedure (see line 2 in

this function.)

In Function calculate-H(j, F(j)), we compute H(j)

based on F(j). It is done exactly according to the

conditions given above for checking ∨-node

containment. Especially, in the presence of ‘¬’, we

have to check each negative node in N

Q

to see

whether it appears in F(j). (see lines 7 - 9 in this

function). It needs O(|N

Q

|⋅log|F(j)|) time. So the total

time of the algorithm is bounded by O(|T|⋅leaf

Q

+

|N

Q

|⋅|T|⋅logleaf

Q

).

5 CONCLUSIONS

In this paper, a new algorithm is proposed to

evaluate twig pattern queries in XML document

databases. The algorithm works in a bottom-up way,

by which an important property of the postorder

numbering is used to avoid join or join-like

operations. The time complexity and the space

complexity of the algorithm are bounded by

O(|T|⋅|Q|) and O(|Q|⋅leaf

T

), respectively, where T is

the document tree and Q the twig pattern query, and

leaf

T

represents the number of leaf nodes in T.

Experiments have been done to compare our method

with some existing strategies, which demonstrates

that our method is highly promising in evaluating

twig pattern queries.

ACKNOWLEDGEMENTS

The work is supported by NSERC 239074-01

(242523) (Natural Science and Engineering Council

of Canada).

REFERENCES

A. Aghili, H. Li, D. Agrawal (2006). and A.E. Abbadi,

TWIX: Twig structure and content matching of

selective queries using binary labeling, in:

INFOSCALE, 2006.

N. Bruno, N. Koudas, and D. Srivastava (2002) Holistic

Twig Hoins: Optimal XML Pattern Matching, in Proc.

SIGMOD Int. Conf. on Management of Data

,

Madison, Wisconsin, June 2002, pp. 310-321.

C. Chung, J. Min, and K. Shim (2002). APEX: An

adaptive path index for XML data,

ACM SIGMOD,

June 2002.

S. Chen et al. (2006). Twig

2

Stack: Bottom-up Processing

of Generalized-Tree-Pattern Queries over XML

Documents, in Proc. VLDB, Seoul, Korea, Sept. 2006,

pp. 283-323.

Y. Chen (2007). A New Algorithm for Tree Mapping in

XML Databases, in Proc. of the Internet and

Multimedia Systems and Applications Conference

(IMSA 2007), Honolulu, Hawaii, USA.

B.F. Cooper, N. Sample (2001). M. Franklin, A.B.

Hialtason, and M. Shadmon, A fast index for

semistructured data, in: Proc. VLDB, Sept. 2001, pp.

341-350.

R. Goldman and J. Widom (1997). DataGuide: Enable

query formulation and optimization in semistructured

databases, in: Proc. VLDB, Aug. 1997, pp. 436-445.

G. Gottlob, C. Koch, and R. Pichler (2005). Efficient

Algorithms for Processing XPath Queries, ACM

Transaction on Database Systems

, Vol. 30, No. 2,

June 2005, pp. 444-491.

C.M. Hoffmann and M.J. O’Donnell (1982). Pattern

matching in trees,

J. ACM, 29(1):68-95, 1982.

Q. Li and B. Moon (2001) Indexing and Querying XML

data for regular path expressions, in: Proc. VLDB,

Sept. 2001, pp. 361-370.

J. Lu, T.W. Ling, C.Y. Chan, and T. Chan (2005). From

Region Encoding to Extended Dewey: on Efficient

Processing of XML Twig Pattern Matching, in: Proc.

VLDB

, pp. 193 - 204, 2005.

G. Miklau and D. Suciu (2004) Containment and

Equivalence of a Fragment of XPath, J. ACM, 51(1):2-

45, 2004.

H. Wang, S. Park, W. Fan, and P.S. Yu (2003) ViST: A

Dynamic Index Method for Querying XML Data by

Tree Structures,

SIGMOD Int. Conf. on Management

of Data

, San Diego, CA., June 2003.

H. Wang and X. Meng (2005), On the Sequencing of Tree

Structures for XML Indexing, in Proc. Conf. Data En-

gineering

, Tokyo, Japan, April, 2005, pp. 372-385.

R. Kaushik, P. Bohannon, J. Naughton, and H. Korth

(2002) Covering indexes for branching path queries,

in:

ACM SIGMOD, June 2002.

ICEIS 2008 - International Conference on Enterprise Information Systems

178