This implements the W3C copy-namespaces {@code no-preserve} semantics: + * only namespace bindings that are used by element/attribute names are preserved.
+ * + *Works by invalidating unused namespace array entries (setting parent to -2) + * and re-adding only used ones. The invalidated entries are dead space that + * is cleaned up on the next {@link #compact()} call.
+ * + * @param rootNodeNum the root element node number of the subtree to process + */ + public void stripUnusedNamespacesInSubtree(final int rootNodeNum) { + if (namespaceCode == null) { + return; + } + // Walk the subtree: process rootNodeNum and all descendants at deeper levels + final short rootLevel = treeLevel[rootNodeNum]; + for (int i = rootNodeNum; i < size; i++) { + if (i > rootNodeNum && treeLevel[i] <= rootLevel) { + break; // past the subtree + } + if (nodeKind[i] != ELEMENT_NODE) { + continue; + } + stripUnusedNamespacesForElement(i); + } + } + + private void stripUnusedNamespacesForElement(final int nodeNum) { + int ns = alphaLen[nodeNum]; + if (ns < 0) { + return; // no namespace declarations + } + + // Collect used prefixes: element name + attribute names + final java.util.SetLocks are acquired in a consistent order (TreeSet natural ordering) + * to prevent deadlocks.
+ * + * @throws LockException if lock acquisition fails + */ + public void preclaimLocks() throws LockException { + if (preclaimDocumentTargets == null) { + return; + } + final org.exist.storage.lock.LockManager lockManager = + getBroker().getBrokerPool().getLockManager(); + + if (preclaimRequiresGlobalLock) { + // Fall back to global collection write lock on /db + preclaimedLocks.add(lockManager.acquireCollectionWriteLock(XmldbURI.ROOT_COLLECTION_URI)); + } else { + // Acquire collection write locks first (sorted order) + for (final XmldbURI collectionUri : preclaimCollectionTargets) { + preclaimedLocks.add(lockManager.acquireCollectionWriteLock(collectionUri)); + } + // Then acquire document write locks (sorted order) + for (final XmldbURI docUri : preclaimDocumentTargets) { + preclaimedLocks.add(lockManager.acquireDocumentWriteLock(docUri)); + } + } + } + + /** + * Release all preclaimed locks. Should be called in a finally block + * after query evaluation completes. + */ + public void releasePreclaimedLocks() { + // Release in reverse order of acquisition + for (int i = preclaimedLocks.size() - 1; i >= 0; i--) { + try { + preclaimedLocks.get(i).close(); + } catch (final Exception e) { + LOG.warn("Error releasing preclaimed lock", e); + } + } + preclaimedLocks.clear(); + } + + /** + * Returns true if preclaimed locks are currently held. + */ + public boolean hasPreclaimedLocks() { + return !preclaimedLocks.isEmpty(); + } + @Override public void setShared(final boolean shared) { isShared = shared; @@ -1407,6 +1517,59 @@ public void addModifiedDoc(final DocumentImpl document) { modifiedDocuments.add(document); } + /** + * Get the W3C XQuery Update Facility 3.0 Pending Update List for this context. + * + * @return the current pending update list + */ + public PendingUpdateList getPendingUpdateList() { + return pendingUpdateList; + } + + /** + * Set the Pending Update List. Used by copy-modify expressions to create + * a nested PUL scope. + * + * @param pul the new pending update list + */ + public void setPendingUpdateList(final PendingUpdateList pul) { + this.pendingUpdateList = pul; + } + + /** + * Mark that the current module uses the legacy eXist-db update syntax. + * Called during tree walking when a legacy update expression is encountered. + * + * @param ast the AST node for error reporting + * @throws XPathException if this module already uses W3C XQUF syntax + */ + public void markLegacyUpdate(final XQueryAST ast) throws XPathException { + if (hasXQUFUpdate) { + throw new XPathException(ast, ErrorCodes.XPST0003, + "Cannot mix legacy 'update' syntax with W3C XQuery Update Facility expressions " + + "in the same module. Migrate all updates to W3C syntax " + + "(insert node, delete node, replace node, replace value of node, rename node)."); + } + hasLegacyUpdate = true; + } + + /** + * Mark that the current module uses W3C XQuery Update Facility 3.0 syntax. + * Called during tree walking when a XQUF expression is encountered. + * + * @param ast the AST node for error reporting + * @throws XPathException if this module already uses legacy update syntax + */ + public void markXQUFUpdate(final XQueryAST ast) throws XPathException { + if (hasLegacyUpdate) { + throw new XPathException(ast, ErrorCodes.XPST0003, + "Cannot mix W3C XQuery Update Facility expressions with legacy 'update' syntax " + + "in the same module. Migrate all updates to W3C syntax " + + "(insert node, delete node, replace node, replace value of node, rename node)."); + } + hasXQUFUpdate = true; + } + @Override public void reset() { reset(false); @@ -1440,6 +1603,13 @@ public void reset(final boolean keepGlobals) { modifiedDocuments = null; } + // Reset the W3C XQuery Update Facility PUL + pendingUpdateList = new PendingUpdateList(); + + // Reset update syntax tracking flags + hasLegacyUpdate = false; + hasXQUFUpdate = false; + calendar = null; implicitTimeZone = null; diff --git a/exist-core/src/main/java/org/exist/xquery/functions/fn/FunInScopePrefixes.java b/exist-core/src/main/java/org/exist/xquery/functions/fn/FunInScopePrefixes.java index b7e319b5470..f002ca11bc5 100644 --- a/exist-core/src/main/java/org/exist/xquery/functions/fn/FunInScopePrefixes.java +++ b/exist-core/src/main/java/org/exist/xquery/functions/fn/FunInScopePrefixes.java @@ -116,7 +116,7 @@ public static MapStatic targets (string literal arguments to fn:doc, fn:collection) + * are collected as specific URIs. If any document/collection reference + * is dynamic (non-literal argument), {@link #requiresGlobalLock()} returns + * true, indicating that a global write lock is needed as a safe fallback.
+ * + *Traversal strategy: each visit method handles the specific expression + * type and then calls {@link #traverseSubExpressions(Expression)} to + * recurse into children. This ensures the entire tree is walked even for + * expression types that don't explicitly delegate in their {@code accept()} + * method.
+ */ +public class LockTargetCollector extends BasicExpressionVisitor { + + private static final String FN_NS = Function.BUILTIN_FUNCTION_NS; + + private final Set
+ * DeleteExpr ::= "delete" ("node" | "nodes") TargetExpr
+ *
+ */
+public class XQUFDeleteExpr extends AbstractExpression {
+
+ private final Expression target;
+
+ public XQUFDeleteExpr(final XQueryContext context, final Expression target) {
+ super(context);
+ this.target = target;
+ }
+
+ @Override
+ public void analyze(final AnalyzeContextInfo contextInfo) throws XPathException {
+ if (contextInfo.hasFlag(NON_UPDATING_CONTEXT)) {
+ throw new XPathException(this, ErrorCodes.XUST0001,
+ "delete expression is not allowed in a non-updating context");
+ }
+ // Target expression of delete is a non-updating context
+ final AnalyzeContextInfo subInfo = new AnalyzeContextInfo(contextInfo);
+ subInfo.setParent(this);
+ subInfo.addFlag(IN_UPDATE);
+ subInfo.addFlag(NON_UPDATING_CONTEXT);
+ target.analyze(subInfo);
+ }
+
+ @Override
+ public Sequence eval(final Sequence contextSequence, final Item contextItem) throws XPathException {
+ if (context.getProfiler().isEnabled()) {
+ context.getProfiler().start(this);
+ }
+
+ final Sequence ctxSeq = contextItem != null ? contextItem.toSequence() : contextSequence;
+ final Sequence targetSeq = target.eval(ctxSeq, null);
+
+ if (!targetSeq.isEmpty()) {
+ final PendingUpdateList pul = context.getPendingUpdateList();
+ for (final SequenceIterator i = targetSeq.iterate(); i.hasNext(); ) {
+ final Item item = i.nextItem();
+ if (!Type.subTypeOf(item.getType(), Type.NODE)) {
+ throw new XPathException(this, ErrorCodes.XUTY0007,
+ "Target of delete expression must be a node.");
+ }
+ final NodeValue nv = (NodeValue) item;
+ pul.addPrimitive(UpdatePrimitive.delete(nv.getNode(), this));
+ }
+ }
+
+ if (context.getProfiler().isEnabled()) {
+ context.getProfiler().end(this, "", Sequence.EMPTY_SEQUENCE);
+ }
+
+ return Sequence.EMPTY_SEQUENCE;
+ }
+
+ @Override
+ public boolean isUpdating() {
+ return true;
+ }
+
+ @Override
+ public int returnsType() {
+ return Type.EMPTY_SEQUENCE;
+ }
+
+ @Override
+ public Cardinality getCardinality() {
+ return Cardinality.EMPTY_SEQUENCE;
+ }
+
+ @Override
+ public void resetState(final boolean postOptimization) {
+ super.resetState(postOptimization);
+ target.resetState(postOptimization);
+ }
+
+ @Override
+ public void dump(final ExpressionDumper dumper) {
+ dumper.display("delete node ");
+ target.dump(dumper);
+ }
+
+ @Override
+ public String toString() {
+ return "delete node " + target.toString();
+ }
+}
diff --git a/exist-core/src/main/java/org/exist/xquery/xquf/XQUFFnPut.java b/exist-core/src/main/java/org/exist/xquery/xquf/XQUFFnPut.java
new file mode 100644
index 00000000000..66ec90bac29
--- /dev/null
+++ b/exist-core/src/main/java/org/exist/xquery/xquf/XQUFFnPut.java
@@ -0,0 +1,66 @@
+/*
+ * eXist-db Open Source Native XML Database
+ * Copyright (C) 2001 The eXist-db Authors
+ *
+ * info@exist-db.org
+ * http://www.exist-db.org
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+package org.exist.xquery.xquf;
+
+import org.exist.dom.QName;
+import org.exist.xquery.*;
+import org.exist.xquery.value.*;
+
+/**
+ * W3C XQuery Update Facility 3.0 - fn:put function.
+ *
+ * + * fn:put($node as node(), $uri as xs:string) as empty-sequence() + *+ * + * Adds a put primitive to the PUL for deferred persistence. + */ +public class XQUFFnPut extends BasicFunction { + + public static final FunctionSignature SIGNATURE = new FunctionSignature( + new QName("put", Function.BUILTIN_FUNCTION_NS, "fn"), + "Stores a document node to a specified URI. The actual storage is deferred " + + "to the end of the snapshot (pending update list application).", + new SequenceType[]{ + new FunctionParameterSequenceType("node", Type.NODE, Cardinality.EXACTLY_ONE, + "The node to store"), + new FunctionParameterSequenceType("uri", Type.STRING, Cardinality.EXACTLY_ONE, + "The URI where the node should be stored") + }, + new SequenceType(Type.EMPTY_SEQUENCE, Cardinality.EMPTY_SEQUENCE) + ); + + public XQUFFnPut(final XQueryContext context) { + super(context, SIGNATURE); + } + + @Override + public Sequence eval(final Sequence[] args, final Sequence contextSequence) throws XPathException { + final NodeValue node = (NodeValue) args[0].itemAt(0); + final String uri = args[1].getStringValue(); + + final PendingUpdateList pul = context.getPendingUpdateList(); + pul.addPrimitive(UpdatePrimitive.put(node.getNode(), uri, this)); + + return Sequence.EMPTY_SEQUENCE; + } +} diff --git a/exist-core/src/main/java/org/exist/xquery/xquf/XQUFInsertExpr.java b/exist-core/src/main/java/org/exist/xquery/xquf/XQUFInsertExpr.java new file mode 100644 index 00000000000..86495906ef7 --- /dev/null +++ b/exist-core/src/main/java/org/exist/xquery/xquf/XQUFInsertExpr.java @@ -0,0 +1,307 @@ +/* + * eXist-db Open Source Native XML Database + * Copyright (C) 2001 The eXist-db Authors + * + * info@exist-db.org + * http://www.exist-db.org + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ +package org.exist.xquery.xquf; + +import org.exist.xquery.*; +import org.exist.xquery.util.ExpressionDumper; +import org.exist.xquery.value.*; +import org.w3c.dom.Node; + +/** + * W3C XQuery Update Facility 3.0 - insert expression. + * + *
+ * InsertExpr ::= "insert" ("node" | "nodes") SourceExpr InsertExprTargetChoice TargetExpr
+ * InsertExprTargetChoice ::= (("as" ("first" | "last"))? "into") | "after" | "before"
+ *
+ */
+public class XQUFInsertExpr extends AbstractExpression {
+
+ public static final int INSERT_INTO = 0;
+ public static final int INSERT_INTO_AS_FIRST = 1;
+ public static final int INSERT_INTO_AS_LAST = 2;
+ public static final int INSERT_BEFORE = 3;
+ public static final int INSERT_AFTER = 4;
+
+ private final Expression source;
+ private final Expression target;
+ private final int mode;
+
+ public XQUFInsertExpr(final XQueryContext context, final Expression source,
+ final Expression target, final int mode) {
+ super(context);
+ this.source = source;
+ this.target = target;
+ this.mode = mode;
+ }
+
+ @Override
+ public void analyze(final AnalyzeContextInfo contextInfo) throws XPathException {
+ if (contextInfo.hasFlag(NON_UPDATING_CONTEXT)) {
+ throw new XPathException(this, ErrorCodes.XUST0001,
+ "insert expression is not allowed in a non-updating context");
+ }
+ // Source and target expressions of insert are non-updating contexts
+ final AnalyzeContextInfo subInfo = new AnalyzeContextInfo(contextInfo);
+ subInfo.setParent(this);
+ subInfo.addFlag(IN_UPDATE);
+ subInfo.addFlag(NON_UPDATING_CONTEXT);
+ source.analyze(subInfo);
+ target.analyze(subInfo);
+ }
+
+ @Override
+ public Sequence eval(final Sequence contextSequence, final Item contextItem) throws XPathException {
+ if (context.getProfiler().isEnabled()) {
+ context.getProfiler().start(this);
+ }
+
+ final Sequence ctxSeq = contextItem != null ? contextItem.toSequence() : contextSequence;
+
+ // Evaluate source expression (content to insert)
+ final Sequence sourceSeq = source.eval(ctxSeq, null);
+ if (sourceSeq.isEmpty()) {
+ return Sequence.EMPTY_SEQUENCE;
+ }
+
+ // Evaluate target expression
+ final Sequence targetSeq = target.eval(ctxSeq, null);
+
+ // XUDY0027: target must not be empty
+ if (targetSeq.isEmpty()) {
+ throw new XPathException(this, ErrorCodes.XUDY0027,
+ "Target of insert expression must not be an empty sequence.");
+ }
+
+ // Target must be a single node
+ if (targetSeq.getItemCount() != 1 || !Type.subTypeOf(targetSeq.itemAt(0).getType(), Type.NODE)) {
+ if (mode == INSERT_INTO || mode == INSERT_INTO_AS_FIRST || mode == INSERT_INTO_AS_LAST) {
+ // XUTY0005: target of insert-into must be single element or document
+ throw new XPathException(this, ErrorCodes.XUTY0005,
+ "Target of insert into expression must be a single element or document node.");
+ } else {
+ // XUTY0006: target of insert-before/after must be single element/text/comment/PI
+ throw new XPathException(this, ErrorCodes.XUTY0006,
+ "Target of insert before/after expression must be a single element, text, comment, or processing instruction node.");
+ }
+ }
+
+ final NodeValue targetNode = (NodeValue) targetSeq.itemAt(0);
+ final Node domTarget = targetNode.getNode();
+ final int targetType = domTarget.getNodeType();
+
+ // Validate target and source based on insert mode
+ switch (mode) {
+ case INSERT_INTO:
+ case INSERT_INTO_AS_FIRST:
+ case INSERT_INTO_AS_LAST:
+ // XUTY0005: target must be element or document
+ if (targetType != Node.ELEMENT_NODE && targetType != Node.DOCUMENT_NODE) {
+ throw new XPathException(this, ErrorCodes.XUTY0005,
+ "Target of insert into expression must be an element or document node.");
+ }
+
+ // XUTY0004: source must not have attribute after non-attribute
+ {
+ boolean seenNonAttribute = false;
+ for (final SequenceIterator i = sourceSeq.iterate(); i.hasNext(); ) {
+ final Item item = i.nextItem();
+ if (Type.subTypeOf(item.getType(), Type.NODE)
+ && ((NodeValue) item).getNode().getNodeType() == Node.ATTRIBUTE_NODE) {
+ if (seenNonAttribute) {
+ throw new XPathException(this, ErrorCodes.XUTY0004,
+ "In the source of an insert expression, attribute nodes must not follow non-attribute nodes.");
+ }
+ } else {
+ seenNonAttribute = true;
+ }
+ }
+ }
+
+ // XUTY0022: cannot insert attributes into document node
+ if (targetType == Node.DOCUMENT_NODE) {
+ for (final SequenceIterator i = sourceSeq.iterate(); i.hasNext(); ) {
+ final Item item = i.nextItem();
+ if (Type.subTypeOf(item.getType(), Type.NODE)
+ && ((NodeValue) item).getNode().getNodeType() == Node.ATTRIBUTE_NODE) {
+ throw new XPathException(this, ErrorCodes.XUTY0022,
+ "Cannot insert attribute nodes into a document node.");
+ }
+ }
+ }
+ break;
+
+ case INSERT_BEFORE:
+ case INSERT_AFTER:
+ // XUTY0006: target must be element, text, comment, or PI (not document or attribute)
+ if (targetType == Node.DOCUMENT_NODE || targetType == Node.ATTRIBUTE_NODE) {
+ throw new XPathException(this, ErrorCodes.XUTY0006,
+ "Target of insert before/after must be an element, text, comment, or processing instruction node.");
+ }
+
+ // XUDY0029: target must have a parent
+ if (domTarget.getParentNode() == null) {
+ throw new XPathException(this, ErrorCodes.XUDY0029,
+ "Target of insert before/after must have a parent node.");
+ }
+
+ // Checks when parent is document node
+ if (domTarget.getParentNode().getNodeType() == Node.DOCUMENT_NODE) {
+ // XUDY0030: cannot insert attribute before/after node whose parent is document
+ for (final SequenceIterator i = sourceSeq.iterate(); i.hasNext(); ) {
+ final Item item = i.nextItem();
+ if (Type.subTypeOf(item.getType(), Type.NODE)
+ && ((NodeValue) item).getNode().getNodeType() == Node.ATTRIBUTE_NODE) {
+ throw new XPathException(this, ErrorCodes.XUDY0030,
+ "Cannot insert attribute node before/after a node whose parent is a document node.");
+ }
+ }
+ // XUDY0027: target is root element or root text of a document
+ if (targetType == Node.ELEMENT_NODE || targetType == Node.TEXT_NODE) {
+ throw new XPathException(this, ErrorCodes.XUDY0027,
+ "Target of insert before/after is a root element or root text node of a document.");
+ }
+ }
+ break;
+ }
+
+ // Add to PUL
+ final PendingUpdateList pul = context.getPendingUpdateList();
+ final UpdatePrimitive.Type primType = switch (mode) {
+ case INSERT_INTO -> UpdatePrimitive.Type.INSERT_INTO;
+ case INSERT_INTO_AS_FIRST -> UpdatePrimitive.Type.INSERT_INTO_AS_FIRST;
+ case INSERT_INTO_AS_LAST -> UpdatePrimitive.Type.INSERT_INTO_AS_LAST;
+ case INSERT_BEFORE -> UpdatePrimitive.Type.INSERT_BEFORE;
+ case INSERT_AFTER -> UpdatePrimitive.Type.INSERT_AFTER;
+ default -> UpdatePrimitive.Type.INSERT_INTO;
+ };
+
+ // Separate attribute and non-attribute content
+ if (mode == INSERT_INTO || mode == INSERT_INTO_AS_FIRST || mode == INSERT_INTO_AS_LAST) {
+ // For into modes: attributes go as INSERT_ATTRIBUTES on target element
+ if (domTarget.getNodeType() == Node.ELEMENT_NODE) {
+ final ValueSequence attrContent = new ValueSequence();
+ final ValueSequence otherContent = new ValueSequence();
+ for (final SequenceIterator i = sourceSeq.iterate(); i.hasNext(); ) {
+ final Item item = i.nextItem();
+ if (Type.subTypeOf(item.getType(), Type.NODE)
+ && ((NodeValue) item).getNode().getNodeType() == Node.ATTRIBUTE_NODE) {
+ attrContent.add(item);
+ } else {
+ otherContent.add(item);
+ }
+ }
+ if (!attrContent.isEmpty()) {
+ pul.addPrimitive(new UpdatePrimitive(UpdatePrimitive.Type.INSERT_ATTRIBUTES,
+ domTarget, attrContent, null, null, this));
+ }
+ if (!otherContent.isEmpty()) {
+ pul.addPrimitive(new UpdatePrimitive(primType, domTarget, otherContent, null, null, this));
+ }
+ } else {
+ pul.addPrimitive(new UpdatePrimitive(primType, domTarget, sourceSeq, null, null, this));
+ }
+ } else if (mode == INSERT_BEFORE || mode == INSERT_AFTER) {
+ // For before/after modes: per W3C spec, attribute nodes in source are
+ // added to the PARENT element of the target node
+ final ValueSequence attrContent = new ValueSequence();
+ final ValueSequence otherContent = new ValueSequence();
+ for (final SequenceIterator i = sourceSeq.iterate(); i.hasNext(); ) {
+ final Item item = i.nextItem();
+ if (Type.subTypeOf(item.getType(), Type.NODE)
+ && ((NodeValue) item).getNode().getNodeType() == Node.ATTRIBUTE_NODE) {
+ attrContent.add(item);
+ } else {
+ otherContent.add(item);
+ }
+ }
+ if (!attrContent.isEmpty()) {
+ // Attributes go to the parent element
+ final Node parentNode = domTarget.getParentNode();
+ pul.addPrimitive(new UpdatePrimitive(UpdatePrimitive.Type.INSERT_ATTRIBUTES,
+ parentNode, attrContent, null, null, this));
+ }
+ if (!otherContent.isEmpty()) {
+ pul.addPrimitive(new UpdatePrimitive(primType, domTarget, otherContent, null, null, this));
+ }
+ } else {
+ pul.addPrimitive(new UpdatePrimitive(primType, domTarget, sourceSeq, null, null, this));
+ }
+
+ if (context.getProfiler().isEnabled()) {
+ context.getProfiler().end(this, "", Sequence.EMPTY_SEQUENCE);
+ }
+
+ return Sequence.EMPTY_SEQUENCE;
+ }
+
+ @Override
+ public boolean isUpdating() {
+ return true;
+ }
+
+ @Override
+ public int returnsType() {
+ return Type.EMPTY_SEQUENCE;
+ }
+
+ @Override
+ public Cardinality getCardinality() {
+ return Cardinality.EMPTY_SEQUENCE;
+ }
+
+ @Override
+ public void resetState(final boolean postOptimization) {
+ super.resetState(postOptimization);
+ source.resetState(postOptimization);
+ target.resetState(postOptimization);
+ }
+
+ @Override
+ public void dump(final ExpressionDumper dumper) {
+ dumper.display("insert node ");
+ source.dump(dumper);
+ switch (mode) {
+ case INSERT_INTO -> dumper.display(" into ");
+ case INSERT_INTO_AS_FIRST -> dumper.display(" as first into ");
+ case INSERT_INTO_AS_LAST -> dumper.display(" as last into ");
+ case INSERT_BEFORE -> dumper.display(" before ");
+ case INSERT_AFTER -> dumper.display(" after ");
+ }
+ target.dump(dumper);
+ }
+
+ @Override
+ public String toString() {
+ final StringBuilder sb = new StringBuilder("insert node ");
+ sb.append(source.toString());
+ switch (mode) {
+ case INSERT_INTO -> sb.append(" into ");
+ case INSERT_INTO_AS_FIRST -> sb.append(" as first into ");
+ case INSERT_INTO_AS_LAST -> sb.append(" as last into ");
+ case INSERT_BEFORE -> sb.append(" before ");
+ case INSERT_AFTER -> sb.append(" after ");
+ }
+ sb.append(target.toString());
+ return sb.toString();
+ }
+}
diff --git a/exist-core/src/main/java/org/exist/xquery/xquf/XQUFRenameExpr.java b/exist-core/src/main/java/org/exist/xquery/xquf/XQUFRenameExpr.java
new file mode 100644
index 00000000000..24acfbb2baa
--- /dev/null
+++ b/exist-core/src/main/java/org/exist/xquery/xquf/XQUFRenameExpr.java
@@ -0,0 +1,183 @@
+/*
+ * eXist-db Open Source Native XML Database
+ * Copyright (C) 2001 The eXist-db Authors
+ *
+ * info@exist-db.org
+ * http://www.exist-db.org
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+package org.exist.xquery.xquf;
+
+import org.exist.dom.QName;
+import org.exist.xquery.*;
+import org.exist.xquery.util.ExpressionDumper;
+import org.exist.xquery.value.*;
+import org.w3c.dom.Node;
+
+/**
+ * W3C XQuery Update Facility 3.0 - rename expression.
+ *
+ * + * RenameExpr ::= "rename" "node" TargetExpr "as" NewNameExpr + *+ */ +public class XQUFRenameExpr extends AbstractExpression { + + private final Expression target; + private final Expression newName; + + public XQUFRenameExpr(final XQueryContext context, final Expression target, final Expression newName) { + super(context); + this.target = target; + this.newName = newName; + } + + @Override + public void analyze(final AnalyzeContextInfo contextInfo) throws XPathException { + if (contextInfo.hasFlag(NON_UPDATING_CONTEXT)) { + throw new XPathException(this, ErrorCodes.XUST0001, + "rename expression is not allowed in a non-updating context"); + } + // Target and new name expressions are non-updating contexts + final AnalyzeContextInfo subInfo = new AnalyzeContextInfo(contextInfo); + subInfo.setParent(this); + subInfo.addFlag(IN_UPDATE); + subInfo.addFlag(NON_UPDATING_CONTEXT); + target.analyze(subInfo); + newName.analyze(subInfo); + } + + @Override + public Sequence eval(final Sequence contextSequence, final Item contextItem) throws XPathException { + if (context.getProfiler().isEnabled()) { + context.getProfiler().start(this); + } + + final Sequence ctxSeq = contextItem != null ? contextItem.toSequence() : contextSequence; + + final Sequence targetSeq = target.eval(ctxSeq, null); + if (targetSeq.isEmpty()) { + throw new XPathException(this, ErrorCodes.XUDY0027, + "Target of rename expression must not be an empty sequence."); + } + + // XUTY0012: target must be a single element, attribute, or PI node + if (targetSeq.getItemCount() != 1 || !Type.subTypeOf(targetSeq.itemAt(0).getType(), Type.NODE)) { + throw new XPathException(this, ErrorCodes.XUTY0012, + "Target of rename expression must be a single element, attribute, or processing instruction node."); + } + + final NodeValue targetNode = (NodeValue) targetSeq.itemAt(0); + final int nodeType = targetNode.getNode().getNodeType(); + + if (nodeType != Node.ELEMENT_NODE && nodeType != Node.ATTRIBUTE_NODE + && nodeType != Node.PROCESSING_INSTRUCTION_NODE) { + throw new XPathException(this, ErrorCodes.XUTY0012, + "Target of rename expression must be an element, attribute, or processing instruction node."); + } + + // Evaluate new name — must be a single item castable to xs:QName + final Sequence nameSeq = newName.eval(ctxSeq, null); + if (nameSeq.isEmpty()) { + throw new XPathException(this, ErrorCodes.XPTY0004, + "New name expression in rename must not be empty; expected xs:QName or xs:string."); + } + if (nameSeq.getItemCount() > 1) { + throw new XPathException(this, ErrorCodes.XPTY0004, + "New name expression in rename must be a single item; got " + nameSeq.getItemCount() + " items."); + } + + // Atomize the new name expression per W3C spec + final Item nameItem; + final Item rawItem = nameSeq.itemAt(0); + if (Type.subTypeOf(rawItem.getType(), Type.NODE)) { + nameItem = rawItem.atomize(); + } else { + nameItem = rawItem; + } + + final QName qname; + if (nameItem.getType() == Type.QNAME) { + qname = ((QNameValue) nameItem).getQName(); + } else if (Type.subTypeOf(nameItem.getType(), Type.STRING) || nameItem.getType() == Type.UNTYPED_ATOMIC) { + final String nameStr = nameItem.getStringValue().trim(); + try { + qname = QName.parse(context, nameStr); + } catch (final QName.IllegalQNameException e) { + throw new XPathException(this, ErrorCodes.XQDY0074, "Invalid QName for rename: " + nameStr); + } + // Validate the name is a valid QName (NCName with optional prefix) + if (org.exist.dom.QName.isQName(nameStr) != QName.Validity.VALID.val) { + throw new XPathException(this, ErrorCodes.XQDY0074, "Invalid QName for rename: " + nameStr); + } + } else { + // Non-QName/string/untypedAtomic types are a type error (XPTY0004) + throw new XPathException(this, ErrorCodes.XPTY0004, + "New name expression in rename must be of type xs:QName or xs:string; got " + Type.getTypeName(nameItem.getType())); + } + + // XQDY0064: PI target name must not be "xml" (case-insensitive) + if (nodeType == Node.PROCESSING_INSTRUCTION_NODE + && "xml".equalsIgnoreCase(qname.getLocalPart())) { + throw new XPathException(this, ErrorCodes.XQDY0064, + "Processing instruction target name cannot be 'xml'."); + } + + final PendingUpdateList pul = context.getPendingUpdateList(); + pul.addPrimitive(UpdatePrimitive.rename(targetNode.getNode(), qname, this)); + + if (context.getProfiler().isEnabled()) { + context.getProfiler().end(this, "", Sequence.EMPTY_SEQUENCE); + } + + return Sequence.EMPTY_SEQUENCE; + } + + @Override + public boolean isUpdating() { + return true; + } + + @Override + public int returnsType() { + return Type.EMPTY_SEQUENCE; + } + + @Override + public Cardinality getCardinality() { + return Cardinality.EMPTY_SEQUENCE; + } + + @Override + public void resetState(final boolean postOptimization) { + super.resetState(postOptimization); + target.resetState(postOptimization); + newName.resetState(postOptimization); + } + + @Override + public void dump(final ExpressionDumper dumper) { + dumper.display("rename node "); + target.dump(dumper); + dumper.display(" as "); + newName.dump(dumper); + } + + @Override + public String toString() { + return "rename node " + target.toString() + " as " + newName.toString(); + } +} diff --git a/exist-core/src/main/java/org/exist/xquery/xquf/XQUFReplaceNodeExpr.java b/exist-core/src/main/java/org/exist/xquery/xquf/XQUFReplaceNodeExpr.java new file mode 100644 index 00000000000..4f530427389 --- /dev/null +++ b/exist-core/src/main/java/org/exist/xquery/xquf/XQUFReplaceNodeExpr.java @@ -0,0 +1,183 @@ +/* + * eXist-db Open Source Native XML Database + * Copyright (C) 2001 The eXist-db Authors + * + * info@exist-db.org + * http://www.exist-db.org + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ +package org.exist.xquery.xquf; + +import org.exist.xquery.*; +import org.exist.xquery.util.ExpressionDumper; +import org.exist.xquery.value.*; +import org.w3c.dom.Node; + +/** + * W3C XQuery Update Facility 3.0 - replace node expression. + * + *
+ * ReplaceExpr ::= "replace" ("value" "of")? "node" TargetExpr "with" ExprSingle
+ *
+ *
+ * This class handles "replace node" (not "replace value of node").
+ */
+public class XQUFReplaceNodeExpr extends AbstractExpression {
+
+ private final Expression target;
+ private final Expression replacement;
+
+ public XQUFReplaceNodeExpr(final XQueryContext context, final Expression target, final Expression replacement) {
+ super(context);
+ this.target = target;
+ this.replacement = replacement;
+ }
+
+ @Override
+ public void analyze(final AnalyzeContextInfo contextInfo) throws XPathException {
+ if (contextInfo.hasFlag(NON_UPDATING_CONTEXT)) {
+ throw new XPathException(this, ErrorCodes.XUST0001,
+ "replace expression is not allowed in a non-updating context");
+ }
+ // Target and replacement expressions are non-updating contexts
+ final AnalyzeContextInfo subInfo = new AnalyzeContextInfo(contextInfo);
+ subInfo.setParent(this);
+ subInfo.addFlag(IN_UPDATE);
+ subInfo.addFlag(NON_UPDATING_CONTEXT);
+ target.analyze(subInfo);
+ replacement.analyze(subInfo);
+ }
+
+ @Override
+ public Sequence eval(final Sequence contextSequence, final Item contextItem) throws XPathException {
+ if (context.getProfiler().isEnabled()) {
+ context.getProfiler().start(this);
+ }
+
+ final Sequence ctxSeq = contextItem != null ? contextItem.toSequence() : contextSequence;
+
+ final Sequence targetSeq = target.eval(ctxSeq, null);
+ if (targetSeq.isEmpty()) {
+ throw new XPathException(this, ErrorCodes.XUDY0027,
+ "Target of replace expression must not be an empty sequence.");
+ }
+
+ // XUTY0008: target must be a single node
+ if (targetSeq.getItemCount() != 1 || !Type.subTypeOf(targetSeq.itemAt(0).getType(), Type.NODE)) {
+ throw new XPathException(this, ErrorCodes.XUTY0008,
+ "Target of replace expression must be a single node.");
+ }
+
+ final NodeValue targetNode = (NodeValue) targetSeq.itemAt(0);
+ final Node domNode = targetNode.getNode();
+ final int nodeType = domNode.getNodeType();
+
+ // XUTY0008: target must not be a document node
+ if (nodeType == Node.DOCUMENT_NODE) {
+ throw new XPathException(this, ErrorCodes.XUTY0008,
+ "Target of replace expression must not be a document node.");
+ }
+
+ // XUTY0006: target must be element, attribute, text, comment, or PI
+ if (nodeType != Node.ELEMENT_NODE && nodeType != Node.ATTRIBUTE_NODE
+ && nodeType != Node.TEXT_NODE && nodeType != Node.COMMENT_NODE
+ && nodeType != Node.PROCESSING_INSTRUCTION_NODE) {
+ throw new XPathException(this, ErrorCodes.XUTY0006,
+ "Target of replace expression must be an element, attribute, text, comment, or processing instruction node.");
+ }
+
+ // XUDY0009: target must have a parent
+ final boolean hasParent;
+ if (nodeType == Node.ATTRIBUTE_NODE) {
+ hasParent = ((org.w3c.dom.Attr) domNode).getOwnerElement() != null;
+ } else {
+ hasParent = domNode.getParentNode() != null;
+ }
+ if (!hasParent) {
+ throw new XPathException(this, ErrorCodes.XUDY0009,
+ "Target node of replace expression has no parent.");
+ }
+
+ final Sequence replacementSeq = replacement.eval(ctxSeq, null);
+
+ // Type checking based on target node type
+ if (nodeType == Node.ATTRIBUTE_NODE) {
+ // XUTY0011: replacement of attribute must be attributes
+ for (final SequenceIterator i = replacementSeq.iterate(); i.hasNext(); ) {
+ final Item item = i.nextItem();
+ if (Type.subTypeOf(item.getType(), Type.NODE)
+ && ((NodeValue) item).getNode().getNodeType() != Node.ATTRIBUTE_NODE) {
+ throw new XPathException(this, ErrorCodes.XUTY0011,
+ "Replacement of an attribute node must be attribute node(s).");
+ }
+ }
+ } else {
+ // XUTY0010: replacement of element/text/comment/PI must not be attributes
+ for (final SequenceIterator i = replacementSeq.iterate(); i.hasNext(); ) {
+ final Item item = i.nextItem();
+ if (Type.subTypeOf(item.getType(), Type.NODE)
+ && ((NodeValue) item).getNode().getNodeType() == Node.ATTRIBUTE_NODE) {
+ throw new XPathException(this, ErrorCodes.XUTY0010,
+ "Replacement of an element, text, comment, or PI node must not contain attribute nodes.");
+ }
+ }
+ }
+
+ final PendingUpdateList pul = context.getPendingUpdateList();
+ pul.addPrimitive(UpdatePrimitive.replaceNode(targetNode.getNode(), replacementSeq, this));
+
+ if (context.getProfiler().isEnabled()) {
+ context.getProfiler().end(this, "", Sequence.EMPTY_SEQUENCE);
+ }
+
+ return Sequence.EMPTY_SEQUENCE;
+ }
+
+ @Override
+ public boolean isUpdating() {
+ return true;
+ }
+
+ @Override
+ public int returnsType() {
+ return Type.EMPTY_SEQUENCE;
+ }
+
+ @Override
+ public Cardinality getCardinality() {
+ return Cardinality.EMPTY_SEQUENCE;
+ }
+
+ @Override
+ public void resetState(final boolean postOptimization) {
+ super.resetState(postOptimization);
+ target.resetState(postOptimization);
+ replacement.resetState(postOptimization);
+ }
+
+ @Override
+ public void dump(final ExpressionDumper dumper) {
+ dumper.display("replace node ");
+ target.dump(dumper);
+ dumper.display(" with ");
+ replacement.dump(dumper);
+ }
+
+ @Override
+ public String toString() {
+ return "replace node " + target.toString() + " with " + replacement.toString();
+ }
+}
diff --git a/exist-core/src/main/java/org/exist/xquery/xquf/XQUFReplaceValueExpr.java b/exist-core/src/main/java/org/exist/xquery/xquf/XQUFReplaceValueExpr.java
new file mode 100644
index 00000000000..2675ac25776
--- /dev/null
+++ b/exist-core/src/main/java/org/exist/xquery/xquf/XQUFReplaceValueExpr.java
@@ -0,0 +1,146 @@
+/*
+ * eXist-db Open Source Native XML Database
+ * Copyright (C) 2001 The eXist-db Authors
+ *
+ * info@exist-db.org
+ * http://www.exist-db.org
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+package org.exist.xquery.xquf;
+
+import org.exist.xquery.*;
+import org.exist.xquery.util.ExpressionDumper;
+import org.exist.xquery.value.*;
+import org.w3c.dom.Node;
+
+/**
+ * W3C XQuery Update Facility 3.0 - replace value of node expression.
+ *
+ * + * ReplaceExpr ::= "replace" "value" "of" "node" TargetExpr "with" ExprSingle + *+ */ +public class XQUFReplaceValueExpr extends AbstractExpression { + + private final Expression target; + private final Expression value; + + public XQUFReplaceValueExpr(final XQueryContext context, final Expression target, final Expression value) { + super(context); + this.target = target; + this.value = value; + } + + @Override + public void analyze(final AnalyzeContextInfo contextInfo) throws XPathException { + if (contextInfo.hasFlag(NON_UPDATING_CONTEXT)) { + throw new XPathException(this, ErrorCodes.XUST0001, + "replace value of expression is not allowed in a non-updating context"); + } + // Target and value expressions are non-updating contexts + final AnalyzeContextInfo subInfo = new AnalyzeContextInfo(contextInfo); + subInfo.setParent(this); + subInfo.addFlag(IN_UPDATE); + subInfo.addFlag(NON_UPDATING_CONTEXT); + target.analyze(subInfo); + value.analyze(subInfo); + } + + @Override + public Sequence eval(final Sequence contextSequence, final Item contextItem) throws XPathException { + if (context.getProfiler().isEnabled()) { + context.getProfiler().start(this); + } + + final Sequence ctxSeq = contextItem != null ? contextItem.toSequence() : contextSequence; + + final Sequence targetSeq = target.eval(ctxSeq, null); + if (targetSeq.isEmpty()) { + throw new XPathException(this, ErrorCodes.XUDY0027, + "Target of replace value of expression must not be an empty sequence."); + } + + // XUTY0008: target must be a single node of the right type + if (targetSeq.getItemCount() != 1 || !Type.subTypeOf(targetSeq.itemAt(0).getType(), Type.NODE)) { + throw new XPathException(this, ErrorCodes.XUTY0008, + "Target of replace value of expression must be a single element, attribute, text, comment, or processing instruction node."); + } + + final NodeValue targetNode = (NodeValue) targetSeq.itemAt(0); + final int nodeType = targetNode.getNode().getNodeType(); + + if (nodeType == Node.DOCUMENT_NODE || (nodeType != Node.ELEMENT_NODE && nodeType != Node.ATTRIBUTE_NODE + && nodeType != Node.TEXT_NODE && nodeType != Node.COMMENT_NODE + && nodeType != Node.PROCESSING_INSTRUCTION_NODE)) { + throw new XPathException(this, ErrorCodes.XUTY0008, + "Target of replace value of expression must be a single element, attribute, text, comment, or processing instruction node, not " + + (nodeType == Node.DOCUMENT_NODE ? "a document node" : "node type " + nodeType) + "."); + } + + final Sequence valueSeq = value.eval(ctxSeq, null); + + // Per W3C spec, the replacement value is the string value obtained by atomizing + // the content expression and joining with single space separator. + // We materialize this now (at snapshot time) rather than deferring to PUL application, + // to ensure we capture the original value before any other PUL primitives modify the tree. + final String stringValue = PendingUpdateList.atomizeAndJoin(valueSeq); + + final PendingUpdateList pul = context.getPendingUpdateList(); + pul.addPrimitive(UpdatePrimitive.replaceValue(targetNode.getNode(), + new StringValue(this, stringValue), this)); + + if (context.getProfiler().isEnabled()) { + context.getProfiler().end(this, "", Sequence.EMPTY_SEQUENCE); + } + + return Sequence.EMPTY_SEQUENCE; + } + + @Override + public boolean isUpdating() { + return true; + } + + @Override + public int returnsType() { + return Type.EMPTY_SEQUENCE; + } + + @Override + public Cardinality getCardinality() { + return Cardinality.EMPTY_SEQUENCE; + } + + @Override + public void resetState(final boolean postOptimization) { + super.resetState(postOptimization); + target.resetState(postOptimization); + value.resetState(postOptimization); + } + + @Override + public void dump(final ExpressionDumper dumper) { + dumper.display("replace value of node "); + target.dump(dumper); + dumper.display(" with "); + value.dump(dumper); + } + + @Override + public String toString() { + return "replace value of node " + target.toString() + " with " + value.toString(); + } +} diff --git a/exist-core/src/main/java/org/exist/xquery/xquf/XQUFTransformExpr.java b/exist-core/src/main/java/org/exist/xquery/xquf/XQUFTransformExpr.java new file mode 100644 index 00000000000..732059dfcc3 --- /dev/null +++ b/exist-core/src/main/java/org/exist/xquery/xquf/XQUFTransformExpr.java @@ -0,0 +1,382 @@ +/* + * eXist-db Open Source Native XML Database + * Copyright (C) 2001 The eXist-db Authors + * + * info@exist-db.org + * http://www.exist-db.org + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ +package org.exist.xquery.xquf; + +import org.exist.Namespaces; +import org.exist.dom.QName; +import org.exist.dom.memtree.DocumentBuilderReceiver; +import org.exist.dom.memtree.ElementImpl; +import org.exist.dom.memtree.MemTreeBuilder; +import org.exist.dom.persistent.NodeHandle; +import org.exist.dom.persistent.NodeProxy; +import org.exist.storage.serializers.Serializer; +import org.exist.xquery.*; +import org.exist.xquery.functions.fn.FunInScopePrefixes; +import org.exist.xquery.util.ExpressionDumper; +import org.exist.xquery.value.*; +import org.w3c.dom.Document; +import org.w3c.dom.Node; +import org.xml.sax.SAXException; + +import javax.xml.XMLConstants; +import java.util.*; +import java.util.stream.Collectors; + +/** + * W3C XQuery Update Facility 3.0 - transform (copy-modify) expression. + * + *
+ * TransformExpr ::= "copy" CopyBinding ("," CopyBinding)* "modify" ExprSingle "return" ExprSingle
+ * CopyBinding ::= "$" VarName ":=" ExprSingle
+ *
+ *
+ * Also supports the shorthand: transform with { ... } (XQuery Update 3.0 extension)
+ */
+public class XQUFTransformExpr extends AbstractExpression {
+
+ private final ListRun on both the base branch (develop) and the preclaiming branch + * to get before/after comparisons. Results are printed to stdout.
+ * + *This class intentionally does not end in {@code *Test} so that + * Surefire will not discover it during normal {@code mvn test} runs. + * Run explicitly with:
+ *+ * mvn test -pl exist-core -Dtest=ConcurrencyBenchmark \ + * -Dexist.run.benchmarks=true -Ddependency-check.skip=true + *+ */ +@SuppressWarnings("PMD.ClassNamingConventions") // benchmark, not a test class; gated by -Dexist.run.benchmarks=true +public class ConcurrencyBenchmark { + + @ClassRule + public static final ExistXmldbEmbeddedServer server = + new ExistXmldbEmbeddedServer(false, true, true); + + private static final String COLLECTION_NAME = "benchmark-concurrency"; + private static final String COLLECTION_PATH = "/db/" + COLLECTION_NAME; + + private static final int NUM_DOCUMENTS = 8; + private static final int DURATION_SECONDS = 5; + private static final int[] THREAD_COUNTS = {2, 4, 8}; + + @BeforeClass + public static void assumeBenchmarks() { + Assume.assumeTrue("Benchmarks are disabled. Set -Dexist.run.benchmarks=true to enable.", + Boolean.getBoolean("exist.run.benchmarks")); + } + + @BeforeClass + public static void setUp() throws XMLDBException { + if (!Boolean.getBoolean("exist.run.benchmarks")) { + return; + } + + final CollectionManagementService cms = + server.getRoot().getService(CollectionManagementService.class); + cms.createCollection(COLLECTION_NAME); + + final Collection col = server.getRoot().getChildCollection(COLLECTION_NAME); + for (int i = 1; i <= NUM_DOCUMENTS; i++) { + final XMLResource res = col.createResource("doc" + i + ".xml", XMLResource.class); + res.setContent("
Measures wall-clock time for W3C XQUF persistent update operations (insert, + * delete, replace node, replace value, rename), their legacy eXist-db equivalents + * (update insert, update delete, etc.), and in-memory copy-modify (transform) + * expressions at various data sizes.
+ * + *This class intentionally does not end in {@code *Test} so that + * Surefire will not discover it during normal {@code mvn test} runs. + * Run explicitly with:
+ *+ * mvn test -pl exist-core -Dtest=XQUFBenchmark \ + * -Dexist.run.benchmarks=true -Ddependency-check.skip=true + *+ */ +@SuppressWarnings("PMD.ClassNamingConventions") // benchmark, not a test class; gated by -Dexist.run.benchmarks=true +public class XQUFBenchmark { + + @ClassRule + public static final ExistXmldbEmbeddedServer server = + new ExistXmldbEmbeddedServer(false, true, true); + + private static final String COLLECTION_NAME = "benchmark-xquf"; + private static final String COLLECTION_PATH = "/db/" + COLLECTION_NAME; + + private static final int WARMUP_ITERATIONS = 3; + private static final int MEASURE_ITERATIONS = 5; + private static final int[] DATA_SIZES = {10, 50, 200}; + + @BeforeClass + public static void assumeBenchmarks() { + Assume.assumeTrue("Benchmarks are disabled. Set -Dexist.run.benchmarks=true to enable.", + Boolean.getBoolean("exist.run.benchmarks")); + } + + @BeforeClass + public static void setUp() throws XMLDBException { + if (!Boolean.getBoolean("exist.run.benchmarks")) { + return; + } + + final CollectionManagementService cms = + server.getRoot().getService(CollectionManagementService.class); + cms.createCollection(COLLECTION_NAME); + } + + @AfterClass + public static void tearDown() throws XMLDBException { + if (!Boolean.getBoolean("exist.run.benchmarks")) { + return; + } + + final CollectionManagementService cms = + server.getRoot().getService(CollectionManagementService.class); + cms.removeCollection(COLLECTION_NAME); + } + + // ---- Persistent update benchmarks ---- + + @Test + public void insertInto() throws XMLDBException { + System.out.println("\n=== insert node ... into (persistent) ==="); + printHeader(); + + for (final int size : DATA_SIZES) { + final double avgMs = runPersistentBenchmark("insert-into", size, (queryService, docPath) -> { + // Reset document with N items + storeDocument(size); + + // Insert a new child into each item + final String update = String.format( + "for $item in doc('%s/bench.xml')//item " + + "return insert node