private string FilterToSQL(LiteralFilter filter, string col)
{
if (filter is SemWeb.Filters.StringCompareFilter)
{
SemWeb.Filters.StringCompareFilter f = (SemWeb.Filters.StringCompareFilter)filter;
return(col + FilterOpToSQL(f.Type) + Escape(f.Pattern, true));
}
/*if (filter is SemWeb.Filters.StringContainsFilter) {
* SemWeb.Filters.StringContainsFilter f = (SemWeb.Filters.StringContainsFilter)filter;
* return CreateLikeTest(col, f.Pattern, 1); // 1=contains
* }*/
if (filter is SemWeb.Filters.StringStartsWithFilter)
{
SemWeb.Filters.StringStartsWithFilter f = (SemWeb.Filters.StringStartsWithFilter)filter;
return(CreatePrefixTest(col, f.Pattern)); // 0=starts-with
}
if (filter is SemWeb.Filters.NumericCompareFilter)
{
SemWeb.Filters.NumericCompareFilter f = (SemWeb.Filters.NumericCompareFilter)filter;
return(col + FilterOpToSQL(f.Type) + f.Number);
}
return(null);
}
protected override void extractLiteralFilters(name.levering.ryan.sparql.model.logic.ExpressionLogic node, java.util.Map literalFilters)
{
//Console.Error.WriteLine(node + " " + node.GetType());
base.extractLiteralFilters(node, literalFilters);
if (node is BinaryExpressionNode) {
BinaryExpressionNode b = (BinaryExpressionNode)node;
LiteralFilter.CompType comp;
if (node is ASTEqualsNode)
comp = LiteralFilter.CompType.EQ;
else if (node is ASTNotEqualsNode)
comp = LiteralFilter.CompType.NE;
else if (node is ASTGreaterThanNode)
comp = LiteralFilter.CompType.GT;
else if (node is ASTGreaterThanEqualsNode)
comp = LiteralFilter.CompType.GE;
else if (node is ASTLessThanNode)
comp = LiteralFilter.CompType.LT;
else if (node is ASTLessThanEqualsNode)
comp = LiteralFilter.CompType.LE;
else
return;
SparqlVariable var;
name.levering.ryan.sparql.common.Literal val;
object left = RemoveCast(b.getLeftExpression());
object right = RemoveCast(b.getRightExpression());
if (left is ASTVar && right is name.levering.ryan.sparql.common.Literal) {
var = (SparqlVariable)left;
val = (name.levering.ryan.sparql.common.Literal)right;
} else if (right is ASTVar && left is name.levering.ryan.sparql.common.Literal) {
var = (SparqlVariable)right;
val = (name.levering.ryan.sparql.common.Literal)left;
switch (comp) {
case LiteralFilter.CompType.LT: comp = LiteralFilter.CompType.GE; break;
case LiteralFilter.CompType.LE: comp = LiteralFilter.CompType.GT; break;
case LiteralFilter.CompType.GT: comp = LiteralFilter.CompType.LE; break;
case LiteralFilter.CompType.GE: comp = LiteralFilter.CompType.LT; break;
}
} else {
return;
}
object parsedvalue = new Literal(val.getLabel(), null, val.getDatatype() == null ? null : val.getDatatype().getURI()).ParseValue();
LiteralFilter filter = LiteralFilter.Create(comp, parsedvalue);
addLiteralFilter(var, filter, literalFilters);
} else if (node is ASTRegexFuncNode) {
ASTRegexFuncNode renode = (ASTRegexFuncNode)node;
SparqlVariable var = RemoveCast(renode.getArguments().get(0)) as ASTVar;
name.levering.ryan.sparql.common.Literal relit = RemoveCast(renode.getArguments().get(1)) as name.levering.ryan.sparql.common.Literal;
if (var == null || relit == null) return;
string re = relit.getLabel();
if (re.Length == 0) return;
bool startsW = removeChar(ref re, '^', 0); // chop of ^ from start, return whether it was there
bool endsW = removeChar(ref re, '$', 1); // chop of $ from end, return whether it was there
// make sure the re that's left has no special re characters
foreach (char c in re)
if (c == '(' || c == '[' || c == '{' || c == '*' || c == '?' || c == '+' || c == '\\' || c == '|' || c == '.')
return;
LiteralFilter filter;
if (startsW && endsW) {
filter = LiteralFilter.Create(LiteralFilter.CompType.EQ, re);
} else if (startsW) {
filter = new SemWeb.Filters.StringStartsWithFilter(re);
} else if (endsW) {
filter = new SemWeb.Filters.StringEndsWithFilter(re);
} else {
filter = new SemWeb.Filters.StringContainsFilter(re);
}
addLiteralFilter(var, filter, literalFilters);
}
}
