org.basex.query.up

Class Updates

java.lang.Object

org.basex.query.up.Updates

public final class Updates
extends java.lang.Object

***** Implementation of the W3C XQUERY UPDATE FACILITY 1.0 ***** Holds all update operations and primitives a snapshot contains, checks constraints and finally executes the updates. Fragment updates are treated like database updates. An artificial data instance is created for each fragment. Ultimately the updating process for a fragment is the same as for a database node. The complete updating process is custom-tailored to the sequential table encoding of BaseX. As a general rule, all updates are collected and applied for each database from bottom to top, regarding the PRE values of the corresponding target nodes. Updates on the highest pre values are applied first. ***** Updates work like the following: ***** 1. Each call of an updating expression creates an UpdatePrimitive 2. All update primitives for a snapshot/query are collected here 3. Primitives are kept separately for each database that is addressed. This way we can operate on PRE values instead of node IDs, skip mapping overhead and further optimize the update process. DatabaseUpdates 4. Primitives are further kept separately for each database node - each individual target PRE value. There's a specific container for this: NodeUpdates 5. Transform expressions are executed in an 'isolated' updating environment, see TransformModifier. All the other updates are executed by a DatabaseModifier. 6. Fn:put statements are treated exactly like an update primitive. They are represented by an update primitive. 7. After the query has been parsed and all update primitives have been added to the list, constraints, which cannot be taken care of on the fly, are checked. If no problems occur, updates are TO BE carried out. 8. Updates are carried out separately for each database, the following way: 1. Update primitives are sorted by the PRE value of their target node in a descending manner. Applying updates from the highest to the lowest PRE value ensures that updates, not-yet carried out, are not affected by PRE value shifts. PRE value shifts are a result of structural changes of the table - which occur each time a node is inserted or deleted, for more see PrimitiveType. 2. For each specific target node, updates which are collected in a NodeUpdates container are executed in a specific order, depending on their type PrimitiveType. This order relates more or less to the XQUF specification, at least it leads to the same result. 3. Neighboring text nodes have to be merged together (see XQuery Data Model). Adjacent text nodes can only be a result of structural updates. With our approach this takes some extra effort, but can be carried out on-the-fly, applying the two following steps: 1. An NodeUpdates container holds all update primitives for a specific database node N. If all updates with target N (all updates in the current container) are carried out, text node adjacency can only occur on the child axis, or the sibling axis of N. Regarding adjacency on the child axis, this can be taken care off by first applying all updates on this axis and subsequently checking the affected PRE positions for adjacent text nodes. The sibling axis of N can only be checked for adjacent text nodes after an eventual left sibling target container has executed its updates. Example: We have two siblings A(1) and B(2). A is a text node, B is an element. The numbers in brackets are their PRE values. If A is target of a delete primitive and B is target of an insert before primitive (text 'foo' is inserted) the following happens: insert before is executed on B, A is deleted, location around B is checked for adjacent text nodes. No merges occur. We repeat this for every target node and only apply text node merges if updates of the next container have been carried out. If we would carry out text merges immediately, the following (which leads to inconsistency) happens: insert before is executed on B, 'foo' is adjacent to A and therefore the two nodes are merged together, A is finally deleted. As a result we loose the text node 'foo' during the process, as it is merged with A and subsequently deleted together with A (consider the pre value shifts!). XQUF SPECIALTIES WITH BASEX Fn:put: the target node of an fn:put statement cannot be deleted, but it can be among the deleted nodes as a result of a 'replace element content' statement.

Author:

BaseX Team 2005-12, BSD License, Lukas Kircher

Field Summary

Fields

Modifier and Type	Field and Description
ContextModifier	mod Current context modifier.

Constructor Summary

Constructors

Constructor and Description
Updates()

Method Summary

Methods

Modifier and Type	Method and Description
void	add(UpdatePrimitive up, QueryContext ctx) Adds an update primitive to the current context modifier.
void	apply() Executes all updates.
DBNode	determineDataRef(ANode target, QueryContext ctx) Determines the data reference and pre value for an update primitive which has a fragment as a target node.
int	size() Number of updates on the pending update list.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

mod

public ContextModifier mod

Current context modifier.

Constructor Detail

Updates

public Updates()

Method Detail

add

public void add(UpdatePrimitive up,
       QueryContext ctx)
         throws QueryException

Adds an update primitive to the current context modifier.

Parameters:

up - update primitive

ctx - query context

Throws:

QueryException - query exception

determineDataRef

public DBNode determineDataRef(ANode target,
                      QueryContext ctx)

Determines the data reference and pre value for an update primitive which has a fragment as a target node. If an ancestor of the given target node has already been added to the pending update list, the corresponding data reference and the pre value of the given target node within this database table are calculated. Otherwise a new data instance is created.

Parameters:

target - target fragment

ctx - query context

Returns:

database node created from input fragment

apply

public void apply()
           throws QueryException

Executes all updates.

Throws:

QueryException - query exception

size

public int size()

Number of updates on the pending update list.

Returns:

#updates