mikemccand commented on a change in pull request #225:
URL: https://github.com/apache/lucene/pull/225#discussion_r715531456
##########
File path:
lucene/codecs/src/java/org/apache/lucene/codecs/uniformsplit/IntersectBlockReader.java
##########
@@ -384,15 +390,18 @@ protected AutomatonNextTermCalculator(CompiledAutomaton
compiled) {
}
/** Records the given state has been visited. */
- protected void setVisited(int state) {
+ private void setVisited(int state) {
if (!finite) {
Review comment:
Maybe fix to `finite == false` since you are here :)
##########
File path: lucene/core/src/java/org/apache/lucene/util/automaton/RegExp.java
##########
@@ -551,12 +551,22 @@ static RegExp newLeafNode(
return new RegExp(flags, kind, null, null, s, c, min, max, digits, from,
to);
}
+ /**
+ * Return an <code>Automaton</code> from this <code>RegExp</code> that will
skip the determinize
+ * and minimize step
+ *
+ * @return {@link Automaton} most likely non-deterministic
+ */
+ public Automaton toNFA() {
Review comment:
I wonder just how "NFA" this Automaton really is. Like for a simple
regexp, what does the NFA even look like? I know the `RegExp` code makes heavy
use of `.addEpsilon` which creates many copies of transitions, etc.
##########
File path: lucene/core/src/java/org/apache/lucene/search/AutomatonQuery.java
##########
@@ -96,12 +109,35 @@ public AutomatonQuery(final Term term, Automaton
automaton, int determinizeWorkL
*/
public AutomatonQuery(
final Term term, Automaton automaton, int determinizeWorkLimit, boolean
isBinary) {
+ this(term, automaton, determinizeWorkLimit, isBinary,
ByteRunnable.TYPE.DFA);
+ }
+
+ /**
+ * Create a new AutomatonQuery from an {@link Automaton}.
+ *
+ * @param term Term containing field and possibly some pattern structure.
The term text is
+ * ignored.
+ * @param automaton Automaton to run, terms that are accepted are considered
a match.
+ * @param determinizeWorkLimit maximum effort to spend determinizing the
automaton. If the
+ * automaton will need more than this much effort,
TooComplexToDeterminizeException is thrown.
+ * Higher numbers require more space but can process more complex
automata.
+ * @param isBinary if true, this automaton is already binary and will not go
through the
+ * UTF32ToUTF8 conversion
+ * @param runnableType NFA or DFA
+ */
+ public AutomatonQuery(
Review comment:
Cool, so the existing ctor remains, defaulting to `DFA` execution
strategy, where the automaton is first fully determinized.
But now you add another ctor, letting users also ask for `NFA` execution,
where the automaton is determinized lazily on-demand and only in those parts
that the terms in this index need to visit.
##########
File path:
lucene/backward-codecs/src/java/org/apache/lucene/backward_codecs/lucene40/blocktree/FieldReader.java
##########
@@ -187,6 +187,14 @@ public TermsEnum intersect(CompiledAutomaton compiled,
BytesRef startTerm) throw
if (compiled.type != CompiledAutomaton.AUTOMATON_TYPE.NORMAL) {
throw new IllegalArgumentException("please use
CompiledAutomaton.getTermsEnum instead");
}
+ if (compiled.nfaRunAutomaton != null) {
+ return new IntersectTermsEnum(
Review comment:
Ahh, so it was too difficult to support `nfaRunAutomaton` also in
`BlockTree`? This probably hurts performance quite a bit for `NFAQuery` --
`BlockTree`'s specialized `intersect` impl is fast. But we can optimize later.
##########
File path:
lucene/core/src/java/org/apache/lucene/util/automaton/CompiledAutomaton.java
##########
@@ -133,7 +137,35 @@ private static int findSinkState(Automaton automaton) {
* is one the cases in {@link CompiledAutomaton.AUTOMATON_TYPE}.
*/
public CompiledAutomaton(Automaton automaton, Boolean finite, boolean
simplify) {
- this(automaton, finite, simplify,
Operations.DEFAULT_DETERMINIZE_WORK_LIMIT, false);
+ this(automaton, finite, simplify, ByteRunnable.TYPE.DFA);
Review comment:
Good -- the existing ctors remain and default to `DFA` strategy.
##########
File path:
lucene/codecs/src/java/org/apache/lucene/codecs/memory/DirectPostingsFormat.java
##########
@@ -962,15 +964,22 @@ public ImpactsEnum impacts(int flags) throws IOException {
private int stateUpto;
public DirectIntersectTermsEnum(CompiledAutomaton compiled, BytesRef
startTerm) {
- runAutomaton = compiled.runAutomaton;
- compiledAutomaton = compiled;
+ if (compiled.nfaRunAutomaton != null) {
+ this.runAutomaton = compiled.nfaRunAutomaton;
Review comment:
Maybe instead of having separate `nfaRunAutomaton` and `runAutomaton` we
could have only `runAutomaton` and a separate
`CompiledAutomaton.isDeterminized` boolean?
##########
File path:
lucene/core/src/java/org/apache/lucene/util/automaton/CompiledAutomaton.java
##########
@@ -250,15 +291,23 @@ public CompiledAutomaton(
}
}
- // This will determinize the binary automaton for us:
- runAutomaton = new ByteRunAutomaton(binary, true, determinizeWorkLimit);
+ if (automaton.isDeterministic() == false && byteRunnableType ==
ByteRunnable.TYPE.NFA) {
Review comment:
Are we still pulling the common prefix/suffix even in `NFA` mode?
@rmuir recently improved those operations to not require a determinized
automaton.
##########
File path:
lucene/core/src/java/org/apache/lucene/util/automaton/ByteRunnable.java
##########
@@ -0,0 +1,66 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.lucene.util.automaton;
+
+/** A runnable automaton accepting byte array as input */
+public interface ByteRunnable {
+
+ /** NFA or DFA */
+ enum TYPE {
+ /** use NFARunAutomaton */
Review comment:
Can we improve these javadocs? Instead of referring to internal
classes, let's write it as seen from a somewhat less knowledgeable external
future user.
E.g. for `DFA`, something like `Fully determinize the automaton up-front for
fast term intersection. Some RegExps may fail to determinize, throwing
TooComplexToDeterminizeException. But if they do not, intersection is fast.`,
and for `NFA`, something like `Determinize the automaton lazily on-demand as
terms are intersected. This option saves the up-front determinize cost, and
can handle some RegExps that DFA cannot, but intersection will be a bit slower`?
##########
File path:
lucene/core/src/test/org/apache/lucene/util/automaton/TestNFARunAutomaton.java
##########
@@ -0,0 +1,188 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.lucene.util.automaton;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+import org.apache.lucene.document.Document;
+import org.apache.lucene.document.Field;
+import org.apache.lucene.index.DirectoryReader;
+import org.apache.lucene.index.IndexReader;
+import org.apache.lucene.index.RandomIndexWriter;
+import org.apache.lucene.index.Term;
+import org.apache.lucene.search.AutomatonQuery;
+import org.apache.lucene.search.IndexSearcher;
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.util.IntsRef;
+import org.apache.lucene.util.LuceneTestCase;
+import org.apache.lucene.util.TestUtil;
+
+public class TestNFARunAutomaton extends LuceneTestCase {
+
+ private static final String FIELD = "field";
+
+ public void testWithRandomRegex() {
+ for (int i = 0; i < 100; i++) {
+ RegExp regExp = null;
+ while (regExp == null) {
+ try {
+ regExp = new RegExp(AutomatonTestUtil.randomRegexp(random()));
+ } catch (IllegalArgumentException e) {
+ ignoreException(e);
+ }
+ }
+ Automaton nfa = regExp.toNFA();
+ if (nfa.isDeterministic()) {
+ i--;
+ continue;
+ }
+ Automaton dfa = regExp.toAutomaton();
+ NFARunAutomaton candidate = new NFARunAutomaton(nfa);
+ AutomatonTestUtil.RandomAcceptedStrings randomStringGen;
+ try {
+ randomStringGen = new AutomatonTestUtil.RandomAcceptedStrings(dfa);
+ } catch (IllegalArgumentException e) {
+ ignoreException(e);
+ i--;
+ continue; // sometimes the automaton accept nothing and throw this
exception
+ }
+
+ for (int round = 0; round < 20; round++) {
+ // test order of accepted strings and random (likely rejected) strings
alternatively to make
+ // sure caching system works correctly
+ if (random().nextBoolean()) {
+ testAcceptedString(regExp, randomStringGen, candidate, 10);
+ testRandomString(regExp, dfa, candidate, 10);
+ } else {
+ testRandomString(regExp, dfa, candidate, 10);
+ testAcceptedString(regExp, randomStringGen, candidate, 10);
+ }
+ }
+ }
+ }
+
+ public void testWithRandomAutomatonQuery() throws IOException {
+ final int n = 5;
+ for (int i = 0; i < n; i++) {
+ randomAutomatonQueryTest();
+ }
+ }
+
+ private void randomAutomatonQueryTest() throws IOException {
+ final int docNum = 50;
+ final int automatonNum = 50;
+ Directory directory = newDirectory();
+ RandomIndexWriter writer = new RandomIndexWriter(random(), directory);
+
+ Set<String> vocab = new HashSet<>();
+ Set<String> perLoopReuse = new HashSet<>();
+ for (int i = 0; i < docNum; i++) {
+ perLoopReuse.clear();
+ int termNum = random().nextInt(20) + 30;
+ while (perLoopReuse.size() < termNum) {
+ String randomString;
+ while ((randomString =
TestUtil.randomUnicodeString(random())).length() == 0)
+ ;
+ perLoopReuse.add(randomString);
+ vocab.add(randomString);
+ }
+ Document document = new Document();
+ document.add(
+ newTextField(
+ FIELD, perLoopReuse.stream().reduce("", (s1, s2) -> s1 + " " +
s2), Field.Store.NO));
+ writer.addDocument(document);
+ }
+ writer.commit();
+ IndexReader reader = DirectoryReader.open(directory);
+ IndexSearcher searcher = new IndexSearcher(reader);
+
+ Set<String> foreignVocab = new HashSet<>();
+ while (foreignVocab.size() < vocab.size()) {
+ String randomString;
+ while ((randomString = TestUtil.randomUnicodeString(random())).length()
== 0)
+ ;
+ foreignVocab.add(randomString);
+ }
+
+ ArrayList<String> vocabList = new ArrayList<>(vocab);
+ ArrayList<String> foreignVocabList = new ArrayList<>(foreignVocab);
+
+ for (int i = 0; i < automatonNum; i++) {
+ perLoopReuse.clear();
Review comment:
And then make a new (still reused) `HashSet` here, `perQueryVocab`?
##########
File path:
lucene/core/src/test/org/apache/lucene/util/automaton/TestNFARunAutomaton.java
##########
@@ -0,0 +1,188 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.lucene.util.automaton;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+import org.apache.lucene.document.Document;
+import org.apache.lucene.document.Field;
+import org.apache.lucene.index.DirectoryReader;
+import org.apache.lucene.index.IndexReader;
+import org.apache.lucene.index.RandomIndexWriter;
+import org.apache.lucene.index.Term;
+import org.apache.lucene.search.AutomatonQuery;
+import org.apache.lucene.search.IndexSearcher;
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.util.IntsRef;
+import org.apache.lucene.util.LuceneTestCase;
+import org.apache.lucene.util.TestUtil;
+
+public class TestNFARunAutomaton extends LuceneTestCase {
+
+ private static final String FIELD = "field";
+
+ public void testWithRandomRegex() {
+ for (int i = 0; i < 100; i++) {
+ RegExp regExp = null;
+ while (regExp == null) {
+ try {
+ regExp = new RegExp(AutomatonTestUtil.randomRegexp(random()));
+ } catch (IllegalArgumentException e) {
+ ignoreException(e);
+ }
+ }
+ Automaton nfa = regExp.toNFA();
+ if (nfa.isDeterministic()) {
+ i--;
+ continue;
+ }
+ Automaton dfa = regExp.toAutomaton();
+ NFARunAutomaton candidate = new NFARunAutomaton(nfa);
+ AutomatonTestUtil.RandomAcceptedStrings randomStringGen;
+ try {
+ randomStringGen = new AutomatonTestUtil.RandomAcceptedStrings(dfa);
+ } catch (IllegalArgumentException e) {
+ ignoreException(e);
+ i--;
+ continue; // sometimes the automaton accept nothing and throw this
exception
+ }
+
+ for (int round = 0; round < 20; round++) {
+ // test order of accepted strings and random (likely rejected) strings
alternatively to make
+ // sure caching system works correctly
+ if (random().nextBoolean()) {
+ testAcceptedString(regExp, randomStringGen, candidate, 10);
+ testRandomString(regExp, dfa, candidate, 10);
+ } else {
+ testRandomString(regExp, dfa, candidate, 10);
+ testAcceptedString(regExp, randomStringGen, candidate, 10);
+ }
+ }
+ }
+ }
+
+ public void testWithRandomAutomatonQuery() throws IOException {
+ final int n = 5;
+ for (int i = 0; i < n; i++) {
+ randomAutomatonQueryTest();
+ }
+ }
+
+ private void randomAutomatonQueryTest() throws IOException {
+ final int docNum = 50;
+ final int automatonNum = 50;
+ Directory directory = newDirectory();
+ RandomIndexWriter writer = new RandomIndexWriter(random(), directory);
+
+ Set<String> vocab = new HashSet<>();
+ Set<String> perLoopReuse = new HashSet<>();
+ for (int i = 0; i < docNum; i++) {
+ perLoopReuse.clear();
+ int termNum = random().nextInt(20) + 30;
+ while (perLoopReuse.size() < termNum) {
+ String randomString;
+ while ((randomString =
TestUtil.randomUnicodeString(random())).length() == 0)
+ ;
+ perLoopReuse.add(randomString);
+ vocab.add(randomString);
+ }
+ Document document = new Document();
+ document.add(
+ newTextField(
+ FIELD, perLoopReuse.stream().reduce("", (s1, s2) -> s1 + " " +
s2), Field.Store.NO));
+ writer.addDocument(document);
+ }
+ writer.commit();
+ IndexReader reader = DirectoryReader.open(directory);
+ IndexSearcher searcher = new IndexSearcher(reader);
+
+ Set<String> foreignVocab = new HashSet<>();
+ while (foreignVocab.size() < vocab.size()) {
+ String randomString;
+ while ((randomString = TestUtil.randomUnicodeString(random())).length()
== 0)
+ ;
+ foreignVocab.add(randomString);
+ }
+
+ ArrayList<String> vocabList = new ArrayList<>(vocab);
+ ArrayList<String> foreignVocabList = new ArrayList<>(foreignVocab);
+
+ for (int i = 0; i < automatonNum; i++) {
+ perLoopReuse.clear();
+ int termNum = random().nextInt(40) + 30;
+ while (perLoopReuse.size() < termNum) {
+ if (random().nextBoolean()) {
+ perLoopReuse.add(vocabList.get(random().nextInt(vocabList.size())));
+ } else {
+
perLoopReuse.add(foreignVocabList.get(random().nextInt(foreignVocabList.size())));
+ }
+ }
+ Automaton a = null;
+ for (String term : perLoopReuse) {
+ if (a == null) {
+ a = Automata.makeString(term);
+ } else {
+ a = Operations.union(a, Automata.makeString(term));
+ }
+ }
+ if (a.isDeterministic()) {
+ i--;
+ continue;
+ }
+ AutomatonQuery dfaQuery = new AutomatonQuery(new Term(FIELD), a);
+ AutomatonQuery nfaQuery = new AutomatonQuery(new Term(FIELD), a,
ByteRunnable.TYPE.NFA);
Review comment:
Could you add a new `LuceneTestCase` method, `newAutomatonQuery`, and it
would randomly pick between `NFA` and `DFA` type? And then in a few
pre-existing tests, let's call `newAutomatonQuery` instead of `new
AutomatonQuery`?
That method could also randomly make the automaton non-deterministic by
simple cloning a few states? We can do this in a follow-on issue.
##########
File path:
lucene/core/src/java/org/apache/lucene/util/automaton/NFARunAutomaton.java
##########
@@ -0,0 +1,429 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.lucene.util.automaton;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import org.apache.lucene.util.ArrayUtil;
+import org.apache.lucene.util.hppc.BitMixer;
+
+/**
+ * A RunAutomaton that does not require DFA, it will determinize and memorize
the generated DFA
Review comment:
Period after `DFA`.
And maybe say `It will lazily determinize on-demand, memorizing the
generated DFA states that indexed terms have intersected with`.
##########
File path:
lucene/core/src/test/org/apache/lucene/util/automaton/TestNFARunAutomaton.java
##########
@@ -0,0 +1,188 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.lucene.util.automaton;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+import org.apache.lucene.document.Document;
+import org.apache.lucene.document.Field;
+import org.apache.lucene.index.DirectoryReader;
+import org.apache.lucene.index.IndexReader;
+import org.apache.lucene.index.RandomIndexWriter;
+import org.apache.lucene.index.Term;
+import org.apache.lucene.search.AutomatonQuery;
+import org.apache.lucene.search.IndexSearcher;
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.util.IntsRef;
+import org.apache.lucene.util.LuceneTestCase;
+import org.apache.lucene.util.TestUtil;
+
+public class TestNFARunAutomaton extends LuceneTestCase {
+
+ private static final String FIELD = "field";
+
+ public void testWithRandomRegex() {
+ for (int i = 0; i < 100; i++) {
+ RegExp regExp = null;
+ while (regExp == null) {
+ try {
+ regExp = new RegExp(AutomatonTestUtil.randomRegexp(random()));
+ } catch (IllegalArgumentException e) {
+ ignoreException(e);
+ }
+ }
+ Automaton nfa = regExp.toNFA();
+ if (nfa.isDeterministic()) {
+ i--;
+ continue;
+ }
+ Automaton dfa = regExp.toAutomaton();
+ NFARunAutomaton candidate = new NFARunAutomaton(nfa);
+ AutomatonTestUtil.RandomAcceptedStrings randomStringGen;
+ try {
+ randomStringGen = new AutomatonTestUtil.RandomAcceptedStrings(dfa);
+ } catch (IllegalArgumentException e) {
+ ignoreException(e);
+ i--;
+ continue; // sometimes the automaton accept nothing and throw this
exception
+ }
+
+ for (int round = 0; round < 20; round++) {
+ // test order of accepted strings and random (likely rejected) strings
alternatively to make
+ // sure caching system works correctly
+ if (random().nextBoolean()) {
+ testAcceptedString(regExp, randomStringGen, candidate, 10);
+ testRandomString(regExp, dfa, candidate, 10);
+ } else {
+ testRandomString(regExp, dfa, candidate, 10);
+ testAcceptedString(regExp, randomStringGen, candidate, 10);
+ }
+ }
+ }
+ }
+
+ public void testWithRandomAutomatonQuery() throws IOException {
+ final int n = 5;
+ for (int i = 0; i < n; i++) {
+ randomAutomatonQueryTest();
+ }
+ }
+
+ private void randomAutomatonQueryTest() throws IOException {
+ final int docNum = 50;
+ final int automatonNum = 50;
+ Directory directory = newDirectory();
+ RandomIndexWriter writer = new RandomIndexWriter(random(), directory);
+
+ Set<String> vocab = new HashSet<>();
+ Set<String> perLoopReuse = new HashSet<>();
Review comment:
Maybe rename to `perDocVocab`?
##########
File path: lucene/core/src/java/org/apache/lucene/search/AutomatonQuery.java
##########
@@ -65,7 +66,19 @@
* @param automaton Automaton to run, terms that are accepted are considered
a match.
*/
public AutomatonQuery(final Term term, Automaton automaton) {
- this(term, automaton, Operations.DEFAULT_DETERMINIZE_WORK_LIMIT);
+ this(term, automaton, ByteRunnable.TYPE.DFA);
+ }
+
+ /**
+ * Create a new AutomatonQuery from an {@link Automaton}. Using specific
type of RunAutomaton
+ *
+ * @param term Term containing field and possibly some pattern structure.
The term text is
+ * ignored.
+ * @param automaton Automaton to run, terms that are accepted are considered
a match.
+ * @param runnableType NFA or DFA
Review comment:
Could you improve these javadocs a bit? And specifically include a
warning that `NFA` has uncertain performance impact?
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: issues-unsubscr...@lucene.apache.org
For queries about this service, please contact Infrastructure at:
us...@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: issues-unsubscr...@lucene.apache.org
For additional commands, e-mail: issues-h...@lucene.apache.org
