Team3 regex Disjunctive Normal Form

textdb/textdb-dataflow/src/main/java/edu/uci/ics/textdb/dataflow/regexmatch/GramBooleanQuery.java

@@ -2,6 +2,7 @@
 
 import java.util.ArrayList;
 import java.util.HashSet;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Set;
 import java.util.StringJoiner;
@@ -293,6 +294,148 @@ private static String toLuceneQueryString(GramBooleanQuery query) {
 			}
 		}
 	}
+
+	public boolean isEmpty() {
+		if (this.operandSet.size() > 0) {
+			return false;
+		}
+		for (GramBooleanQuery subQuery : this.subQuerySet) {
+			if (! subQuery.isEmpty()) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	// "AND" two DNF trees (trees are assumed to be in DNF form)
+	// Apply distributive laws:
+	// a AND (b OR c) = (a AND b) OR (a AND c)
+	// (a OR b) AND (c OR d) = (a AND c) OR (a AND d) OR (b AND c) OR (c AND d)
+	private static GramBooleanQuery andDNF(GramBooleanQuery left, GramBooleanQuery right) {
+		if (left.isEmpty()) {
+			return right;
+		}
+		if (right.isEmpty()) {
+			return left;
+		}
+		GramBooleanQuery resultQuery = new GramBooleanQuery(QueryOp.OR);
+		for (String leftOperand : left.operandSet) {
+			for (String rightOperand : right.operandSet) {
+				GramBooleanQuery tempQuery = new GramBooleanQuery(QueryOp.AND);
+				tempQuery.operandSet.add(leftOperand);
+				tempQuery.operandSet.add(rightOperand);
+				resultQuery.subQuerySet.add(tempQuery);
+			}
+			for (GramBooleanQuery rightSubQuery : right.subQuerySet) {
+				GramBooleanQuery tempQuery = new GramBooleanQuery(QueryOp.AND);
+				tempQuery.operandSet.add(leftOperand);
+				tempQuery.operandSet.addAll(rightSubQuery.operandSet);
+				resultQuery.subQuerySet.add(tempQuery);
+			}
+		}
+		for (GramBooleanQuery leftSubQuery : left.subQuerySet) {
+			for (String rightOperand : right.operandSet) {
+				GramBooleanQuery tempQuery = new GramBooleanQuery(QueryOp.AND);
+				tempQuery.operandSet.addAll(leftSubQuery.operandSet);
+				tempQuery.operandSet.add(rightOperand);
+				resultQuery.subQuerySet.add(tempQuery);
+			}
+			for (GramBooleanQuery rightSubQuery : right.subQuerySet) {
+				GramBooleanQuery tempQuery = new GramBooleanQuery(QueryOp.AND);
+				tempQuery.operandSet.addAll(leftSubQuery.operandSet);
+				tempQuery.operandSet.addAll(rightSubQuery.operandSet);
+				resultQuery.subQuerySet.add(tempQuery);
+			}
+		}
+		return resultQuery;
+	}
+
+
+	/**
+	 * simplify a tree, which is assumed to be already in DNF form
+	 * Apply Absorption laws: a OR (a AND b) = a
+	 * 
+	 * Simplifying is important because it enables comparison between two trees.
+	 * Two equivalent trees could have different forms. However, after transforming to DNF
+	 * and applying simplifications, their forms should be identical.
+	 * 
+	 * @param DNFQuery
+	 * @return simplifiedDNFQuery
+	 */
+	public static GramBooleanQuery simplifyDNF(GramBooleanQuery query) {
+		GramBooleanQuery result = new GramBooleanQuery(QueryOp.OR);
+		result.operandSet.addAll(query.operandSet);
+
+		Iterator<GramBooleanQuery> outerIterator = query.subQuerySet.iterator();
+		OuterLoop:
+		while (outerIterator.hasNext()) {
+			GramBooleanQuery outerAndQuery = outerIterator.next();
+			for (String operand : query.operandSet) {
+				if (outerAndQuery.operandSet.contains(operand)) {
+					continue OuterLoop;
+				}
+			}
+			Iterator<GramBooleanQuery> innerIterator = query.subQuerySet.iterator();
+			while (innerIterator.hasNext()) {
+				GramBooleanQuery innerAndQuery = innerIterator.next();
+				if (outerAndQuery != innerAndQuery) {
+					if (outerAndQuery.operandSet.containsAll(innerAndQuery.operandSet)) {
+						outerIterator.remove();
+						continue OuterLoop;
+					}				
+				}
+			}
+			// if reach this code, then add a copy of it to result
+			GramBooleanQuery tempQuery = new GramBooleanQuery(QueryOp.AND);
+			tempQuery.operandSet.addAll(outerAndQuery.operandSet);
+			result.subQuerySet.add(tempQuery);
+		}
+
+		return query;
+	}
+
 
+	/**
+	 * The query tree generated by the translator is messy with possibly lots of redundant information.
+	 * This function transforms it into Disjunctive normal form (DNF), which is an OR of different ANDs.
+	 * 
+	 * For example, the original query of regex "abc?pqr?" is: 
+	 *  (((bpq AND abp) OR (abc AND cpq AND bcp)) AND (bpq OR cpq) AND (bpq OR cpq OR (pqr AND cpq) OR (pqr AND bpq)) AND (pqr OR bpq OR cpq) AND (abc OR abp))
+	 *  which is long and messey. After calling toDNF() and simplifyDNF(), the result query is:
+	 *  ((abp AND bpq) OR (abc AND bcp AND cpq))
+	 *  
+	 * @param query
+	 * @return DNFQuery
+	 */
+	public static GramBooleanQuery toDNF(GramBooleanQuery query) {
+		if (query.operator == QueryOp.AND) {
+			GramBooleanQuery firstOrNode = new GramBooleanQuery(QueryOp.OR);
+			if (query.operandSet.size() != 0) {
+				GramBooleanQuery firstAndNode = new GramBooleanQuery(QueryOp.AND);
+				firstAndNode.operandSet.addAll(query.operandSet);
+				firstOrNode.subQuerySet.add(firstAndNode);
+			}
+
+			ArrayList<GramBooleanQuery> subDNFList = new ArrayList<>();
+			for (GramBooleanQuery subQuery : query.subQuerySet) {
+				subDNFList.add(toDNF(subQuery));
+			}
+
+			GramBooleanQuery result = subDNFList.stream().reduce(firstOrNode, (left, right) -> andDNF(left, right));
+			return result;
+		} else if (query.operator == QueryOp.OR) {
+			GramBooleanQuery result = new GramBooleanQuery(QueryOp.OR);
+			result.operandSet.addAll(query.operandSet);
+			for (GramBooleanQuery subQuery : query.subQuerySet) {
+				GramBooleanQuery newSubQuery = toDNF(subQuery);
+				result.subQuerySet.addAll(newSubQuery.subQuerySet);
+				result.operandSet.addAll(newSubQuery.operandSet);
+			}
+			return result;
+		}
+
+		// ANY or NONE, no need to simplify
+		return query;
+	}
 
 }