[ADD] XQuery: More optimizations on namespaced databases. #1763

Author: ChristianGruen

basex-core/src/main/java/org/basex/data/Data.java

@@ -270,6 +270,14 @@ public byte[] defaultNs() {
     return nspaces.defaultNs(meta.ndocs);
   }
 
+  /**
+   * Checks if a default namespace is declared anywhere in the database.
+   * @return result of check
+   */
+  public boolean usesDefaultNs() {
+    return nspaces.usesDefaultNs();
+  }
+
   // RETRIEVING VALUES ============================================================================
 
   /**

basex-core/src/main/java/org/basex/data/Namespaces.java

@@ -146,6 +146,31 @@ byte[] defaultNs(final int ndocs) {
     return uri(id);
   }
 
+  /**
+   * Checks if a default namespace is declared anywhere in the database.
+   * @return result of check
+   */
+  public boolean usesDefaultNs() {
+    return !isEmpty() && usesDefaultNs(root);
+  }
+
+  /**
+   * Recursively checks a namespace node and its descendants for a default namespace.
+   * @param node namespace node
+   * @return result of check
+   */
+  private boolean usesDefaultNs(final NSNode node) {
+    final int[] values = node.values();
+    for(int v = 0; v < values.length; v += 2) {
+      if(prefix(values[v]).length == 0 && uri(values[v + 1]).length != 0) return true;
+    }
+    final int ch = node.children();
+    for(int c = 0; c < ch; c++) {
+      if(usesDefaultNs(node.child(c))) return true;
+    }
+    return false;
+  }
+
   // Requesting Namespaces Based on Context =======================================================
 
   /**

basex-core/src/main/java/org/basex/query/expr/path/NameTest.java

@@ -91,9 +91,21 @@ public Test optimize(final Kind kn, final Data data) {
     // skip optimizations if data reference is not known at compile time
     if(data == null) return this;
 
-    // skip optimizations if more than one namespace is defined in the database
+    // common default namespace (empty: none declared; null: ambiguous)
     final byte[] dataNs = data.defaultNs();
-    if(dataNs == null) return this;
+    if(dataNs == null) {
+      // no default namespace anywhere: discard no-namespace name test if its local name is unknown
+      // (the test is not reduced to local, as a prefixed name may share the same local name)
+      if(scope.oneOf(Scope.FLEXIBLE, Scope.FULL) && !qname.hasURI() &&
+          !kind.oneOf(Kind.GNODE, Kind.PROCESSING_INSTRUCTION) &&
+          (kind == Kind.ATTRIBUTE || ns.length == 0) && !data.usesDefaultNs()) {
+        final byte[] local = qname.local();
+        final Names names = kind == Kind.ELEMENT ? data.elemNames : data.attrNames;
+        if(!names.contains(local) && !names.contains(Token.concat(Token.XML, ':', local)))
+          return null;
+      }
+      return this;
+    }
 
     // check if test may yield results
     if(scope.oneOf(Scope.FLEXIBLE, Scope.FULL) && !qname.hasURI()) {

basex-core/src/main/java/org/basex/query/util/index/IndexInfo.java

@@ -84,14 +84,25 @@ public IndexType type(final Expr input, final IndexType type) {
       text = true;
     } else if(kind == Kind.ELEMENT) {
       // ensure that addressed elements only have text nodes as children
-      // stop if database is unknown/out-dated, if namespaces occur, or if name test is not simple
-      if(data == null || !data.meta.uptodate || !data.nspaces.isEmpty() ||
-          !(last.test instanceof NameTest)) return null;
-
+      // stop if database is unknown/out-dated or if name test is not simple
+      if(data == null || !data.meta.uptodate || !(last.test instanceof NameTest)) return null;
       test = (NameTest) last.test;
-      if(test.name == null) return null;
 
-      final Stats stats = data.elemNames.stats(data.elemNames.index(test.name));
+      // resolve local name for statistics lookup; sound only if its lexical name is unambiguous
+      final byte[] local;
+      if(data.nspaces.isEmpty()) {
+        // no namespaces: one lexical name per local name
+        if(test.name == null) return null;
+        local = test.name;
+      } else if(test.scope == NameTest.Scope.FULL && !test.qname.hasURI() &&
+          !data.usesDefaultNs()) {
+        // no default namespace: full no-namespace test maps to its no-prefix lexical name
+        local = test.qname.local();
+      } else {
+        return null;
+      }
+
+      final Stats stats = data.elemNames.stats(data.elemNames.index(local));
       if(stats == null || !stats.isLeaf()) return null;
       text = true;
     } else if(kind == Kind.ATTRIBUTE) {

basex-core/src/test/java/org/basex/query/index/IndexOptimizeTest.java

@@ -330,29 +330,69 @@ public final class IndexOptimizeTest extends SandboxTest {
   }
 
   /**
-   * Index access with namespaces.
+   * Index access with namespaces (#1763).
    */
   @Test public void gh1763() {
     final String doc = "<a xmlns:x=\"X\"><b>B</b></a>";
     execute(new CreateDB(NAME, doc));
+
+    // explicit text steps: rewritten for index access
     check("/a[.//text() = 'B']", doc, exists(ValueAccess.class));
     check("//a[.//text() = 'B']", doc, exists(ValueAccess.class));
     check("/a/b[text() = 'B']/..", doc, exists(ValueAccess.class));
     check("//b[text() = 'B']/..", doc, exists(ValueAccess.class));
     check("//*[text() = 'B']/..", doc, exists(ValueAccess.class));
 
-    // the following queries could be rewritten for index access
+    // no default namespace is declared anywhere: no-namespace element tests are rewritten
+    check("/a[b = 'B']", doc, exists(ValueAccess.class));
+    check("//a[b = 'B']", doc, exists(ValueAccess.class));
+    check("/*[b = 'B']", doc, exists(ValueAccess.class));
+    check("//*[b = 'B']", doc, exists(ValueAccess.class));
+
+    // local-name wildcard tests are not rewritten (may match names in other namespaces)
     check("/a[*:b = 'B']", doc, empty(ValueAccess.class));
     check("//a[*:b = 'B']", doc, empty(ValueAccess.class));
     check("/*:a[*:b = 'B']", doc, empty(ValueAccess.class));
     check("//*:a[*:b = 'B']", doc, empty(ValueAccess.class));
     check("/*[*:b = 'B']", doc, empty(ValueAccess.class));
     check("//*[*:b = 'B']", doc, empty(ValueAccess.class));
 
-    check("/a[b = 'B']", doc, empty(ValueAccess.class));
-    check("//a[b = 'B']", doc, empty(ValueAccess.class));
-    check("/*[b = 'B']", doc, empty(ValueAccess.class));
-    check("//*[b = 'B']", doc, empty(ValueAccess.class));
+    // nonexistent no-namespace names: statically discarded
+    check("/a/nonexistent", "", empty());
+    check("//nonexistent[. = 'B']", "", empty());
+
+    // attribute values are rewritten for index access
+    execute(new CreateDB(NAME, "<a xmlns:x=\"X\"><b id=\"7\">B</b></a>"));
+    check("//b[@id = '7']", "<b xmlns:x=\"X\" id=\"7\">B</b>", exists(ValueAccess.class));
+  }
+
+  /**
+   * Index access with namespaces: soundness with prefixed same-local names (#1763).
+   */
+  @Test public void gh1763Mixed() {
+    // no-namespace <b> (leaf) and prefixed <x:b> (non-leaf) share the local name 'b'
+    execute(new CreateDB(NAME, "<a xmlns:x=\"X\"><b>B</b><x:b><c>B</c></x:b></a>"));
+
+    // full no-namespace test is rewritten and matches only the no-namespace element
+    check("count(/a[b = 'B'])", "1", exists(ValueAccess.class));
+    check("count(//b[. = 'B'])", "1", exists(ValueAccess.class));
+    // local-name wildcard is evaluated sequentially and matches both elements
+    check("count(//*:b[. = 'B'])", "2", empty(ValueAccess.class));
+
+    // 'B' only occurs below the prefixed element: no-namespace test must not match
+    execute(new CreateDB(NAME, "<a xmlns:x=\"X\"><b>b</b><x:b><c>B</c></x:b></a>"));
+    check("count(/a[b = 'B'])", "0", exists(ValueAccess.class));
+  }
+
+  /**
+   * Index access on databases with a default namespace (#1763).
+   */
+  @Test public void gh1763DefaultNs() {
+    // single default namespace: a no-namespace element test never matches and is discarded
+    execute(new CreateDB(NAME, "<a xmlns=\"Y\"><b>B</b></a>"));
+    check("/a[b = 'B']", "", empty());
+    // query default namespace matches the database default namespace: correct result
+    check("declare default element namespace 'Y'; count(/a[b = 'B'])", "1");
   }
 
   /** Index access for integer comparisons (issue #2069). */

basex-core/src/test/java/org/basex/query/index/ValueIndexTest.java

@@ -56,7 +56,8 @@ public void textIndex(final boolean mainmem) {
       execute(new CreateDB(NAME, FILE));
       check("count(//" + key + "[text() = " + value + "])",
           value.split(",").length, exists(ValueAccess.class));
-      if(!key.equals("*")) check("//X[text() = 'unknown']", "", exists(DBNode.class));
+      // existing but non-indexed element: sequential fallback (name 'b' is never a lookup key)
+      if(!key.equals("*")) check("//b[text() = 'unknown']", "", exists(DBNode.class));
     });
   }
 
@@ -73,7 +74,8 @@ public void attrIndex(final boolean mainmem) {
       execute(new CreateDB(NAME, FILE));
       check("count(//*[@" + key + " = " + value + "])",
           value.split(",").length, exists(ValueAccess.class));
-      if(!key.equals("*")) check("//*[@x = 'unknown']", "", exists(DBNode.class));
+      // existing but non-indexed attribute: sequential fallback (name 'b' is never a lookup key)
+      if(!key.equals("*")) check("//*[@b = 'unknown']", "", exists(DBNode.class));
     });
   }
 
@@ -88,7 +90,8 @@ public void attrIndex(final boolean mainmem) {
       check("count(//" + key + "[text() contains text { " + value + " }])",
           value.split(",").length,
           exists(FTIndexAccess.class));
-      if(!key.equals("*")) check("//X[text() contains text 'unknown']", "", exists(DBNode.class));
+      // existing but non-indexed element: sequential fallback (name 'b' is never a lookup key)
+      if(!key.equals("*")) check("//b[text() contains text 'unknown']", "", exists(DBNode.class));
     });
   }