基于知识图谱的农业病虫害数据查询系统(附数据爬虫)

package de.fuberlin.wiwiss.d2rq.optimizer.expr; import java.util.ArrayList; import java.util.Collections; import java.util.Iterator; import java.util.List; import java.util.Stack; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import com.hp.hpl.jena.datatypes.RDFDatatype; import com.hp.hpl.jena.datatypes.xsd.XSDDatatype; import com.hp.hpl.jena.graph.Node; import com.hp.hpl.jena.sparql.core.Var; import com.hp.hpl.jena.sparql.expr.E_Add; import com.hp.hpl.jena.sparql.expr.E_Datatype; import com.hp.hpl.jena.sparql.expr.E_Divide; import com.hp.hpl.jena.sparql.expr.E_Equals; import com.hp.hpl.jena.sparql.expr.E_GreaterThan; import com.hp.hpl.jena.sparql.expr.E_GreaterThanOrEqual; import com.hp.hpl.jena.sparql.expr.E_IsBlank; import com.hp.hpl.jena.sparql.expr.E_IsIRI; import com.hp.hpl.jena.sparql.expr.E_IsLiteral; import com.hp.hpl.jena.sparql.expr.E_Lang; import com.hp.hpl.jena.sparql.expr.E_LangMatches; import com.hp.hpl.jena.sparql.expr.E_LessThan; import com.hp.hpl.jena.sparql.expr.E_LessThanOrEqual; import com.hp.hpl.jena.sparql.expr.E_LogicalNot; import com.hp.hpl.jena.sparql.expr.E_LogicalOr; import com.hp.hpl.jena.sparql.expr.E_Multiply; import com.hp.hpl.jena.sparql.expr.E_NotEquals; import com.hp.hpl.jena.sparql.expr.E_SameTerm; import com.hp.hpl.jena.sparql.expr.E_Str; import com.hp.hpl.jena.sparql.expr.E_Subtract; import com.hp.hpl.jena.sparql.expr.E_UnaryMinus; import com.hp.hpl.jena.sparql.expr.E_UnaryPlus; import com.hp.hpl.jena.sparql.expr.Expr; import com.hp.hpl.jena.sparql.expr.ExprAggregator; import com.hp.hpl.jena.sparql.expr.ExprEvalException; import com.hp.hpl.jena.sparql.expr.ExprFunction; import com.hp.hpl.jena.sparql.expr.ExprFunction0; import com.hp.hpl.jena.sparql.expr.ExprFunction1; import com.hp.hpl.jena.sparql.expr.ExprFunction2; import com.hp.hpl.jena.sparql.expr.ExprFunction3; import com.hp.hpl.jena.sparql.expr.ExprFunctionN; import com.hp.hpl.jena.sparql.expr.ExprFunctionOp; import com.hp.hpl.jena.sparql.expr.ExprVar; import com.hp.hpl.jena.sparql.expr.ExprVisitor; import com.hp.hpl.jena.sparql.expr.NodeValue; import com.hp.hpl.jena.sparql.expr.nodevalue.NodeFunctions; import com.hp.hpl.jena.sparql.expr.nodevalue.NodeValueBoolean; import de.fuberlin.wiwiss.d2rq.algebra.Attribute; import de.fuberlin.wiwiss.d2rq.algebra.ExpressionProjectionSpec; import de.fuberlin.wiwiss.d2rq.algebra.NodeRelation; import de.fuberlin.wiwiss.d2rq.algebra.ProjectionSpec; import de.fuberlin.wiwiss.d2rq.algebra.RelationalOperators; import de.fuberlin.wiwiss.d2rq.expr.Add; import de.fuberlin.wiwiss.d2rq.expr.Constant; import de.fuberlin.wiwiss.d2rq.expr.Divide; import de.fuberlin.wiwiss.d2rq.expr.Equality; import de.fuberlin.wiwiss.d2rq.expr.Expression; import de.fuberlin.wiwiss.d2rq.expr.GreaterThan; import de.fuberlin.wiwiss.d2rq.expr.GreaterThanOrEqual; import de.fuberlin.wiwiss.d2rq.expr.LessThan; import de.fuberlin.wiwiss.d2rq.expr.LessThanOrEqual; import de.fuberlin.wiwiss.d2rq.expr.Multiply; import de.fuberlin.wiwiss.d2rq.expr.Negation; import de.fuberlin.wiwiss.d2rq.expr.SQLExpression; import de.fuberlin.wiwiss.d2rq.expr.Subtract; import de.fuberlin.wiwiss.d2rq.expr.UnaryMinus; import de.fuberlin.wiwiss.d2rq.nodes.DetermineNodeType; import de.fuberlin.wiwiss.d2rq.nodes.FixedNodeMaker; import de.fuberlin.wiwiss.d2rq.nodes.NodeMaker; import de.fuberlin.wiwiss.d2rq.nodes.NodeSetConstraintBuilder; import de.fuberlin.wiwiss.d2rq.nodes.TypedNodeMaker; import de.fuberlin.wiwiss.d2rq.values.ValueMaker; /** * Attempts to transform a SPARQL FILTER Expr to a SQL Expression * * Notes: * <ul> * <li>Literals using d2rq:pattern cannot be compared.</li> * <li>No XSD type checking/conversion or constructor functions yet.</li> * </ul> * * @author Herwig Leimer * @author Giovanni Mels */ public final class TransformExprToSQLApplyer implements ExprVisitor { private static final Log logger = LogFactory.getLog(TransformExprToSQLApplyer.class); /** * Converts a SPARQL filter expression to an SQL expression * * @param expr The root node of an {@link Expr Expr} tree, contains the SPARQL filter. * @param nodeRelation The relation supplying the values to apply the filter on. * @return The root node of an {@link Expression Expression} tree, if conversion was successful, <code>null</code> otherwise. */ public static Expression convert(final Expr expr, final NodeRelation nodeRelation) { TransformExprToSQLApplyer transformer = new TransformExprToSQLApplyer(nodeRelation); expr.visit(transformer); return transformer.result(); } // TODO Expression.FALSE and Expression.TRUE are not constants private static final Expression CONSTANT_FALSE = new ConstantEx("false", NodeValueBoolean.FALSE.asNode()); private static final Expression CONSTANT_TRUE = new ConstantEx("true", NodeValueBoolean.TRUE.asNode()); private final NodeRelation nodeRelation; private final Stack<Expression> expression = new Stack<Expression>(); private boolean convertable; // flag if converting was possible private String reason = null; // reason why converting failed /** * Creates an expression transformer. * * @param nodeRelation */ public TransformExprToSQLApplyer(NodeRelation nodeRelation) { this.convertable = true; this.nodeRelation = nodeRelation; } /** * Returns the sql Expression * * @return the transformed sql expression if converting was possible, otherwise null. */ public Expression result() { if (!convertable) { logger.debug("filter conversion failed: " + reason); return null; } if (expression.size() != 1) throw new IllegalStateException("something is seriously wrong"); Expression result = expression.pop(); logger.debug("Resulting filter = " + result); return result; } public void startVisit() { logger.debug("transform started"); } public void finishVisit() { logger.debug("transform finished"); } public void visit(ExprFunction0 func) { visitExprFunction(func); } public void visit(ExprFunction1 function) { logger.debug("visit ExprFunction " + function); if (!convertable) { expression.push(Expression.FALSE); // prevent stack empty exceptions when conversion return; // fails in the middle of a multi-arg operator conversion } convertFunction(function); } public void visit(ExprFunction2 function) { logger.debug("visit ExprFunction " + function); if (!convertable) { expression.push(Expression.FALSE); // prevent stack empty exceptions when conversion return; // fails in the middle of a multi-arg operator conversion } convertFunction(function); } public void visit(ExprFunction3 func) { visitExprFunction(func); } public void visit(ExprFunctionN func) { visitExprFunction(func); } public void visit(ExprFunctionOp funcOp) { visitExprFunction(funcOp); } public void visit(ExprAggregator eAgg) { conversionFailed(eAgg); } public void visit(ExprVar var) { logger.debug("visit ExprVar " + var); if (!convertable) { expression.push(Expression.FALSE); // prevent stack empty exceptions when conversion return; // fails in the middle of a multi-arg operator conversion } String varName = var.getVarName(); // if expression contains a blank node, no conversion to sql can be done if (Var.isBlankNodeVarName(varName)) { conversionFailed("blank nodes not supported", var); return; } List<Expression> expressions = toExpression(var); if (expressions.size() == 1) { expression.push(expressions.get(0)); } else { // no single sql-column for sparql-var does exist break up conversion // (the case for Pattern ValueMakers) conversionFailed("multi column pattern valuemakers not supported", var); } } public void visit(NodeValue value) { logger.debug("visit NodeValue " + value); if (!convertable) { expression.push(Expression.FALSE); // pr