inteligr8/alfresco-community-repo
1
0
Fork 0
mirror of https://github.com/Alfresco/alfresco-community-repo.git synced 2025-08-07 17:49:17 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge from SEAMIST3

Browse Source 
git-svn-id: https://svn.alfresco.com/repos/alfresco-enterprise/alfresco/HEAD/root@10733 c4b6b30b-aa2e-2d43-bbcb-ca4b014f7261
This commit is contained in:
David Caruana
2008-09-04 11:22:17 +00:00
parent 41b5618d1d
commit a6625b1c61
63 changed files with 5450 additions and 962 deletions
Download Patch File Download Diff File Expand all files Collapse all files

155
source/java/org/alfresco/util/SearchLanguageConversion.java
View File

@@ -26,44 +26,60 @@ package org.alfresco.util;
import org.alfresco.repo.search.impl.lucene.QueryParser;
/**
* Helper class to provide conversions between different search languages
*
* @author Derek Hulley
*/
public class SearchLanguageConversion
{
/**
* SQL like query language summary:
* <ul>
* <li>Escape: \</li>
* <li>Single char search: _</li>
* <li>Multiple char search: %</li>
* <li>Reserved: \%_</li>
* </ul>
*/
public static LanguageDefinition DEF_SQL_LIKE = new SimpleLanguageDef('\\', "%", "_", "\\%_[]");
/**
* XPath like query language summary:
* <ul>
* <li>Escape: \</li>
* <li>Single char search: _</li>
* <li>Multiple char search: %</li>
* <li>Reserved: \%_</li>
* <li>Escape: \</li>
* <li>Single char search: _</li>
* <li>Multiple char search: %</li>
* <li>Reserved: \%_</li>
* </ul>
*/
public static LanguageDefinition DEF_XPATH_LIKE = new SimpleLanguageDef('\\', "%", "_", "\\%_[]");
/**
* Regular expression query language summary:
* <ul>
* <li>Escape: \</li>
* <li>Single char search: .</li>
* <li>Multiple char search: .*</li>
* <li>Reserved: \*.+?^$(){}|</li>
* <li>Escape: \</li>
* <li>Single char search: .</li>
* <li>Multiple char search: .*</li>
* <li>Reserved: \*.+?^$(){}|</li>
* </ul>
*/
public static LanguageDefinition DEF_REGEX = new SimpleLanguageDef('\\', ".*", ".", "\\*.+?^$(){}|");
/**
* Lucene syntax summary: {@link QueryParser#escape(String) Lucene Query Parser}
*/
public static LanguageDefinition DEF_LUCENE = new LuceneLanguageDef();
public static LanguageDefinition DEF_LUCENE = new LuceneLanguageDef(true);
public static LanguageDefinition DEF_LUCENE_INTERNAL = new LuceneLanguageDef(false);
/**
* CIFS name patch query language summary:
* <ul>
* <li>Escape: \ (but not used)</li>
* <li>Single char search: ?</li>
* <li>Multiple char search: *</li>
* <li>Reserved: "*\<>?/:|£%&+;</li>
* <li>Escape: \ (but not used)</li>
* <li>Single char search: ?</li>
* <li>Multiple char search: *</li>
* <li>Reserved: "*\<>?/:|£%&+;</li>
* </ul>
*/
public static LanguageDefinition DEF_CIFS = new SimpleLanguageDef('\\', "*", "?", "\"*\\<>?/:|£%&+;");
@@ -71,43 +87,46 @@ public class SearchLanguageConversion
/**
* Escape a string according to the <b>XPath</b> like function syntax.
*
* @param str the string to escape
* @param str
* the string to escape
* @return Returns the escaped string
*/
public static String escapeForXPathLike(String str)
{
return escape(DEF_XPATH_LIKE, str);
}
/**
* Escape a string according to the <b>regex</b> language syntax.
*
* @param str the string to escape
* @param str
* the string to escape
* @return Returns the escaped string
*/
public static String escapeForRegex(String str)
{
return escape(DEF_REGEX, str);
}
/**
* Escape a string according to the <b>Lucene</b> query syntax.
*
* @param str the string to escape
* @param str
* the string to escape
* @return Returns the escaped string
*/
public static String escapeForLucene(String str)
{
return escape(DEF_LUCENE, str);
}
/**
* Generic escaping using the language definition
*/
private static String escape(LanguageDefinition def, String str)
{
StringBuilder sb = new StringBuilder(str.length() * 2);
char[] chars = str.toCharArray();
for (int i = 0; i < chars.length; i++)
{
@@ -121,124 +140,161 @@ public class SearchLanguageConversion
}
return sb.toString();
}
/**
* Convert an <b>xpath</b> like function clause into a <b>regex</b> query.
*
* @param xpathLikeClause
* @return Returns a valid regular expression that is equivalent to the
* given <b>xpath</b> like clause.
* @return Returns a valid regular expression that is equivalent to the given <b>xpath</b> like clause.
*/
public static String convertXPathLikeToRegex(String xpathLikeClause)
{
return "(?s)" + convert(DEF_XPATH_LIKE, DEF_REGEX, xpathLikeClause);
}
/**
* Convert an <b>xpath</b> like function clause into a <b>Lucene</b> query.
*
* @param xpathLikeClause
* @return Returns a valid <b>Lucene</b> expression that is equivalent to the
* given <b>xpath</b> like clause.
* @return Returns a valid <b>Lucene</b> expression that is equivalent to the given <b>xpath</b> like clause.
*/
public static String convertXPathLikeToLucene(String xpathLikeClause)
{
return convert(DEF_XPATH_LIKE, DEF_LUCENE, xpathLikeClause);
}
/**
* Convert a <b>sql</b> like function clause into a <b>Lucene</b> query.
*
* @param sqlLikeClause
* @return Returns a valid <b>Lucene</b> expression that is equivalent to the given <b>sql</b> like clause.
*/
public static String convertSQLLikeToLucene(String sqlLikeClause)
{
return convert(DEF_SQL_LIKE, DEF_LUCENE_INTERNAL, sqlLikeClause);
}
/**
* Convert a <b>sql</b> like function clause into a <b>regex</b> query.
*
* @param sqlLikeClause
* @return Returns a valid regular expression that is equivalent to the given <b>sql</b> like clause.
*/
public static String convertSQLLikeToRegex(String sqlLikeClause)
{
return "(?s)" + convert(DEF_SQL_LIKE, DEF_REGEX, sqlLikeClause);
}
/**
* Convert a <b>CIFS</b> name path into the equivalent <b>Lucene</b> query.
*
* @param cifsNamePath the CIFS named path
* @return Returns a valid <b>Lucene</b> expression that is equivalent to the
* given CIFS name path
* @param cifsNamePath
* the CIFS named path
* @return Returns a valid <b>Lucene</b> expression that is equivalent to the given CIFS name path
*/
public static String convertCifsToLucene(String cifsNamePath)
{
return convert(DEF_CIFS, DEF_LUCENE, cifsNamePath);
}
public static String convert(LanguageDefinition from, LanguageDefinition to, String query)
{
char[] chars = query.toCharArray();
StringBuilder sb = new StringBuilder(chars.length * 2);
boolean escaping = false;
for (int i = 0; i < chars.length; i++)
{
if (escaping) // if we are currently escaping, just escape the current character
if (escaping) // if we are currently escaping, just escape the current character
{
sb.append(to.escapeChar); // the to format escape char
sb.append(chars[i]); // the current char
sb.append(to.escapeChar); // the to format escape char
sb.append(chars[i]); // the current char
escaping = false;
}
else if (chars[i] == from.escapeChar) // not escaping and have escape char
else if (chars[i] == from.escapeChar) // not escaping and have escape char
{
escaping = true;
}
else if (query.startsWith(from.multiCharWildcard, i)) // not escaping but have multi-char wildcard
else if (query.startsWith(from.multiCharWildcard, i)) // not escaping but have multi-char wildcard
{
// translate the wildcard
sb.append(to.multiCharWildcard);
}
else if (query.startsWith(from.singleCharWildcard, i)) // have single-char wildcard
else if (query.startsWith(from.singleCharWildcard, i)) // have single-char wildcard
{
// translate the wildcard
sb.append(to.singleCharWildcard);
}
else if (to.isReserved(chars[i])) // reserved character
else if (to.isReserved(chars[i])) // reserved character
{
sb.append(to.escapeChar).append(chars[i]);
}
else // just a normal char in both
else
// just a normal char in both
{
sb.append(chars[i]);
}
}
return sb.toString();
}
/**
* Simple store of special characters for a given query language
*/
public static abstract class LanguageDefinition
{
public final char escapeChar;
public final String multiCharWildcard;
public final String singleCharWildcard;
public LanguageDefinition(char escapeChar, String multiCharWildcard, String singleCharWildcard)
{
this.escapeChar = escapeChar;
this.multiCharWildcard = multiCharWildcard;
this.singleCharWildcard = singleCharWildcard;
}
public abstract boolean isReserved(char ch);
}
private static class SimpleLanguageDef extends LanguageDefinition
{
private String reserved;
public SimpleLanguageDef(char escapeChar, String multiCharWildcard, String singleCharWildcard, String reserved)
{
super(escapeChar, multiCharWildcard, singleCharWildcard);
this.reserved = reserved;
this.reserved = reserved;
}
@Override
public boolean isReserved(char ch)
{
return (reserved.indexOf(ch) > -1);
}
}
private static class LuceneLanguageDef extends LanguageDefinition
{
private String reserved;
public LuceneLanguageDef()
public LuceneLanguageDef(boolean reserve)
{
super('\\', "*", "?");
init();
if (reserve)
{
init();
}
else
{
reserved = "";
}
}
/**
* Discovers all the reserved chars
*/
@@ -247,7 +303,7 @@ public class SearchLanguageConversion
StringBuilder sb = new StringBuilder(20);
for (char ch = 0; ch < 256; ch++)
{
char[] chars = new char[] {ch};
char[] chars = new char[] { ch };
String unescaped = new String(chars);
// check it
String escaped = QueryParser.escape(unescaped);
@@ -259,6 +315,7 @@ public class SearchLanguageConversion
}
reserved = sb.toString();
}
@Override
public boolean isReserved(char ch)
{