rule.java

这是外国一个开源推理机

			if (ifFirst) {
				buffer.append(" AND ");
			}
			buffer.append("t" + i + ".subj is not NULL");
			ifFirst = true;
		}
		if (ifFirst) {
			buffer.append(" AND ");
		}
		buffer.append("t" + premiseList.size() + ".subj is NULL");

		return buffer.toString();
	}

	//  10. 	xxx rdf:type rdfs:ContainerMembershipProperty      -->  (dep1)
	//    xxx rdfs:subPropertyOf rdfs:member			(t)
	/**
	 *   Algorithm outline:
	 * 0. add insert into clause+join of t with the first template (dep1)
	 * 1. fill all constant restrictions on t component (the inferred statement)
	 * 2. add each match with dep1 components to the join
	 * 3. add next template restriction (dep2) from the remaining list
	 * 4. fiil its contsnt restrictions and add any matches with the t or dep1
	 * 5. add WHERE clause
	 */
	private boolean appendConstaints(StringBuffer buffer, TripleTemplate t,
			boolean bFirst, String tablePrefix)
	{
		if (!t.subject.isVar()) {
			if (bFirst) {
				buffer.append(" AND ");
			}
			buffer.append(tablePrefix);
			buffer.append(".subj = ");
			buffer.append(getId(t.subject));
			bFirst = true;
		}
		if (!t.predicate.isVar()) {
			if (bFirst) {
				buffer.append(" AND ");
			}	
			buffer.append(tablePrefix);
			buffer.append(".pred = ");
			buffer.append(getId(t.predicate));
			bFirst = true;
		}
		if (!t.object.isVar()) {
			if (bFirst) {
				buffer.append(" AND ");
			}
			buffer.append(tablePrefix);
			buffer.append(".obj = ");
			buffer.append(getId(t.object));
			bFirst = true;
		}
		return bFirst;
	}

	private String matchVarComponent(Component var, TripleTemplate t) {
		if (var.compareTo(t.subject) == 0) {
			return ".subj";
		}
		if (var.compareTo(t.predicate) == 0) {
			return ".pred";
		}
		if (var.compareTo(t.object) == 0) {
			return ".obj";
		}
		return null;
	}

	private boolean matchAgainst(StringBuffer buffer, boolean bFirst,
			TripleTemplate from, String fromPrefix, TripleTemplate to, String toPrefix)
	{
		if (bFirst) {
			buffer.append(" AND ");
		}

		buffer.append(fromPrefix);
		buffer.append(".id <> ");
		buffer.append(toPrefix);
		buffer.append(".id ");
		bFirst = true;

		String foundMatch = null;
		foundMatch = matchVarComponent(from.subject, to);
		if (foundMatch != null) {
			if (bFirst) {
				buffer.append(" AND ");
			}
			buffer.append(fromPrefix);
			buffer.append(".subj = ");
			buffer.append(toPrefix);
			buffer.append(foundMatch);
			foundMatch = null;
			bFirst = true;
		}
		foundMatch = matchVarComponent(from.predicate, to);
		if (foundMatch != null) {
			if (bFirst) {
				buffer.append(" AND ");
			}
			buffer.append(fromPrefix);
			buffer.append(".pred = ");
			buffer.append(toPrefix);
			buffer.append(foundMatch);
			foundMatch = null;
			bFirst = true;
		}
		foundMatch = matchVarComponent(from.object, to);
		if (foundMatch != null) {
			if (bFirst) {
				buffer.append(" AND ");
			}
			buffer.append(fromPrefix);
			buffer.append(".obj = ");
			buffer.append(toPrefix);
			buffer.append(foundMatch);
			foundMatch = null;
			bFirst = true;
		}
		return bFirst;
	}

	public ArrayList getDependSQL() {
		alreadyJoined = null;
		StringBuffer bufferPrefix = new StringBuffer();
		bufferPrefix.append("insert into ");
		bufferPrefix.append(DEPEND_TABLE);
		bufferPrefix.append("\n\r SELECT t.id ");

		for (int i = 1; i <= CustomInferenceServices.getMaxTemplateCountsPerRule(); i++) {
			if (i <= premiseList.size()) {
				bufferPrefix.append(", dep" + (i) + ".id ");
			}
			else {
				bufferPrefix.append(", 0");
			}
		}
		bufferPrefix.append(" FROM ");

		StringBuffer bufferMidSuffix = new StringBuffer();
		StringBuffer bufferSuffix = new StringBuffer();
		bufferSuffix.append(" WHERE ");
		boolean bFirst = false;
		bFirst = appendConstaints(bufferSuffix, consequent, bFirst, "t");
		for (int i = 0; i < premiseList.size(); i++) {
			TripleTemplate tr = (TripleTemplate)premiseList.get(i);
			bFirst = appendConstaints(bufferSuffix, tr, bFirst, "dep" + (i + 1));
			bFirst = matchAgainst(bufferSuffix, bFirst, consequent, "t", tr, "dep" + (i + 1));
			for (int j = 0; j < i; j++) {
				bFirst = matchAgainst(bufferSuffix, bFirst, tr, "dep" + (i + 1),
						(TripleTemplate)premiseList.get(j), "dep" + (j + 1));
			}
			processjoinWithRegExpr(bufferMidSuffix, tr.subject, "dep" + (i + 1), "subj");
			processjoinWithRegExpr(bufferMidSuffix, tr.predicate, "dep" + (i + 1), "pred");
			processjoinWithRegExpr(bufferMidSuffix, tr.object, "dep" + (i + 1), "obj");
		}
		
		ArrayList ret = new ArrayList();
		for (int i = 0; i < premiseList.size(); i++) {
			String middle = "";
			for (int j = 0; j < premiseList.size(); j++) {
				if (i == j) {
					middle += ALL_NEW_TRIPLES_TABLE + " dep" + (j + 1) + ",";
				}
				else {
					middle += TRIPLES_TABLE + " dep" + (j + 1) + ",";
				}
			}
			middle += TRIPLES_TABLE + " t ";
			ret.add(bufferPrefix.toString() + middle + bufferMidSuffix + bufferSuffix.toString());
		}
		return ret;
	}

	public void initTriggersRuleCollection() {
		triggersRule = new ArrayList();
	}

	public void triggersRule(String ruleRef) {
		triggersRule.add(ruleRef);
	}

	public boolean hasTriggersRuleCollection() {
		return triggersRule != null;
	}

	public String getName() {
		return ruleName;
	}

	protected String escapeRegExpression(String expression, String esc) {
		if (esc == null) {
			esc = "\\";
		}
		if (0 == esc.compareTo("\\")) {
			esc = esc + esc;
		}
		expression = expression.replaceAll("[',_,%," + esc + "]", esc + "$0");
		expression = expression.replaceAll("([^" + esc + "])([?])", "$1_");
		return expression.replaceAll("([^" + esc + "])([\\*])", "$1%");
	}

	HashMap alreadyJoined;

	protected void processjoinWithRegExpr(StringBuffer buffer,
			Component component, String tableID, String sub_ob_pred)
	{
		//@todo chek if it is joined already
		if (regExpByVars == null) {
			return;
		}
		if (alreadyJoined == null) {
			alreadyJoined = new HashMap();
		}
		component = (Component)regExpByVars.get(component.value());
		if (component == null) {
			return;
		}
		if (component.isRegExp() && null == alreadyJoined.get(component)) {
			String varName = component.value();
			Component regExpr = (Component)regExpByVars.get(varName);
			if (regExpr != null) {
				// inner join resources (r+id) on (r+id).id == (t+id).subject
				// inner join namespaces (n+id) on (r+id).namespace == (n+id).id
				// AND concat((n+id).name, (r+id).localname) like
				buffer.append(" inner join ");
				buffer.append(RESOURCES_TABLE);
				buffer.append(" r" + varName);
				buffer.append(" on r" + varName);
				buffer.append(".id = " + tableID);
				buffer.append("." + sub_ob_pred);

				buffer.append(" inner join ");
				buffer.append(NAMESPACES_TABLE);
				buffer.append(" n" + varName);
				buffer.append(" on r" + varName);
				buffer.append(".namespace = n" + varName + ".id AND ");

				buffer.append("concat( n" + varName + ".name, ");
				buffer.append(" r" + varName + ".localname ) LIKE '");
				// 1 . add escChar ahead of all ',%,_
				// 2 . replace all ?,* with (not preceeded by esc) with _,%
				// 3 . move all exc before ?,*
				String esc = regExpr.getRegExpEsc();
				if (esc == null) {
					esc = "\\";
				}
				String likeText = escapeRegExpression(regExpr.getRegExpTemplate(), esc);
				buffer.append(likeText);
				buffer.append("' ESCAPE '" + esc + esc + "' ");
			}
			// mark that it is already joined
			alreadyJoined.put(component, "");
		}
	}

	public int getPremiseCount() {
		return premiseList.size();
	}

	public TripleTemplate getConsequent() {
		return consequent;
	}

	public ArrayList getPremiseCollection() {
		return premiseList;
	}

	public ArrayList getTriggersRule() {
		return triggersRule;
	}

	public static void main(String op[]) {
		/*    String val = "http://www.w3.org/1999/02/22-rdf-syn\\tax-ns#_t%*yp?'e";
		 String esc = "\\";
		 if (0==esc.compareTo("\\"))
		 esc = esc+esc;
		 String valOne = val.replaceAll("[',_,%,"+esc+"]", esc+"$0");
		 String valTwo = valOne.replaceAll("([^"+esc+"])([?])", "$1_");
		 String valTre = valTwo.replaceAll("([^"+esc+"])([\\*])", "$1%");
		 System.out.println(val);
		 System.out.println(valOne);
		 System.out.println(valTwo);
		 System.out.println(valTre);
		 */
		Rule rule = new Rule("test");

		Component subjectComp = new Component("xxx", Component.VAR);
		Component predicateComp = new Component("id", Component.REGEXP);
		predicateComp.setRegExpTemplate("http://www.w3.org/1999/02/22-rdf-syntax-ns#_*", "\\");
		Component objectComp = new Component("yyy", Component.VAR);
		TripleTemplate t = new TripleTemplate(subjectComp, predicateComp, objectComp);
		/*    t.subject = new Component("xxx", Component.VAR);
		 t.predicate = new Component("prop", Component.VAR);
		 t.object = new Component("yyy", Component.VAR);
		 rule.addPremise(t);
		 t = new TripleTemplate();
		 t.subject = new Component("yyy", Component.VAR);
		 t.predicate = new Component("prop", Component.VAR);
		 t.object = new Component("zzz", Component.VAR);
		 */
		rule.addPremise(t);

		subjectComp = new Component("id", Component.VAR);
		predicateComp = new Component("http://www.w3.org/1999/02/22-rdf-syntax-ns#type", Component.URI);
		objectComp = new Component("http://www.w3.org/2000/01/rdf-schema#ContainerMembershipProperty", Component.URI);
		t = new TripleTemplate(subjectComp, predicateComp, objectComp);
		/*    t.subject = new Component("xxx", Component.VAR);
		 t.predicate = new Component("prop", Component.REGEXP);
		 t.predicate.setRegExpTemplate("http://www.w3.org/2000/01/rdf-schema#sub*","\\");
		 t.object = new Component("zzz", Component.VAR);
		 */
		rule.setConsequent(t);

		ArrayList list = rule.getAllSQLs();
		//    ArrayList list = rule.getDependSQL();
		Iterator iter = list.iterator();
		while (iter.hasNext()) {
			System.out.println(iter.next());
		}
	}
}