/**
* @param queryEdge
* @param graphEdge
* @param r
* @return
*/
protected boolean edgeMatch(Edge queryEdge, Edge graphEdge, IsomorphicQuery r) {
if (queryEdge.getLabel() != 0L && queryEdge.getLabel() != graphEdge.getLabel().longValue()) {
return false;
}
Long querySource = null;
Long queryDestination = null;
Long graphSource = null;
Long graphDestination = null;
if (r != null) {
if (r.isUsing(graphEdge)) {
return false;
}
querySource = queryEdge.getSource();
graphSource = graphEdge.getSource();
boolean mappedSource = r.hasMapped(querySource);
boolean usingSource = r.isUsing(graphSource);
if (usingSource && !mappedSource) {
return false;
}
queryDestination = queryEdge.getDestination();
graphDestination = graphEdge.getDestination();
boolean mappedDestination = r.hasMapped(queryDestination);
boolean usingDestination = r.isUsing(graphDestination);
if (usingDestination && !mappedDestination) {
return false;
}
if (mappedSource && !graphSource.equals(r.isomorphicMapOf(querySource).getNodeID())) {
return false;
}
if (mappedDestination
&& !graphDestination.equals(r.isomorphicMapOf(queryDestination).getNodeID())) {
return false;
}
if (usingSource && !r.mappedAs(graphSource).equals(querySource)) {
return false;
}
if (usingDestination && !r.mappedAs(graphDestination).equals(queryDestination)) {
return false;
}
}
return true;
}
/**
* Given a query, a starting node from the query, and a node from the knowledgeBase , tries to
* build up a related query
*
* @param query
* @param queryNode
* @param graphNode
* @return
*/
public List<IsomorphicQuery> createQueries(
Multigraph query, Long queryNode, MappedNode graphNode, IsomorphicQuery relatedQuery) {
// Initialize the queries set
// Given the current situation we expect to build more than one possible related query
List<IsomorphicQuery> relatedQueries = new ArrayList<>();
relatedQueries.add(relatedQuery);
// The graphEdges exiting from the query node passed
Collection<Edge> queryEdgesOut = query.outgoingEdgesOf(queryNode);
// The graphEdges entering the query node passed
Collection<Edge> queryEdgesIn = query.incomingEdgesOf(queryNode);
// The graphEdges in the KB exiting from the mapped node passed
Collection<Edge> graphEdgesOut = graph.outgoingEdgesOf(graphNode.getNodeID());
// The graphEdges in the KB entering the mapped node passed
Collection<Edge> graphEdgesIn = graph.incomingEdgesOf(graphNode.getNodeID());
// System.out.println(graphNode.getNodeID() + " " + (graphEdgesOut.size() +
// graphEdgesIn.size()));
// Null handling
queryEdgesIn = queryEdgesIn == null ? new HashSet<Edge>() : queryEdgesIn;
queryEdgesOut = queryEdgesOut == null ? new HashSet<Edge>() : queryEdgesOut;
graphEdgesIn = graphEdgesIn == null ? new HashSet<Edge>() : graphEdgesIn;
graphEdgesOut = graphEdgesOut == null ? new HashSet<Edge>() : graphEdgesOut;
// debug("TEst %d map to %d", queryNode, graphNode);
// Optimization: if the queryEdges are more than the kbEdges, we are done, not isomorphic!
if (queryEdgesIn.size() > graphEdgesIn.size() || queryEdgesOut.size() > graphEdgesOut.size()) {
return null;
}
// All non mapped graphEdges from the query are put in one set
Set<Edge> queryEdges = new HashSet<>();
for (Edge edgeOut : queryEdgesOut) {
if (!relatedQuery.hasMapped(edgeOut)) {
queryEdges.add(edgeOut);
}
}
for (Edge edgeIn : queryEdgesIn) {
if (!relatedQuery.hasMapped(edgeIn)) {
queryEdges.add(edgeIn);
}
}
queryEdgesIn = null;
queryEdgesOut = null;
List<Edge> sortedEdges = sortEdge(queryEdges, this.labelFreq);
// Look if we can map all the outgoing/ingoing graphEdges of the query node
for (Edge queryEdge : sortedEdges) {
// System.out.println("Processs answer number: " + relatedQueries.size());
if (relatedQueries.size() > MAX_RELATED) return relatedQueries;
// System.out.println(queryEdge);
// info("Trying to map the edge " + queryEdge);
List<IsomorphicQuery> newRelatedQueries = new ArrayList<>();
LinkedList<IsomorphicQuery> toTestRelatedQueries = new LinkedList<>();
for (IsomorphicQuery current : relatedQueries) {
if (current.hasMapped(queryEdge)) {
newRelatedQueries.add(current);
} else {
toTestRelatedQueries.add(current);
}
}
relatedQueries.clear();
IsomorphicQuerySearch.interNum =
Math.max(toTestRelatedQueries.size(), IsomorphicQuerySearch.interNum);
// reset, we do not want too many duplicates
relatedQueries = new LinkedList<>();
// If all candidated have this QueryEdge mapped, go to next
if (toTestRelatedQueries.isEmpty()) {
relatedQueries = newRelatedQueries;
continue;
}
// The label we are looking for
Long label = queryEdge.getLabel();
// is it isIncoming or outgoing ?
boolean isIncoming = queryEdge.getDestination().equals(queryNode);
List<Edge> graphEdges;
// Look for graphEdges with the same label and same direction as the one from the query
if (isIncoming) {
graphEdges = findEdges(label, graphEdgesIn);
} else {
graphEdges = findEdges(label, graphEdgesOut);
}
// loggable.debug("Matching with %d graphEdges", graphEdges.size() );
// Do we found any?
if (graphEdges.isEmpty()) {
// If we cannot map graphEdges, this path is wrong
return null;
} else {
// Cycle through all the possible graphEdges options,
// they would be possibly different related queries
for (Edge graphEdge : graphEdges) {
// Cycle through all the possible related queries retrieved up to now
// A new related query is good if it finds a match
for (IsomorphicQuery tempRelatedQuery : toTestRelatedQueries) {
if (newRelatedQueries.size() > MAX_RELATED
|| watch.getElapsedTimeMillis() > QUIT_TIME) {
// System.out.println("Time limit exceeded or more than 10000
// partial results");
this.isQuit = true;
return relatedQueries.size() > 0 ? relatedQueries : null;
}
if (tempRelatedQuery.isUsing(graphEdge)) {
// Ok this option is already using this edge,
// not a good choice go away
// it means that this query didn't found his match in this edge
continue;
}
Utilities.searchCount++;
// Otherwise this edge can be mapped to the query edge if all goes well
IsomorphicQuery newRelatedQuery = tempRelatedQuery.getClone();
// check nodes similarity
// double nodeSimilarity = 0;
// if (isIncoming) {
// nodeSimilarity = RelatedQuerySearch.conceptSimilarity(queryEdge.getSource(),
// graphEdge.getSource());
// } else {
// nodeSimilarity = RelatedQuerySearch.conceptSimilarity(queryEdge.getDestination(),
// graphEdge.getDestination());
// }
// If the found edge peudo-destination is similar to the query edge pseudo-destination
// if (nodeSimilarity > RelatedQuerySearch.MIN_SIMILARITY) {
// The destination if outgoing the source if isIncoming
Long queryNextNode;
MappedNode graphNextNode;
if (isIncoming) {
queryNextNode = queryEdge.getSource();
// graphNextNode = graphEdge.getSource();
graphNextNode =
new MappedNode(graphEdge.getSource(), graphEdge, 0, isIncoming, false);
} else {
queryNextNode = queryEdge.getDestination();
// graphNextNode = graphEdge.getDestination();
graphNextNode =
new MappedNode(graphEdge.getDestination(), graphEdge, 0, isIncoming, false);
}
// Is this node coeherent with the structure?
if (edgeMatch(queryEdge, graphEdge, newRelatedQuery)) {
// That's a good edge!! Add it to this related query
newRelatedQuery.map(queryEdge, graphEdge);
// Map also the node
newRelatedQuery.map(queryNextNode, graphNextNode);
// The query node that we are going to map
// Does it have graphEdges that we don't have mapped?
boolean needExpansion = false;
Collection<Edge> pseudoOutgoingEdges = query.incomingEdgesOf(queryNextNode);
Long queryPrevNode = null;
if (pseudoOutgoingEdges.size() > 0) {
for (Edge pseudoEdge : pseudoOutgoingEdges) {
needExpansion =
!newRelatedQuery.hasMapped(pseudoEdge) && !pseudoEdge.equals(queryEdge);
queryPrevNode =
pseudoEdge.getDestination().equals(queryNextNode)
? pseudoEdge.getSource()
: pseudoEdge.getDestination();
needExpansion = needExpansion && !queryPrevNode.equals(queryNode);
if (needExpansion) {
break;
}
}
}
pseudoOutgoingEdges = query.outgoingEdgesOf(queryNextNode);
if (!needExpansion && pseudoOutgoingEdges.size() > 0) {
for (Edge pseudoEdge : pseudoOutgoingEdges) {
needExpansion =
!newRelatedQuery.hasMapped(pseudoEdge) && !pseudoEdge.equals(queryEdge);
queryPrevNode =
pseudoEdge.getDestination().equals(queryNextNode)
? pseudoEdge.getSource()
: pseudoEdge.getDestination();
needExpansion = needExpansion && !queryPrevNode.equals(queryNode);
if (needExpansion) {
break;
}
}
}
// Lookout! We need to check the outgoing part, if we did not already
if (needExpansion) {
// Possible outgoing branches
List<IsomorphicQuery> tmpRelatedQueries;
// Go find them!
// log("Go find mapping for: " + queryNextNode + " // " + graphNextNode);
tmpRelatedQueries =
createQueries(query, queryNextNode, graphNextNode, newRelatedQuery);
// Did we find any?
if (tmpRelatedQueries != null) {
// Ok so we found some, they are all good to me
// More possible related queries
// They already contain the root
for (IsomorphicQuery branch : tmpRelatedQueries) {
// All these related queries have found in this edge their match
newRelatedQueries.add(branch);
}
}
// else {
// This query didn't find in this edge its match
// continue;
// }
} else {
// log("Complete query " + relatedQuery);
// this related query has found in this edge is map
// newRelatedQuery.map(queryNextNode, graphNextNode);
newRelatedQueries.add(newRelatedQuery);
}
}
// else {
// info("Edge does not match %s - for %s : %d", graphEdge.getId(),
// FreebaseConstants.convertLongToMid(graphNode), graphNode);
// }
}
}
}
// after this cycle we should have found some, how do we check?
if (newRelatedQueries.isEmpty()) {
return null;
} else {
// basically in the *new* list are the related queries still valid and growing
relatedQueries = newRelatedQueries;
}
}
return relatedQueries.size() > 0 ? relatedQueries : null;
}