/** * @return the number of records which had at least one diff for this field. */ public int getNumDiffs() { return diffToOrdinals.size(); }
public void prepareMultiply() { if(childFirstFieldMap.length > 0) this.currentMultiplyFieldMatchListPosition = fieldMatches[childFirstFieldMap[0]].size(); }
public int getNumMatches() { return fieldMatchLists[0].size(); }
boolean nextSpecialCharacter() { return ++specialCharacterIteratorPos < specialCharacterOffsets.size(); }
@Override public int traverseMissingFields(IntList fromOrdinals, IntList toOrdinals) { if(fromFieldIndex == -1) { fieldDiff.addDiff(currentTopLevelFromOrdinal, currentTopLevelToOrdinal, toOrdinals.size()); return toOrdinals.size(); } if(toFieldIndex == -1) { fieldDiff.addDiff(currentTopLevelFromOrdinal, currentTopLevelToOrdinal, fromOrdinals.size()); return fromOrdinals.size(); } return 0; }
public void putEqualOrdinals(int fromOrdinal, IntList toOrdinals) { long fromOrdinalMapEntry = (long)toOrdinals.get(0) << 32 | fromOrdinal; if(toOrdinals.size() > 1) { fromOrdinalMapEntry = Long.MIN_VALUE | (long)pivotedToOrdinalClusters.size() << 32 | fromOrdinal; for(int i=0;i<toOrdinals.size();i++) { int valueToAdd = toOrdinals.get(i); if(i == toOrdinals.size() - 1) valueToAdd |= Integer.MIN_VALUE; pivotedToOrdinalClusters.add(valueToAdd); } } int hashCode = HashCodes.hashInt(fromOrdinal); int bucket = hashCode & (fromOrdinalsMap.length - 1); while(fromOrdinalsMap[bucket] != -1) bucket = (bucket + 1) & (fromOrdinalsMap.length - 1); fromOrdinalsMap[bucket] = fromOrdinalMapEntry; }
private Map<String, IntList> typeQueryKeyMatches(HollowHistory history, String query) { Map<String, IntList> typeQueryKeyMatches = new HashMap<String, IntList>(); for(Map.Entry<String, HollowHistoryTypeKeyIndex> entry : history.getKeyIndex().getTypeKeyIndexes().entrySet()) { IntList typeQueryResult = entry.getValue().queryIndexedFields(query); if(typeQueryResult.size() != 0) typeQueryKeyMatches.put(entry.getKey(), typeQueryResult); } return typeQueryKeyMatches; }
@Override public int traverseDiffs(IntList fromOrdinals, IntList toOrdinals) { fillTraversalLists(fromOrdinals, toOrdinals); referenceFilter.filter(traversalFromOrdinals, traversalToOrdinals); int score = 0; if(referenceFilter.getUnmatchedFromOrdinals().size() != 0 || referenceFilter.getUnmatchedToOrdinals().size() != 0) score += elementNode.traverseDiffs(referenceFilter.getUnmatchedFromOrdinals(), referenceFilter.getUnmatchedToOrdinals()); if(requiresTraversalForMissingFields) if(referenceFilter.getMatchedFromOrdinals().size() != 0 || referenceFilter.getMatchedToOrdinals().size() != 0) score += elementNode.traverseMissingFields(referenceFilter.getMatchedFromOrdinals(), referenceFilter.getMatchedToOrdinals()); return score; }
private void fillTraversalLists(IntList fromOrdinals, IntList toOrdinals) { traversalFromOrdinals.clear(); traversalToOrdinals.clear(); if(fromState != null) { for(int i=0;i<fromOrdinals.size();i++) { fillListWithReferencedOrdinals(fromState, fromOrdinals.get(i), traversalFromOrdinals); } } if(toState != null) { for(int i=0;i<toOrdinals.size();i++) { fillListWithReferencedOrdinals(toState, toOrdinals.get(i), traversalToOrdinals); } } }
private List<HollowUnmatchedObject> lazyGetUnmatchedObjects( ConcurrentHashMap<String, List<HollowUnmatchedObject>> cache, HollowTypeDiff typeDiff, HollowObjectTypeReadState typeState, IntList unmatchedOrdinals) { // Handle typeState missing from either from or to if (typeState==null) return Collections.emptyList(); List<HollowUnmatchedObject> list = cache.get(typeDiff.getTypeName()); if(list != null) return list; list = new ArrayList<HollowUnmatchedObject>(); for(int i=0;i<unmatchedOrdinals.size();i++) { int ordinal = unmatchedOrdinals.get(i); String keyDisplay = typeDiff.getMatcher().getKeyDisplayString(typeState, ordinal); list.add(new HollowUnmatchedObject(keyDisplay, ordinal)); } List<HollowUnmatchedObject> existingList = cache.putIfAbsent(typeState.getSchema().getName(), list); return existingList != null ? existingList : list; }
@Override public int traverseDiffs(IntList fromOrdinals, IntList toOrdinals) { fillTraversalLists(fromOrdinals, toOrdinals); keyFilter.filter(traversalFromKeyOrdinals, traversalToKeyOrdinals); valueFilter.filter(traversalFromValueOrdinals, traversalToValueOrdinals); int score = 0; if(keyFilter.getUnmatchedFromOrdinals().size() != 0 || keyFilter.getUnmatchedToOrdinals().size() != 0) score += keyNode.traverseDiffs(keyFilter.getUnmatchedFromOrdinals(), keyFilter.getUnmatchedToOrdinals()); if(keyRequiresTraversalForMissingFields) if(keyFilter.getMatchedFromOrdinals().size() != 0 || keyFilter.getMatchedToOrdinals().size() != 0) score += keyNode.traverseMissingFields(keyFilter.getMatchedFromOrdinals(), keyFilter.getMatchedToOrdinals()); if(valueFilter.getUnmatchedFromOrdinals().size() != 0 || valueFilter.getUnmatchedToOrdinals().size() != 0) score += valueNode.traverseDiffs(valueFilter.getUnmatchedFromOrdinals(), valueFilter.getUnmatchedToOrdinals()); if(valueRequiresTraversalForMissingFields) if(valueFilter.getMatchedFromOrdinals().size() != 0 || valueFilter.getMatchedToOrdinals().size() != 0) score += valueNode.traverseMissingFields(valueFilter.getMatchedFromOrdinals(), valueFilter.getMatchedToOrdinals()); return score; }
private void fillTraversalLists(IntList fromOrdinals, IntList toOrdinals) { traversalFromKeyOrdinals.clear(); traversalToKeyOrdinals.clear(); traversalFromValueOrdinals.clear(); traversalToValueOrdinals.clear(); if(fromState != null) { for(int i=0;i<fromOrdinals.size();i++) { fillListsWithReferencedOrdinals(fromState, fromOrdinals.get(i), traversalFromKeyOrdinals, traversalFromValueOrdinals); } } if(toState != null) { for(int i=0;i<toOrdinals.size();i++) { fillListsWithReferencedOrdinals(toState, toOrdinals.get(i), traversalToKeyOrdinals, traversalToValueOrdinals); } } }
public void buildToOrdinalIdentityMapping() { for(int i=0;i<fromOrdinalsMap.length;i++) { if(fromOrdinalsMap[i] >= 0) { int toOrdinal = (int)(fromOrdinalsMap[i] >> 32); addToOrdinalIdentity(toOrdinal, toOrdinal); } } boolean newCluster = true; int currentIdentity = 0; for(int i=0;i<pivotedToOrdinalClusters.size();i++) { if(newCluster) currentIdentity = pivotedToOrdinalClusters.get(i); addToOrdinalIdentity(pivotedToOrdinalClusters.get(i) & Integer.MAX_VALUE, currentIdentity); newCluster = (pivotedToOrdinalClusters.get(i) & Integer.MIN_VALUE) != 0; } }
/** * Should be called exclusively from the {@link HollowDiff} -- not intended for external consumption * * @param fromOrdinal the from ordinal * @param toOrdinal the to ordinal * @param score the score */ public void addDiff(int fromOrdinal, int toOrdinal, int score) { if(isSameDiffAsLastAdd(fromOrdinal, toOrdinal)) { int scoreIdx = diffPairScores.size() - 1; diffPairScores.set(scoreIdx, diffPairScores.get(scoreIdx) + score); } else { diffFromOrdinals.add(fromOrdinal); diffToOrdinals.add(toOrdinal); diffPairScores.add(score); } totalDiffScore += score; }
private void assertResults(HollowHistoryKeyIndex keyIdx, String type, String query, int... expectedResults) { IntList actualResults = keyIdx.getTypeKeyIndexes().get(type).queryIndexedFields(query); Assert.assertEquals(expectedResults.length, actualResults.size()); actualResults.sort(); for(int i=0;i<expectedResults.length;i++) { Assert.assertEquals(expectedResults[i], actualResults.get(i)); } }