Avoid lucence QueryParser Parse exception? - lucene

Question

On the 3rd line i get exceptions such as 'IOException: read past eof' and 'LookaheadSuccess: Error in the application.'
Is there any way to avoid this? i hate the breaks and pressing continue twice everytime i execute a search
Note i only notice this when i tell visual studios to show me exceptions that are thrown even IF they are caught. I don't get the exceptions, i just see that they are being thrown thus the two (or three) breakpoints every time i search. The app runs fine.
var searcher = new IndexSearcher(directory, true);
var parser = new QueryParser(Lucene.Net.Util.Version.LUCENE_29, "all", analyzer);
var query = parser.Parse(text); //here

Answer 1

These are first-chance exceptions that occur, and are caught, within Lucene. You've configured Visual Studio to break on all exceptions, and not just those that are unhandled. Use the Exceptions dialog (ctrl-alt-e iirc) and change your settings.

Answer 2

Lucene.NET (at the time of version 3.0.3) used IOExceptions to manage several parts of the parser's flow. This had a bad impact on the performance (up to 90ms on my development machine).
Good news is that the version currently in their source code repository at http://lucenenet.apache.org/community.html seems to have removed the specific exceptions that were causing this. Certainly for me, this has improved performance a lot. Hope this helps.

Answer 3

Patch for QueryParser in Lucene 3.0.3 to avoid the LookaheadSuccess exception throwing:
--- a/src/core/QueryParser/QueryParser.cs
+++ b/src/core/QueryParser/QueryParser.cs
## -1708,16 +1708,13 ## namespace Lucene.Net.QueryParsers
}
private bool Jj_2_1(int xla)
- {
+ {
+ bool lookaheadSuccess = false;
jj_la = xla;
jj_lastpos = jj_scanpos = token;
try
{
- return !Jj_3_1();
- }
- catch (LookaheadSuccess)
- {
- return true;
+ return !Jj_3_1(out lookaheadSuccess);
}
finally
{
## -1725,29 +1722,31 ## namespace Lucene.Net.QueryParsers
}
}
- private bool Jj_3R_2()
- {
- if (jj_scan_token(TermToken)) return true;
- if (jj_scan_token(ColonToken)) return true;
+ private bool Jj_3R_2(out bool lookaheadSuccess)
+ {
+ if (jj_scan_token(TermToken, out lookaheadSuccess)) return true;
+ if (lookaheadSuccess) return false;
+ if (jj_scan_token(ColonToken, out lookaheadSuccess)) return true;
return false;
}
- private bool Jj_3_1()
+ private bool Jj_3_1(out bool lookaheadSuccess)
{
Token xsp;
xsp = jj_scanpos;
- if (Jj_3R_2())
+ if (Jj_3R_2(out lookaheadSuccess))
{
jj_scanpos = xsp;
- if (Jj_3R_3()) return true;
+ if (Jj_3R_3(out lookaheadSuccess)) return true;
}
return false;
}
- private bool Jj_3R_3()
- {
- if (jj_scan_token(StarToken)) return true;
- if (jj_scan_token(ColonToken)) return true;
+ private bool Jj_3R_3(out bool lookaheadSuccess)
+ {
+ if (jj_scan_token(StarToken, out lookaheadSuccess)) return true;
+ if (lookaheadSuccess) return false;
+ if (jj_scan_token(ColonToken, out lookaheadSuccess)) return true;
return false;
}
## -1861,14 +1860,9 ## namespace Lucene.Net.QueryParsers
throw GenerateParseException();
}
- [Serializable]
- private sealed class LookaheadSuccess : System.Exception
- {
- }
-
- private LookaheadSuccess jj_ls = new LookaheadSuccess();
- private bool jj_scan_token(int kind)
- {
+ private bool jj_scan_token(int kind, out bool lookaheadSuccess)
+ {
+ lookaheadSuccess = false;
if (jj_scanpos == jj_lastpos)
{
jj_la--;
## -1896,8 +1890,8 ## namespace Lucene.Net.QueryParsers
}
if (tok != null) Jj_add_error_token(kind, i);
}
- if (jj_scanpos.kind != kind) return true;
- if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
+ if (jj_scanpos.kind != kind) return true;
+ if (jj_la == 0 && jj_scanpos == jj_lastpos) lookaheadSuccess = true;
return false;
}
## -2029,32 +2023,34 ## namespace Lucene.Net.QueryParsers
}
private void Jj_rescan_token()
- {
+ {
+ bool lookaheadSuccess = false;
jj_rescan = true;
for (int i = 0; i < 1; i++)
{
- try
+ JJCalls p = jj_2_rtns[i];
+ do
{
- JJCalls p = jj_2_rtns[i];
- do
+ if (p.gen > jj_gen)
{
- if (p.gen > jj_gen)
+ jj_la = p.arg;
+ jj_lastpos = jj_scanpos = p.first;
+ switch (i)
{
- jj_la = p.arg;
- jj_lastpos = jj_scanpos = p.first;
- switch (i)
- {
- case 0:
- Jj_3_1();
- break;
- }
+ case 0:
+ Jj_3_1(out lookaheadSuccess);
+ if (lookaheadSuccess)
+ {
+ goto Jj_rescan_token_after_while_label;
+ }
+ break;
}
- p = p.next;
- } while (p != null);
- }
- catch (LookaheadSuccess)
- {
- }
+ }
+ p = p.next;
+ } while (p != null);
+
+ Jj_rescan_token_after_while_label:
+ lookaheadSuccess = false;
}
jj_rescan = false;
}
--
Patch for QueryParser in Lucene 3.0.3 to avoid lots of System.IO.IOException exception throwing:
CharStream.cs:
--- CharStream.cs
+++ CharStream.cs
## -44,6 +44,7 ##
/// implementing this interface. Can throw any java.io.IOException.
/// </summary>
char ReadChar();
+ char ReadChar(ref bool? systemIoException);
/// <summary> Returns the column position of the character last read.</summary>
/// <deprecated>
## -93,6 +94,7 ##
/// to this method to implement backup correctly.
/// </summary>
char BeginToken();
+ char BeginToken(ref bool? systemIoException);
/// <summary> Returns a string made up of characters from the marked token beginning
/// to the current buffer position. Implementations have the choice of returning
FastCharStream.cs:
--- FastCharStream.cs
+++ FastCharStream.cs
## -48,12 +48,35 ##
public char ReadChar()
{
+ bool? systemIoException = null;
if (bufferPosition >= bufferLength)
- Refill();
+ {
+ Refill(ref systemIoException);
+ }
+ return buffer[bufferPosition++];
+ }
+
+ public char ReadChar(ref bool? systemIoException)
+ {
+ if (bufferPosition >= bufferLength)
+ {
+ Refill(ref systemIoException);
+ // If using this Nullable as System.IO.IOException signal and is signaled.
+ if (systemIoException.HasValue && systemIoException.Value == true)
+ {
+ return '\0';
+ }
+ }
return buffer[bufferPosition++];
}
- private void Refill()
+ // You may ask to be signaled of a System.IO.IOException through the systemIoException parameter.
+ // Set it to false if you are interested, it will be set to true to signal a System.IO.IOException.
+ // Set it to null if you are not interested.
+ // This is used to avoid having a lot of System.IO.IOExceptions thrown while running the code under a debugger.
+ // Having a lot of exceptions thrown under a debugger causes the code to execute a lot more slowly.
+ // So use this if you are experimenting a lot of slow parsing at runtime under a debugger.
+ private void Refill(ref bool? systemIoException)
{
int newPosition = bufferLength - tokenStart;
## -86,7 +109,18 ##
int charsRead = input.Read(buffer, newPosition, buffer.Length - newPosition);
if (charsRead <= 0)
- throw new System.IO.IOException("read past eof");
+ {
+ // If interested in using this Nullable to signal a System.IO.IOException
+ if (systemIoException.HasValue)
+ {
+ systemIoException = true;
+ return;
+ }
+ else
+ {
+ throw new System.IO.IOException("read past eof");
+ }
+ }
else
bufferLength += charsRead;
}
## -96,6 +130,12 ##
tokenStart = bufferPosition;
return ReadChar();
}
+
+ public char BeginToken(ref bool? systemIoException)
+ {
+ tokenStart = bufferPosition;
+ return ReadChar(ref systemIoException);
+ }
public void Backup(int amount)
{
## -156,4 +196,4 ##
get { return 1; }
}
}
-}
\ No newline at end of file
+}
QueryParserTokenManager.cs:
--- QueryParserTokenManager.cs
+++ QueryParserTokenManager.cs
## -1341,9 +1341,16 ##
for (; ; )
{
+ bool? systemIoException = false;
try
{
- curChar = input_stream.BeginToken();
+ curChar = input_stream.BeginToken(ref systemIoException);
+ if (systemIoException != null && systemIoException.HasValue && systemIoException.Value == true)
+ {
+ jjmatchedKind = 0;
+ matchedToken = JjFillToken();
+ return matchedToken;
+ }
}
catch (System.IO.IOException)
{
## -1459,4 +1466,4 ##
while (start++ != end);
}
}
-}
\ No newline at end of file
+}
You can also use my github version
https://github.com/franckspike/lucenenet.git