Fix for #45

SmartDataAnalytics · May 3, 2014 · 34f40bf · 34f40bf
1 parent ef0763e
commit 34f40bf
Show file tree

Hide file tree

Showing 3 changed files with 106 additions and 23 deletions.
diff --git a/sparqlify-core/src/main/java/org/aksw/sparqlify/algebra/sql/nodes/SqlOpSelectBlock.java b/sparqlify-core/src/main/java/org/aksw/sparqlify/algebra/sql/nodes/SqlOpSelectBlock.java
@@ -2,8 +2,10 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
 
 import org.aksw.sparqlify.algebra.sql.exprs2.SqlExpr;
+import org.aksw.sparqlify.algebra.sql.exprs2.SqlExprFunction;
 import org.apache.jena.atlas.io.IndentedWriter;
 
 import com.hp.hpl.jena.sdb.core.Generator;
@@ -456,6 +458,49 @@ public void write(IndentedWriter writer) {
 	}
 
 
+
+	/**
+	 * Checks whether a projection contains a COUNT function
+	 * 
+	 * TODO HACK Just checking function names for string containment is not the proper way to do this
+	 * 
+	 * @param projection
+	 * @return
+	 */
+	public static boolean containsCount(Projection projection) {
+        boolean result = false;
+
+        Map<String, SqlExpr> nameToExpr = projection.getNameToExpr();
+
+        for(String name : projection.getNames()) {
+            SqlExpr expr = nameToExpr.get(name);
+            //System.out.println(expr);
+            if(expr.isFunction()) {
+                SqlExprFunction fn = expr.asFunction();
+                String fnName = fn.getName();
+                if(fnName.contains("Count")) {
+                    result = true;
+                    break;
+                }
+            }
+        }
+
+        return result;
+	}
 
+	@Override
+	public boolean isEmpty() {
+	    boolean result = super.isEmpty();
+
+	    // Check if the query is a count query without grouping, because then its not empty after all
+	    int argCount = projection.getNames().size();
+	    if(argCount == 1 && groupByExprs.isEmpty()) {
+	        boolean hasCount = containsCount(projection);
+
+	        result = !hasCount;
+	    }
+
+        return result;
+	}
 
 }
diff --git a/sparqlify-core/src/main/java/org/aksw/sparqlify/core/algorithms/MappingOpsImpl.java b/sparqlify-core/src/main/java/org/aksw/sparqlify/core/algorithms/MappingOpsImpl.java
@@ -1050,41 +1050,75 @@ public Mapping joinCommon(Mapping a, Mapping initB, boolean isLeftJoin) {
 
 		// Add common definitions
 		Set<SqlExpr> joinCondition = new HashSet<SqlExpr>();
+
+		//Multimap<Var, RestrictedExpr> newVarDef = HashMultimap.create();
 
+		boolean isJoinConditionSatisfiable = true;
 		for(Var commonVar : commonVars) {
 			Collection<RestrictedExpr> defsA = a.getVarDefinition().getDefinitions(commonVar);
 			Collection<RestrictedExpr> defsB = b.getVarDefinition().getDefinitions(commonVar);
 
 			VarDefKey ors = joinDefinitionsOnEquals(defsA, defsB, typeMap, sqlTranslator);
 
+            if(isLeftJoin) {
+                newVarDef.putAll(commonVar, defsA);
+            }               
+
+
 			if(ors == null) {
-				opResult = SqlOpEmpty.create(opJoin.getSchema());
-				break;
+			    // // Bail out on unsatisfiable join condition
+			    isJoinConditionSatisfiable = false;
+
+	            if(!isLeftJoin) {
+	                newVarDef.put(commonVar, new RestrictedExpr(NodeValue.nvNothing));
+	            }			     
+			}
+			else {
+			    if(!isLeftJoin) {
+			        newVarDef.putAll(commonVar, ors.definitionExprs);
+			    }
 			}
-			newVarDef.putAll(commonVar, ors.definitionExprs);
-
-			SqlExpr or = SqlExprUtils.orifyBalanced(ors.constraintExpr);
-			if(or == null || or.equals(S_Constant.TRUE)) {
-				continue;
-			} 			
 
-
-			//joinCondition.addAll(ors.constraintExpr);
-			joinCondition.add(or);
+			if(isJoinConditionSatisfiable) {
+			    // Stop collecting join conditions if they are unsatisfiable anyway
+
+			    // Don't bother adding TRUE conditions
+	            SqlExpr or = SqlExprUtils.orifyBalanced(ors.constraintExpr);
+	            if(or == null || or.equals(S_Constant.TRUE)) {
+	                continue;
+	            }           
+
+	            //joinCondition.addAll(ors.constraintExpr);
+	            joinCondition.add(or);
+			}			
 		}
 
-		SqlOp resultSqlOp;
-		List<SqlExpr> jc = new ArrayList<SqlExpr>(joinCondition);
-
-		if(joinType.equals(JoinType.LEFT)) {
-			opJoin.getConditions().addAll(jc);
-			resultSqlOp = opResult;
-		} else {
-
-			//ExprList jc = new ExprList(new ArrayList<Expr>(joinCondition));
-			resultSqlOp = SqlOpFilter.create(opResult, jc);
-		}		
+	    SqlOp resultSqlOp;
+
+		if(!isJoinConditionSatisfiable) {
+		    //newVarDef.clear();
+
+            if(isLeftJoin) {
+                resultSqlOp = a.getSqlOp();
+            }
+            else {              
+                resultSqlOp = SqlOpEmpty.create(opJoin.getSchema());
+            }		    
+		}
+		else {
 
+    		List<SqlExpr> jc = new ArrayList<SqlExpr>(joinCondition);
+
+    		if(joinType.equals(JoinType.LEFT)) {
+    			opJoin.getConditions().addAll(jc);
+    			resultSqlOp = opResult;
+    		} else {
+
+    			//ExprList jc = new ExprList(new ArrayList<Expr>(joinCondition));
+    			resultSqlOp = SqlOpFilter.create(opResult, jc);
+    		}		
+		}
+
 		VarDefinition newVarDefinition = new VarDefinition(newVarDef);
 
 

diff --git a/sparqlify-core/src/main/java/org/aksw/sparqlify/core/interfaces/SparqlSqlOpRewriterImpl.java b/sparqlify-core/src/main/java/org/aksw/sparqlify/core/interfaces/SparqlSqlOpRewriterImpl.java
@@ -8,6 +8,7 @@
 import org.aksw.sparqlify.core.algorithms.SqlOptimizerImpl;
 import org.aksw.sparqlify.core.domain.input.Mapping;
 import org.aksw.sparqlify.core.domain.input.SparqlSqlOpRewrite;
+import org.aksw.sparqlify.core.domain.input.VarDefinition;
 import org.apache.commons.lang.time.StopWatch;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -136,7 +137,10 @@ public SparqlSqlOpRewrite rewrite(Query query) {
 		}
 		*/		
 
-		SparqlSqlOpRewrite result = new SparqlSqlOpRewrite(sqlOp, mapping.isEmpty(), mapping.getVarDefinition(), projectionOrder);
+		//boolean isEmpty = mapping.isEmpty();
+		boolean isEmpty = sqlOp.isEmpty();
+		VarDefinition varDefinition = mapping.getVarDefinition();
+		SparqlSqlOpRewrite result = new SparqlSqlOpRewrite(sqlOp, isEmpty, varDefinition, projectionOrder);
 
 		return result;
 	}