@Override
public void meet(IsNumeric node) throws RuntimeException {
ValueExpr arg = node.getArg();
// operator must be a variable or a constant
if (arg instanceof ValueConstant) {
try {
Double.parseDouble(((ValueConstant) arg).getValue().stringValue());
builder.append(Boolean.toString(true));
} catch (NumberFormatException ex) {
builder.append(Boolean.toString(false));
}
} else if (arg instanceof Var) {
String var = getVariableAlias((Var) arg);
Preconditions.checkState(var != null, "no alias available for variable");
builder
.append("(")
.append(var)
.append(".ntype = 'int' OR ")
.append(var)
.append(".ntype = 'double')");
}
}
@Override
public void meet(IsLiteral node) throws RuntimeException {
ValueExpr arg = node.getArg();
// operator must be a variable or a constant
if (arg instanceof ValueConstant) {
builder.append(Boolean.toString(((ValueConstant) arg).getValue() instanceof Literal));
} else if (arg instanceof Var) {
String var = getVariableAlias((Var) arg);
Preconditions.checkState(var != null, "no alias available for variable");
builder
.append("(")
.append(var)
.append(".ntype = 'string' OR ")
.append(var)
.append(".ntype = 'int' OR ")
.append(var)
.append(".ntype = 'double' OR ")
.append(var)
.append(".ntype = 'date' OR ")
.append(var)
.append(".ntype = 'boolean')");
}
}
@Override
public void meet(MathExpr expr) throws RuntimeException {
ValueType ot = new OPTypeFinder(expr).coerce();
if (ot == ValueType.STRING) {
if (expr.getOperator() == MathExpr.MathOp.PLUS) {
builder.append(
functionRegistry
.get(FN.CONCAT.stringValue())
.getNative(
parent.getDialect(),
new ValueExpressionEvaluator(expr.getLeftArg(), parent, ot).build(),
new ValueExpressionEvaluator(expr.getRightArg(), parent, ot).build()));
} else {
throw new IllegalArgumentException(
"operation " + expr.getOperator() + " is not supported on strings");
}
} else {
if (ot == ValueType.NODE || ot == ValueType.TERM) {
ot = ValueType.DOUBLE;
}
optypes.push(ot);
expr.getLeftArg().visit(this);
builder.append(getSQLOperator(expr.getOperator()));
expr.getRightArg().visit(this);
optypes.pop();
}
}
@Override
public void meet(Count node) throws RuntimeException {
builder.append("COUNT(");
if (node.isDistinct()) {
builder.append("DISTINCT ");
}
if (node.getArg() == null) {
// this is a weird special case where we need to expand to all variables selected in the query
// wrapped
// by the group; we cannot simply use "*" because the concept of variables is a different one
// in SQL,
// so instead we construct an ARRAY of the bindings of all variables
List<String> countVariables = new ArrayList<>();
for (SQLVariable v : parent.getVariables().values()) {
if (v.getProjectionType() == ValueType.NONE) {
Preconditions.checkState(
v.getExpressions().size() > 0, "no expressions available for variable");
countVariables.add(v.getExpressions().get(0));
}
}
builder.append("ARRAY[");
Joiner.on(',').appendTo(builder, countVariables);
builder.append("]");
} else {
optypes.push(ValueType.NODE);
node.getArg().visit(this);
optypes.pop();
}
builder.append(")");
}
@Override
public void meet(And node) throws RuntimeException {
builder.append("(");
node.getLeftArg().visit(this);
builder.append(" AND ");
node.getRightArg().visit(this);
builder.append(")");
}
@Override
public void meet(Sum node) throws RuntimeException {
builder.append("SUM(");
optypes.push(ValueType.DOUBLE);
node.getArg().visit(this);
optypes.pop();
builder.append(")");
}
@Override
public void meet(Lang lang) throws RuntimeException {
if (lang.getArg() instanceof Var) {
String var = getVariableAlias((Var) lang.getArg());
Preconditions.checkState(var != null, "no alias available for variable");
builder.append(var);
builder.append(".lang");
}
}
@Override
public void meet(Coalesce node) throws RuntimeException {
builder.append("COALESCE(");
for (Iterator<ValueExpr> it = node.getArguments().iterator(); it.hasNext(); ) {
it.next().visit(this);
if (it.hasNext()) {
builder.append(", ");
}
}
builder.append(")");
}
@Override
public void meet(IsBNode node) throws RuntimeException {
ValueExpr arg = node.getArg();
// operator must be a variable or a constant
if (arg instanceof ValueConstant) {
builder.append(Boolean.toString(((ValueConstant) arg).getValue() instanceof BNode));
} else if (arg instanceof Var) {
String var = getVariableAlias((Var) arg);
builder.append(var).append(".ntype = 'bnode'");
}
}
@Override
public void meet(Bound node) throws RuntimeException {
ValueExpr arg = node.getArg();
if (arg instanceof ValueConstant) {
builder.append(Boolean.toString(true));
} else if (arg instanceof Var) {
builder.append("(");
optypes.push(ValueType.NODE);
arg.visit(this);
optypes.pop();
builder.append(" IS NOT NULL)");
}
}
@Override
public void meet(FunctionCall fc) throws RuntimeException {
// special optimizations for frequent cases with variables
if ((XMLSchema.DOUBLE.toString().equals(fc.getURI())
|| XMLSchema.FLOAT.toString().equals(fc.getURI()))
&& fc.getArgs().size() == 1) {
optypes.push(ValueType.DOUBLE);
fc.getArgs().get(0).visit(this);
optypes.pop();
} else if ((XMLSchema.INTEGER.toString().equals(fc.getURI())
|| XMLSchema.INT.toString().equals(fc.getURI()))
&& fc.getArgs().size() == 1) {
optypes.push(ValueType.INT);
fc.getArgs().get(0).visit(this);
optypes.pop();
} else if (XMLSchema.BOOLEAN.toString().equals(fc.getURI()) && fc.getArgs().size() == 1) {
optypes.push(ValueType.BOOL);
fc.getArgs().get(0).visit(this);
optypes.pop();
} else if (XMLSchema.DATE.toString().equals(fc.getURI()) && fc.getArgs().size() == 1) {
optypes.push(ValueType.DATE);
fc.getArgs().get(0).visit(this);
optypes.pop();
} else {
String fnUri = fc.getURI();
String[] args = new String[fc.getArgs().size()];
NativeFunction nf = functionRegistry.get(fnUri);
if (nf != null && nf.isSupported(parent.getDialect())) {
for (int i = 0; i < args.length; i++) {
args[i] =
new ValueExpressionEvaluator(fc.getArgs().get(i), parent, nf.getArgumentType(i))
.build();
}
if (optypes.peek() != nf.getReturnType()) {
builder.append(castExpression(nf.getNative(parent.getDialect(), args), optypes.peek()));
} else {
builder.append(nf.getNative(parent.getDialect(), args));
}
} else {
throw new IllegalArgumentException(
"the function " + fnUri + " is not supported by the SQL translation");
}
}
}
@Override
public void meet(If node) throws RuntimeException {
builder.append("CASE WHEN ");
optypes.push(ValueType.BOOL);
node.getCondition().visit(this);
optypes.pop();
optypes.push(new OPTypeFinder(node).coerce());
builder.append(" THEN ");
node.getResult().visit(this);
builder.append(" ELSE ");
node.getAlternative().visit(this);
builder.append(" END");
optypes.pop();
}
@Override
public void meet(Regex re) throws RuntimeException {
builder.append(
optimizeRegexp(
new ValueExpressionEvaluator(re.getArg(), parent, ValueType.STRING).build(),
new ValueExpressionEvaluator(re.getPatternArg(), parent, ValueType.STRING).build(),
re.getFlagsArg()));
}
@Override
public void meet(Compare cmp) throws RuntimeException {
optypes.push(new OPTypeFinder(cmp).coerce());
cmp.getLeftArg().visit(this);
builder.append(getSQLOperator(cmp.getOperator()));
cmp.getRightArg().visit(this);
optypes.pop();
}
@Override
public void meet(SameTerm cmp) throws RuntimeException {
// covered by value binding in variables
optypes.push(ValueType.TERM);
cmp.getLeftArg().visit(this);
builder.append(" = ");
cmp.getRightArg().visit(this);
optypes.pop();
}
@Override
public void meet(Like node) throws RuntimeException {
if (node.isCaseSensitive()) {
optypes.push(ValueType.STRING);
node.getArg().visit(this);
optypes.pop();
builder.append(" LIKE ");
node.getPattern();
} else {
builder.append(
parent
.getDialect()
.getILike(
new ValueExpressionEvaluator(node.getArg(), parent, ValueType.STRING).build(),
node.getOpPattern()));
}
}
@Override
public void meet(GroupConcat node) throws RuntimeException {
if (node.getSeparator() == null) {
builder.append(
parent
.getDialect()
.getGroupConcat(
new ValueExpressionEvaluator(node.getArg(), parent, ValueType.STRING).build(),
null,
node.isDistinct()));
} else {
builder.append(
parent
.getDialect()
.getGroupConcat(
new ValueExpressionEvaluator(node.getArg(), parent, ValueType.STRING).build(),
new ValueExpressionEvaluator(node.getSeparator(), parent, ValueType.STRING)
.build(),
node.isDistinct()));
}
}
@Override
public void meet(ValueConstant node) throws RuntimeException {
String val = node.getValue().stringValue();
switch (optypes.peek()) {
case STRING:
case URI:
builder.append("'").append(val).append("'");
break;
case INT:
builder.append(Integer.parseInt(val));
break;
case DECIMAL:
case DOUBLE:
builder.append(Double.parseDouble(val));
break;
case BOOL:
builder.append(Boolean.parseBoolean(val));
break;
case DATE:
builder.append("'").append(sqlDateFormat.format(DateUtils.parseDate(val))).append("'");
break;
// in this case we should return a node ID and also need to make sure it actually exists
case TERM:
case NODE:
KiWiNode n = parent.getConverter().convert(node.getValue());
builder.append(n.getId());
break;
default:
throw new IllegalArgumentException("unsupported value type: " + optypes.peek());
}
}
@Override
public void meet(BNodeGenerator gen) throws RuntimeException {
if (gen.getNodeIdExpr() != null) {
// get value of argument and express it as string
optypes.push(ValueType.STRING);
gen.getNodeIdExpr().visit(this);
optypes.pop();
} else {
builder
.append("'")
.append(
Long.toHexString(System.currentTimeMillis())
+ Integer.toHexString(anonIdGenerator.nextInt(1000)))
.append("'");
}
}
@Override
public void meet(LangMatches lm) throws RuntimeException {
ValueConstant pattern = (ValueConstant) lm.getRightArg();
if (pattern.getValue().stringValue().equals("*")) {
lm.getLeftArg().visit(this);
builder.append(" LIKE '%'");
} else if (pattern.getValue().stringValue().equals("")) {
lm.getLeftArg().visit(this);
builder.append(" IS NULL");
} else {
builder.append("(");
lm.getLeftArg().visit(this);
builder.append(" = '");
builder.append(pattern.getValue().stringValue().toLowerCase());
builder.append("' OR ");
lm.getLeftArg().visit(this);
builder.append(" LIKE '");
builder.append(pattern.getValue().stringValue().toLowerCase());
builder.append("-%' )");
}
}
@Override
public void meet(Exists node) throws RuntimeException {
// TODO: need to make sure that variables of the parent are visible in the subquery
// - pattern names need to be unique even in subqueries
// - variable lookup for expressions in the subquery need to refer to the parent
SQLBuilder sq_builder =
new SQLBuilder(
node.getSubQuery(),
parent.getBindings(),
parent.getDataset(),
parent.getConverter(),
parent.getDialect(),
"_",
Collections.EMPTY_SET,
copyVariables(parent.getVariables()));
builder.append("EXISTS (").append(sq_builder.build()).append(")");
}
@Override
public void meet(IRIFunction fun) throws RuntimeException {
if (fun.getBaseURI() != null) {
String ex = new ValueExpressionEvaluator(fun.getArg(), parent, ValueType.STRING).build();
builder
.append("CASE WHEN position(':' IN ")
.append(ex)
.append(") > 0 THEN ")
.append(ex)
.append(" ELSE ")
.append(
functionRegistry
.get(FN.CONCAT.stringValue())
.getNative(parent.getDialect(), "'" + fun.getBaseURI() + "'", ex))
.append(" END ");
} else {
// get value of argument and express it as string
optypes.push(ValueType.STRING);
fun.getArg().visit(this);
optypes.pop();
}
}
@Override
public void meet(Not node) throws RuntimeException {
builder.append("NOT (");
node.getArg().visit(this);
builder.append(")");
}
@Override
public void meet(Var node) throws RuntimeException {
// distinguish between the case where the variable is plain and the variable is bound
SQLVariable sv = parent.getVariables().get(node.getName());
if (sv == null) {
builder.append("NULL");
} else if (sv.getBindings().size() > 0) {
// in case the variable is actually an alias for an expression, we evaluate that expression
// instead, effectively replacing the
// variable occurrence with its value
sv.getBindings().get(0).visit(this);
} else {
String var = sv.getAlias();
if (sv.getProjectionType() != ValueType.NODE && sv.getProjectionType() != ValueType.NONE) {
// in case the variable represents a constructed or bound value instead of a node, we need
// to
// use the SQL expression as value; SQL should take care of proper casting...
// TODO: explicit casting needed?
builder.append(sv.getExpressions().get(0));
} else {
// in case the variable represents an entry from the NODES table (i.e. has been bound to a
// node
// in the database, we take the NODES alias and resolve to the correct column according to
// the
// operator type
switch (optypes.peek()) {
case STRING:
Preconditions.checkState(var != null, "no alias available for variable");
builder.append(var).append(".svalue");
break;
case INT:
Preconditions.checkState(var != null, "no alias available for variable");
builder.append(var).append(".ivalue");
break;
case DECIMAL:
case DOUBLE:
Preconditions.checkState(var != null, "no alias available for variable");
builder.append(var).append(".dvalue");
break;
case BOOL:
Preconditions.checkState(var != null, "no alias available for variable");
builder.append(var).append(".bvalue");
break;
case DATE:
Preconditions.checkState(var != null, "no alias available for variable");
builder.append(var).append(".tvalue");
break;
case TZDATE:
Preconditions.checkState(var != null, "no alias available for variable");
builder.append(parent.getDialect().getDateTimeTZ(var));
break;
case URI:
Preconditions.checkState(var != null, "no alias available for variable");
builder.append(var).append(".svalue");
break;
case TERM:
case NODE:
if (sv.getExpressions().size() > 0) {
// this allows us to avoid joins with the nodes table for simple expressions that only
// need the ID
builder.append(sv.getExpressions().get(0));
} else {
Preconditions.checkState(var != null, "no alias available for variable");
builder.append(var).append(".id");
}
break;
}
}
}
}