@Inject private ExpressionEvaluator(DatalogTools datalogTools, TermFactory termFactory, TypeFactory typeFactory, UnifierUtilities unifierUtilities, ExpressionNormalizer normalizer, ImmutabilityTools immutabilityTools, RDF rdfFactory) { this.termFactory = termFactory; this.typeFactory = typeFactory; this.datalogTools = datalogTools; valueFalse = termFactory.getBooleanConstant(false); valueTrue = termFactory.getBooleanConstant(true); valueNull = termFactory.getNullConstant(); this.unifierUtilities = unifierUtilities; this.normalizer = normalizer; this.immutabilityTools = immutabilityTools; this.rdfFactory = rdfFactory; }
private Term evalIsLiteral(Function term) { Term innerTerm = term.getTerm(0); if (innerTerm instanceof Function) { Function function = (Function) innerTerm; return TERM_FACTORY.getBooleanConstant(function.isDataTypeFunction()); } else { return term; } }
private Term evalIsLiteral(Function term) { Term innerTerm = term.getTerm(0); if (innerTerm instanceof Function) { Function function = (Function) innerTerm; return termFactory.getBooleanConstant(function.isDataTypeFunction()); } else { return term; } }
private int getDataType(Term term) { /* * TODO: refactor! */ if (term instanceof Function){ Function f = (Function) term; Predicate p = f.getFunctionSymbol(); if (p instanceof DatatypePredicate) { RDFDatatype type = ((DatatypePredicate) p).getReturnedType(); return jdbcTypeMapper.getSQLType(type); } // return varchar for unknown return Types.VARCHAR; } else if (term instanceof Variable) { throw new RuntimeException("Cannot return the SQL type for: " + term); } /* * Boolean constant */ else if (term.equals(termFactory.getBooleanConstant(false)) || term.equals(termFactory.getBooleanConstant(true))) { return Types.BOOLEAN; } return Types.VARCHAR; }
private Term evalUriTemplateEqNeq(Function uriFunction1, Function uriFunction2, boolean isEqual) { int arityForFunction1 = uriFunction1.getArity(); int arityForFunction2 = uriFunction2.getArity(); if (arityForFunction1 == 1) { if (arityForFunction2 == 1) { return evalUriFunctionsWithSingleTerm(uriFunction1, uriFunction2, isEqual); } else if (arityForFunction2 > 1) { // Currently, we assume the arity should be the same (already decomposed URIs) return termFactory.getBooleanConstant(!isEqual); } } else if (arityForFunction1 > 1) { if (arityForFunction2 == 1) { // Currently, we assume the arity should be the same (already decomposed URIs) return termFactory.getBooleanConstant(!isEqual); } else if (arityForFunction2 > 1) { return evalUriFunctionsWithMultipleTerms(uriFunction1, uriFunction2, isEqual); } } return null; }
private Term evalIsBlank(Function term) { Term teval = eval(term.getTerm(0)); if (teval instanceof Function) { Function function = (Function) teval; Predicate predicate = function.getFunctionSymbol(); return termFactory.getBooleanConstant(predicate instanceof BNodePredicate); } return term; }
private Term evalUriTemplateEqNeq(Function uriFunction1, Function uriFunction2, boolean isEqual) { int arityForFunction1 = uriFunction1.getArity(); int arityForFunction2 = uriFunction2.getArity(); if (arityForFunction1 == 1) { if (arityForFunction2 == 1) { return evalUriFunctionsWithSingleTerm(uriFunction1, uriFunction2, isEqual); } else if (arityForFunction2 > 1) { // Currently, we assume the arity should be the same (already decomposed URIs) return TERM_FACTORY.getBooleanConstant(!isEqual); } } else if (arityForFunction1 > 1) { if (arityForFunction2 == 1) { // Currently, we assume the arity should be the same (already decomposed URIs) return TERM_FACTORY.getBooleanConstant(!isEqual); } else if (arityForFunction2 > 1) { return evalUriFunctionsWithMultipleTerms(uriFunction1, uriFunction2, isEqual); } } return null; }
private Term evalIsIri(Function term) { Term teval = eval(term.getTerm(0)); if (teval instanceof Function) { Function function = (Function) teval; Predicate predicate = function.getFunctionSymbol(); return TERM_FACTORY.getBooleanConstant(predicate instanceof URITemplatePredicate); } return term; }
private Term evalIsIri(Function term) { Term teval = eval(term.getTerm(0)); if (teval instanceof Function) { Function function = (Function) teval; Predicate predicate = function.getFunctionSymbol(); return termFactory.getBooleanConstant(predicate instanceof URITemplatePredicate); } return term; }
private Term evalIsBlank(Function term) { Term teval = eval(term.getTerm(0)); if (teval instanceof Function) { Function function = (Function) teval; Predicate predicate = function.getFunctionSymbol(); return TERM_FACTORY.getBooleanConstant(predicate instanceof BNodePredicate); } return term; }
private Term evalUriFunctionsWithMultipleTerms(Function uriFunction1, Function uriFunction2, boolean isEqual) { if (uriFunction1.equals(uriFunction2)) return termFactory.getBooleanConstant(isEqual); return termFactory.getBooleanConstant(!isEqual); return termFactory.getBooleanConstant(!isEqual);
private Term evalUriFunctionsWithMultipleTerms(Function uriFunction1, Function uriFunction2, boolean isEqual) { Substitution theta = UnifierUtilities.getMGU(uriFunction1, uriFunction2); if (theta == null) { return TERM_FACTORY.getBooleanConstant(!isEqual); return TERM_FACTORY.getBooleanConstant(!isEqual);
@Inject private DatalogTools(TermFactory termFactory, DatalogFactory datalogFactory) { this.termFactory = termFactory; this.datalogFactory = datalogFactory; ValueConstant valueTrue = termFactory.getBooleanConstant(true); TRUE_EQ = termFactory.getFunctionEQ(valueTrue, valueTrue); IS_DATA_OR_LJ_OR_JOIN_ATOM_FCT = this::isDataOrLeftJoinOrJoinAtom; IS_NOT_DATA_OR_COMPOSITE_ATOM_FCT = atom -> !isDataOrLeftJoinOrJoinAtom(atom); IS_BOOLEAN_ATOM_FCT = atom -> atom.isOperation() || isXsdBoolean(atom.getFunctionSymbol()); }
private Term evalIsNumeric(Function term) { Term innerTerm = term.getTerm(0); if (innerTerm instanceof Function) { Function function = (Function) innerTerm; return TERM_FACTORY.getBooleanConstant(function.isDataTypeFunction() && isNumeric(function.getFunctionSymbol())); } else { return term; } }
private Term evalIsNumeric(Function term) { Term innerTerm = term.getTerm(0); if (innerTerm instanceof Function) { Function function = (Function) innerTerm; return termFactory.getBooleanConstant(function.isDataTypeFunction() && isNumeric(function.getFunctionSymbol())); } else { return term; } }
return termFactory.getBooleanConstant(isEqual); else return termFactory.getFunctionNEQ(term1, term2); return termFactory.getBooleanConstant(!isEqual);
return TERM_FACTORY.getBooleanConstant(isEqual); else return TERM_FACTORY.getFunctionNEQ(term1, term2); return TERM_FACTORY.getBooleanConstant(!isEqual);
@Override public void visit(Column expression) { QuotedID column = idfac.createAttributeID(expression.getColumnName()); Table table = expression.getTable(); RelationID relation = (table != null) && (table.getName() != null) ? idfac.createRelationID(table.getSchemaName(), table.getName()) : null; QualifiedAttributeID qa = new QualifiedAttributeID(relation, column); Term var = attributes.get(qa); if (var == null) { // can be // - a CONSTANT or // - a PSEUDO-COLUMN like ROWID, ROWNUM or // - a FUNCTION without arguments like USER, CURRENT_DATE if (column.equals(idfac.createAttributeID("true"))) result = TERM_FACTORY.getBooleanConstant(true); else if (column.equals(idfac.createAttributeID("false"))) result = TERM_FACTORY.getBooleanConstant(false); else throw new UnsupportedSelectQueryRuntimeException("Unable to find attribute name ", expression); } else { // if it is an attribute name (qualified or not) result = var; } }
@Override public void visit(SWRLLiteralArgument node) { OWLLiteral literal=node.getLiteral(); if (literal.isBoolean()) terms.add(termFactory.getBooleanConstant(literal.parseBoolean())); else if(literal.hasLang()) terms.add(termFactory.getConstantLiteral(literal.getLiteral(), literal.getLang())); else if (literal.isDouble()) terms.add(termFactory.getConstantLiteral(literal.getLiteral(), typeFactory.getXsdDoubleDatatype())); else if (literal.isFloat()) terms.add(termFactory.getConstantLiteral(literal.getLiteral(), typeFactory.getXsdDecimalDatatype())); else if (literal.isInteger()) terms.add(termFactory.getConstantLiteral(literal.getLiteral(), typeFactory.getXsdIntegerDatatype())); else termFactory.getConstantLiteral(literal.getLiteral()); }
@Override public void visit(Column expression) { QuotedID column = idfac.createAttributeID(expression.getColumnName()); Table table = expression.getTable(); RelationID relation = (table != null) && (table.getName() != null) ? idfac.createRelationID(table.getSchemaName(), table.getName()) : null; QualifiedAttributeID qa = new QualifiedAttributeID(relation, column); Term var = attributes.get(qa); if (var == null) { // can be // - a CONSTANT or // - a PSEUDO-COLUMN like ROWID, ROWNUM or // - a FUNCTION without arguments like USER, CURRENT_DATE if (column.equals(idfac.createAttributeID("true"))) result = termFactory.getBooleanConstant(true); else if (column.equals(idfac.createAttributeID("false"))) result = termFactory.getBooleanConstant(false); else throw new UnsupportedSelectQueryRuntimeException("Unable to find attribute name ", expression); } else { // if it is an attribute name (qualified or not) result = var; } }