Skip to content

A
atlas
Commit f59284ad by Sarath Subramanian
Options

ATLAS-2040: Relationship with many-to-many cardinality gives incorrect relationship attribute value

parent 1b7e41f1
Showing with 486 additions and 113 deletions
intg/src/main/java/org/apache/atlas/type/AtlasRelationshipType.java
......@@ -31,6 +31,7 @@ import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import static org.apache.atlas.type.AtlasStructType.AtlasAttribute.AtlasRelationshipEdgeDirection;
import static org.apache.atlas.type.AtlasStructType.AtlasAttribute.AtlasRelationshipEdgeDirection.BOTH;
import static org.apache.atlas.type.AtlasStructType.AtlasAttribute.AtlasRelationshipEdgeDirection.IN;
import static org.apache.atlas.type.AtlasStructType.AtlasAttribute.AtlasRelationshipEdgeDirection.OUT;
......@@ -118,24 +119,33 @@ public class AtlasRelationshipType extends AtlasStructType {
}
private void addRelationshipEdgeDirection() {
AtlasRelationshipEndDef endDef1 = relationshipDef.getEndDef1();
AtlasRelationshipEndDef endDef2 = relationshipDef.getEndDef2();
AtlasAttribute end1Attribute = end1Type.getRelationshipAttribute(endDef1.getName());
AtlasAttribute end2Attribute = end2Type.getRelationshipAttribute(endDef2.getName());
AtlasRelationshipEndDef endDef1 = relationshipDef.getEndDef1();
AtlasRelationshipEndDef endDef2 = relationshipDef.getEndDef2();
//default relationship edge direction is end1 (out) -> end2 (in)
AtlasRelationshipEdgeDirection end1Direction = OUT;
AtlasRelationshipEdgeDirection end2Direction = IN;
if (StringUtils.equals(endDef1.getType(), endDef2.getType()) &&
StringUtils.equals(endDef1.getName(), endDef2.getName())) {
if (endDef1.getIsLegacyAttribute() && endDef2.getIsLegacyAttribute()) {
end2Direction = OUT;
} else if (!endDef1.getIsLegacyAttribute() && endDef2.getIsLegacyAttribute()) {
end1Direction = IN;
end2Direction = OUT;
}
AtlasAttribute endAttribute = end1Type.getRelationshipAttribute(endDef1.getName());
end1Attribute.setRelationshipEdgeDirection(end1Direction);
end2Attribute.setRelationshipEdgeDirection(end2Direction);
endAttribute.setRelationshipEdgeDirection(BOTH);
} else {
AtlasAttribute end1Attribute = end1Type.getRelationshipAttribute(endDef1.getName());
AtlasAttribute end2Attribute = end2Type.getRelationshipAttribute(endDef2.getName());
//default relationship edge direction is end1 (out) -> end2 (in)
AtlasRelationshipEdgeDirection end1Direction = OUT;
AtlasRelationshipEdgeDirection end2Direction = IN;
if (endDef1.getIsLegacyAttribute() && endDef2.getIsLegacyAttribute()) {
end2Direction = OUT;
} else if (!endDef1.getIsLegacyAttribute() && endDef2.getIsLegacyAttribute()) {
end1Direction = IN;
end2Direction = OUT;
}
end1Attribute.setRelationshipEdgeDirection(end1Direction);
end2Attribute.setRelationshipEdgeDirection(end2Direction);
}
}
@Override
......@@ -200,7 +210,6 @@ public class AtlasRelationshipType extends AtlasStructType {
AtlasRelationshipEndDef endDef2 = relationshipDef.getEndDef2();
RelationshipCategory relationshipCategory = relationshipDef.getRelationshipCategory();
String name = relationshipDef.getName();
boolean isContainer1 = endDef1.getIsContainer();
boolean isContainer2 = endDef2.getIsContainer();
......
intg/src/main/java/org/apache/atlas/type/AtlasStructType.java
......@@ -794,6 +794,6 @@ public class AtlasStructType extends AtlasType {
private static final char DOUBLE_QUOTE_CHAR = '"';
private static final char SPACE_CHAR = ' ';
public enum AtlasRelationshipEdgeDirection { IN, OUT }
public enum AtlasRelationshipEdgeDirection { IN, OUT, BOTH }
}
}
intg/src/test/java/org/apache/atlas/TestRelationshipUtilsV2.java
......@@ -23,8 +23,8 @@ import com.google.common.collect.ImmutableSet;
import org.apache.atlas.exception.AtlasBaseException;
import org.apache.atlas.model.instance.AtlasEntity;
import org.apache.atlas.model.instance.AtlasEntity.AtlasEntitiesWithExtInfo;
import org.apache.atlas.model.instance.AtlasObjectId;
import org.apache.atlas.model.instance.AtlasStruct;
import org.apache.atlas.model.typedef.AtlasBaseTypeDef;
import org.apache.atlas.model.typedef.AtlasClassificationDef;
import org.apache.atlas.model.typedef.AtlasEntityDef;
import org.apache.atlas.model.typedef.AtlasEnumDef;
......@@ -33,18 +33,17 @@ import org.apache.atlas.model.typedef.AtlasRelationshipDef;
import org.apache.atlas.model.typedef.AtlasRelationshipEndDef;
import org.apache.atlas.model.typedef.AtlasStructDef;
import org.apache.atlas.model.typedef.AtlasTypesDef;
import org.apache.atlas.type.AtlasTypeUtil;
import org.apache.commons.lang.ArrayUtils;
import org.apache.commons.lang.StringUtils;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import static org.apache.atlas.model.typedef.AtlasBaseTypeDef.getArrayTypeName;
import static org.apache.atlas.model.typedef.AtlasBaseTypeDef.getMapTypeName;
import static org.apache.atlas.model.typedef.AtlasRelationshipDef.PropagateTags.BOTH;
import static org.apache.atlas.model.typedef.AtlasRelationshipDef.PropagateTags.ONE_TO_TWO;
import static org.apache.atlas.model.typedef.AtlasRelationshipDef.RelationshipCategory.AGGREGATION;
import static org.apache.atlas.model.typedef.AtlasRelationshipDef.RelationshipCategory.ASSOCIATION;
......@@ -72,12 +71,13 @@ public final class TestRelationshipUtilsV2 {
public static final String EMPLOYEE_TYPE = "Employee";
public static final String EMPLOYEE_DEPARTMENT_TYPE = "EmployeeDepartment";
public static final String EMPLOYEE_MANAGER_TYPE = "EmployeeManager";
public static final String EMPLOYEE_MENTOR_TYPE = "EmployeeMentor";
public static final String EMPLOYEE_MENTORS_TYPE = "EmployeeMentors";
public static final String EMPLOYEE_FRIENDS_TYPE = "EmployeeFriends";
public static final String PERSON_SIBLING_TYPE = "PersonSibling";
public static final String TYPE_A = "A";
public static final String TYPE_B = "B";
public static final String DEFAULT_VERSION = "1.0";
private TestRelationshipUtilsV2() { }
public static AtlasTypesDef getDepartmentEmployeeTypes() throws AtlasBaseException {
......@@ -121,23 +121,36 @@ public final class TestRelationshipUtilsV2 {
DEFAULT_VERSION, AGGREGATION, ONE_TO_TWO,
new AtlasRelationshipEndDef(EMPLOYEE_TYPE, "department", SINGLE),
new AtlasRelationshipEndDef(DEPARTMENT_TYPE, "employees", SET, true));
/******* [Manager -> Employee] Relationship *******/
AtlasRelationshipDef employeeManagerType = new AtlasRelationshipDef(EMPLOYEE_MANAGER_TYPE, description(EMPLOYEE_MANAGER_TYPE),
DEFAULT_VERSION, AGGREGATION, ONE_TO_TWO,
new AtlasRelationshipEndDef(EMPLOYEE_TYPE, "manager", SINGLE),
new AtlasRelationshipEndDef(MANAGER_TYPE, "subordinates", SET, true));
/******* [Mentor -> Employee] Relationship *******/
AtlasRelationshipDef employeeMentorType = new AtlasRelationshipDef(EMPLOYEE_MENTOR_TYPE, description(EMPLOYEE_MENTOR_TYPE),
/******* [Mentors -> Employee] Relationship *******/
AtlasRelationshipDef employeeMentorsType = new AtlasRelationshipDef(EMPLOYEE_MENTORS_TYPE, description(EMPLOYEE_MENTORS_TYPE),
DEFAULT_VERSION, AGGREGATION, ONE_TO_TWO,
new AtlasRelationshipEndDef(EMPLOYEE_TYPE, "mentors", SET),
new AtlasRelationshipEndDef(EMPLOYEE_TYPE, "mentees", SET, true));
/******* [Friends -> Employee] Relationship *******/
AtlasRelationshipDef employeeFriendsType = new AtlasRelationshipDef(EMPLOYEE_FRIENDS_TYPE, description(EMPLOYEE_FRIENDS_TYPE),
DEFAULT_VERSION, ASSOCIATION, ONE_TO_TWO,
new AtlasRelationshipEndDef(EMPLOYEE_TYPE, "mentor", SINGLE),
new AtlasRelationshipEndDef(EMPLOYEE_TYPE, "mentees", SET));
new AtlasRelationshipEndDef(EMPLOYEE_TYPE, "friends", SET),
new AtlasRelationshipEndDef(EMPLOYEE_TYPE, "friends", SET));
/******* [Person -> Sibling] Relationship *******/
AtlasRelationshipDef personSiblingType = new AtlasRelationshipDef(PERSON_SIBLING_TYPE, description(PERSON_SIBLING_TYPE),
DEFAULT_VERSION, ASSOCIATION, BOTH,
new AtlasRelationshipEndDef(PERSON_TYPE, "sibling", SINGLE),
new AtlasRelationshipEndDef(PERSON_TYPE, "sibling", SINGLE));
return new AtlasTypesDef(ImmutableList.of(orgLevelType),
ImmutableList.of(addressType),
ImmutableList.of(securityClearanceType),
ImmutableList.of(personType, employeeType, departmentType, managerType),
ImmutableList.of(employeeDepartmentType, employeeManagerType, employeeMentorType));
ImmutableList.of(employeeDepartmentType, employeeManagerType, employeeMentorsType, employeeFriendsType, personSiblingType));
}
public static AtlasEntitiesWithExtInfo getDepartmentEmployeeInstances() {
......@@ -163,25 +176,30 @@ public final class TestRelationshipUtilsV2 {
johnAddr.setAttribute("street", "Stewart Drive");
johnAddr.setAttribute("city", "Sunnyvale");
/******* Manager - Jane (John and Max subordinates) *******/
AtlasStruct mikeAddr = new AtlasStruct(ADDRESS_TYPE);
mikeAddr.setAttribute("street", "Casa Verde St");
mikeAddr.setAttribute("city", "San Jose");
/******* Manager - Jane (Subordinates: [John, Max]) *******/
AtlasEntity jane = new AtlasEntity(MANAGER_TYPE);
jane.setAttribute("name", "Jane");
jane.setRelationshipAttribute("department", getAtlasObjectId(hrDept));
jane.setAttribute("address", janeAddr);
/******* Manager - Julius (no subordinates) *******/
/******* Manager - Julius (Subordinates: [], Sibling: Jane) *******/
AtlasEntity julius = new AtlasEntity(MANAGER_TYPE);
julius.setAttribute("name", "Julius");
julius.setRelationshipAttribute("department", getAtlasObjectId(hrDept));
julius.setRelationshipAttribute("sibling", getAtlasObjectId(jane));
julius.setAttribute("address", juliusAddr);
/******* Employee - Max (Manager: Jane, Mentor: Julius) *******/
/******* Employee - Max (Manager: Jane, Mentors: [Julius], Sibling: Julius) *******/
AtlasEntity max = new AtlasEntity(EMPLOYEE_TYPE);
max.setAttribute("name", "Max");
max.setRelationshipAttribute("department", getAtlasObjectId(hrDept));
max.setAttribute("address", maxAddr);
max.setRelationshipAttribute("manager", getAtlasObjectId(jane));
max.setRelationshipAttribute("mentor", getAtlasObjectId(julius));
max.setRelationshipAttribute("mentors", getAtlasObjectIds(julius));
max.setAttribute("birthday",new Date(1979, 3, 15));
max.setAttribute("hasPets", true);
max.setAttribute("age", 36);
......@@ -193,13 +211,14 @@ public final class TestRelationshipUtilsV2 {
max.setAttribute("numberOfStarsEstimate", new BigInteger("1000000000000000000000000000000"));
max.setAttribute("approximationOfPi", new BigDecimal("3.1415926535897932"));
/******* Employee - John (Manager: Jane, Mentor: Max) *******/
/******* Employee - John (Manager: Jane, Mentors: [Max], Friends: [Max]) *******/
AtlasEntity john = new AtlasEntity(EMPLOYEE_TYPE);
john.setAttribute("name", "John");
john.setRelationshipAttribute("department", getAtlasObjectId(hrDept));
john.setAttribute("address", johnAddr);
john.setRelationshipAttribute("manager", getAtlasObjectId(jane));
john.setRelationshipAttribute("mentor", getAtlasObjectId(max));
john.setRelationshipAttribute("mentors", getAtlasObjectIds(max, julius));
john.setRelationshipAttribute("friends", getAtlasObjectIds(max));
john.setAttribute("birthday",new Date(1950, 5, 15));
john.setAttribute("hasPets", true);
john.setAttribute("numberOfCars", 1);
......@@ -211,11 +230,30 @@ public final class TestRelationshipUtilsV2 {
john.setAttribute("numberOfStarsEstimate", new BigInteger("1000000000000000000000"));
john.setAttribute("approximationOfPi", new BigDecimal("3.141592653589793238462643383279502884197169399375105820974944592307816406286"));
/******* Employee - Mike (Manager: Julius, Friends: [Max, John]) *******/
AtlasEntity mike = new AtlasEntity(EMPLOYEE_TYPE);
mike.setAttribute("name", "Mike");
mike.setRelationshipAttribute("department", getAtlasObjectId(hrDept));
mike.setAttribute("address", mikeAddr);
mike.setRelationshipAttribute("manager", getAtlasObjectId(julius));
mike.setRelationshipAttribute("friends", getAtlasObjectIds(max, john));
mike.setAttribute("birthday",new Date(1947, 8, 15));
mike.setAttribute("hasPets", false);
mike.setAttribute("numberOfCars", 2);
mike.setAttribute("houseNumber", 3737);
mike.setAttribute("carMileage", 25000);
mike.setAttribute("shares", Long.MIN_VALUE);
mike.setAttribute("salary", Double.MIN_VALUE);
mike.setAttribute("age", 37);
mike.setAttribute("numberOfStarsEstimate", new BigInteger("5000050000050000050005"));
mike.setAttribute("approximationOfPi", new BigDecimal("3.14159"));
ret.addEntity(hrDept);
ret.addEntity(jane);
ret.addEntity(julius);
ret.addEntity(max);
ret.addEntity(john);
ret.addEntity(mike);
return ret;
}
......@@ -264,4 +302,16 @@ public final class TestRelationshipUtilsV2 {
private static ImmutableSet<String> superType(String superTypeName) {
return StringUtils.isNotEmpty(superTypeName) ? ImmutableSet.of(superTypeName) : ImmutableSet.<String>of();
}
private static List<AtlasObjectId> getAtlasObjectIds(AtlasEntity... entities) {
List<AtlasObjectId> ret = new ArrayList<>();
if (ArrayUtils.isNotEmpty(entities)) {
for (AtlasEntity entity : entities) {
ret.add(getAtlasObjectId(entity));
}
}
return ret;
}
}
\ No newline at end of file
repository/src/main/java/org/apache/atlas/repository/graph/GraphHelper.java
......@@ -42,7 +42,6 @@ import org.apache.atlas.repository.graphdb.AtlasVertex;
import org.apache.atlas.repository.store.graph.v1.AtlasGraphUtilsV1;
import org.apache.atlas.type.AtlasEntityType;
import org.apache.atlas.type.AtlasRelationshipType;
import org.apache.atlas.type.AtlasStructType;
import org.apache.atlas.type.AtlasType;
import org.apache.atlas.typesystem.IReferenceableInstance;
import org.apache.atlas.typesystem.ITypedInstance;
......@@ -86,6 +85,10 @@ import java.util.Set;
import java.util.Stack;
import java.util.UUID;
import static org.apache.atlas.type.AtlasStructType.AtlasAttribute.AtlasRelationshipEdgeDirection.BOTH;
import static org.apache.atlas.type.AtlasStructType.AtlasAttribute.AtlasRelationshipEdgeDirection.IN;
import static org.apache.atlas.type.AtlasStructType.AtlasAttribute.AtlasRelationshipEdgeDirection.OUT;
/**
* Utility class for graph operations.
*/
......@@ -308,7 +311,7 @@ public final class GraphHelper {
//In some cases of parallel APIs, the edge is added, but get edge by label doesn't return the edge. ATLAS-1104
//So traversing all the edges
public Iterator<AtlasEdge> getAdjacentEdgesByLabel(AtlasVertex instanceVertex, AtlasEdgeDirection direction, final String edgeLabel) {
public static Iterator<AtlasEdge> getAdjacentEdgesByLabel(AtlasVertex instanceVertex, AtlasEdgeDirection direction, final String edgeLabel) {
if (LOG.isDebugEnabled()) {
LOG.debug("Finding edges for {} with label {}", string(instanceVertex), edgeLabel);
}
......@@ -348,11 +351,11 @@ public final class GraphHelper {
return null;
}
public Iterator<AtlasEdge> getIncomingEdgesByLabel(AtlasVertex instanceVertex, String edgeLabel) {
public static Iterator<AtlasEdge> getIncomingEdgesByLabel(AtlasVertex instanceVertex, String edgeLabel) {
return getAdjacentEdgesByLabel(instanceVertex, AtlasEdgeDirection.IN, edgeLabel);
}
public Iterator<AtlasEdge> getOutGoingEdgesByLabel(AtlasVertex instanceVertex, String edgeLabel) {
public static Iterator<AtlasEdge> getOutGoingEdgesByLabel(AtlasVertex instanceVertex, String edgeLabel) {
return getAdjacentEdgesByLabel(instanceVertex, AtlasEdgeDirection.OUT, edgeLabel);
}
......@@ -361,20 +364,24 @@ public final class GraphHelper {
switch (edgeDirection) {
case IN:
ret = getEdgeForLabel(vertex, edgeLabel, AtlasEdgeDirection.IN);
break;
ret = getEdgeForLabel(vertex, edgeLabel, AtlasEdgeDirection.IN);
break;
case OUT:
ret = getEdgeForLabel(vertex, edgeLabel, AtlasEdgeDirection.OUT);
break;
case BOTH:
default:
ret = getEdgeForLabel(vertex, edgeLabel, AtlasEdgeDirection.OUT);
ret = getEdgeForLabel(vertex, edgeLabel, AtlasEdgeDirection.BOTH);
break;
}
return ret;
}
public Iterator<AtlasEdge> getEdgesForLabel(AtlasVertex vertex, String edgeLabel, AtlasRelationshipEdgeDirection edgeDirection) {
Iterator<AtlasEdge> ret;
public static Iterator<AtlasEdge> getEdgesForLabel(AtlasVertex vertex, String edgeLabel, AtlasRelationshipEdgeDirection edgeDirection) {
Iterator<AtlasEdge> ret = null;
switch (edgeDirection) {
case IN:
......@@ -382,8 +389,11 @@ public final class GraphHelper {
break;
case OUT:
default:
ret = getOutGoingEdgesByLabel(vertex, edgeLabel);
ret = getOutGoingEdgesByLabel(vertex, edgeLabel);
break;
case BOTH:
ret = getAdjacentEdgesByLabel(vertex, AtlasEdgeDirection.BOTH, edgeLabel);
break;
}
......@@ -1341,32 +1351,38 @@ public final class GraphHelper {
return StringUtils.isNotEmpty(edge.getLabel()) ? edgeLabel.startsWith("r:") : false;
}
public static AtlasObjectId getReferenceObjectId(AtlasEdge edge, AtlasRelationshipEdgeDirection relationshipDirection) {
public static AtlasObjectId getReferenceObjectId(AtlasEdge edge, AtlasRelationshipEdgeDirection relationshipDirection,
AtlasVertex parentVertex) {
AtlasObjectId ret = null;
if (relationshipDirection == AtlasRelationshipEdgeDirection.OUT) {
ret = new AtlasObjectId(getGuid(edge.getInVertex()), getTypeName(edge.getInVertex()));
if (relationshipDirection == OUT) {
ret = getAtlasObjectIdForInVertex(edge);
} else if (relationshipDirection == IN) {
ret = getAtlasObjectIdForOutVertex(edge);
} else if (relationshipDirection == AtlasRelationshipEdgeDirection.IN) {
ret = new AtlasObjectId(getGuid(edge.getOutVertex()), getTypeName(edge.getOutVertex()));
} else if (relationshipDirection == BOTH){
// since relationship direction is BOTH, edge direction can be inward or outward
// compare with parent entity vertex and pick the right reference vertex
if (verticesEquals(parentVertex, edge.getOutVertex())) {
ret = getAtlasObjectIdForInVertex(edge);
} else {
ret = getAtlasObjectIdForOutVertex(edge);
}
}
return ret;
}
public static AtlasObjectId getCurrentObjectId(AtlasEdge edge, AtlasRelationshipEdgeDirection relationshipDirection) {
String typeName = null;
String guid = null;
if (relationshipDirection == AtlasRelationshipEdgeDirection.OUT) {
typeName = GraphHelper.getTypeName(edge.getOutVertex());
guid = GraphHelper.getGuid(edge.getOutVertex());
public static AtlasObjectId getAtlasObjectIdForOutVertex(AtlasEdge edge) {
return new AtlasObjectId(getGuid(edge.getOutVertex()), getTypeName(edge.getOutVertex()));
}
} else if (relationshipDirection == AtlasRelationshipEdgeDirection.IN) {
typeName = GraphHelper.getTypeName(edge.getInVertex());
guid = GraphHelper.getGuid(edge.getInVertex());
}
public static AtlasObjectId getAtlasObjectIdForInVertex(AtlasEdge edge) {
return new AtlasObjectId(getGuid(edge.getInVertex()), getTypeName(edge.getInVertex()));
}
return new AtlasObjectId(guid, typeName);
private static boolean verticesEquals(AtlasVertex vertexA, AtlasVertex vertexB) {
return StringUtils.equals(getGuid(vertexB), getGuid(vertexA));
}
}
\ No newline at end of file
repository/src/main/java/org/apache/atlas/repository/store/graph/v1/DeleteHandlerV1.java
......@@ -40,6 +40,7 @@ import org.apache.atlas.type.AtlasStructType.AtlasAttribute;
import org.apache.atlas.type.AtlasStructType.AtlasAttribute.AtlasRelationshipEdgeDirection;
import org.apache.atlas.type.AtlasType;
import org.apache.atlas.type.AtlasTypeRegistry;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
......@@ -54,9 +55,13 @@ import java.util.Set;
import java.util.Stack;
import static org.apache.atlas.repository.graph.GraphHelper.EDGE_LABEL_PREFIX;
import static org.apache.atlas.repository.graph.GraphHelper.getAtlasObjectIdForInVertex;
import static org.apache.atlas.repository.graph.GraphHelper.getAtlasObjectIdForOutVertex;
import static org.apache.atlas.repository.graph.GraphHelper.getGuid;
import static org.apache.atlas.repository.graph.GraphHelper.getReferenceObjectId;
import static org.apache.atlas.repository.graph.GraphHelper.isRelationshipEdge;
import static org.apache.atlas.repository.graph.GraphHelper.string;
import static org.apache.atlas.type.AtlasStructType.AtlasAttribute.AtlasRelationshipEdgeDirection.BOTH;
public abstract class DeleteHandlerV1 {
......@@ -219,14 +224,14 @@ public abstract class DeleteHandlerV1 {
* @throws AtlasException
*/
public boolean deleteEdgeReference(AtlasEdge edge, TypeCategory typeCategory, boolean isOwned,
boolean forceDeleteStructTrait) throws AtlasBaseException {
boolean forceDeleteStructTrait, AtlasVertex vertex) throws AtlasBaseException {
// default edge direction is outward
return deleteEdgeReference(edge, typeCategory, isOwned, forceDeleteStructTrait, AtlasRelationshipEdgeDirection.OUT);
return deleteEdgeReference(edge, typeCategory, isOwned, forceDeleteStructTrait, AtlasRelationshipEdgeDirection.OUT, vertex);
}
public boolean deleteEdgeReference(AtlasEdge edge, TypeCategory typeCategory, boolean isOwned, boolean forceDeleteStructTrait,
AtlasRelationshipEdgeDirection relationshipDirection) throws AtlasBaseException {
AtlasRelationshipEdgeDirection relationshipDirection, AtlasVertex entityVertex) throws AtlasBaseException {
LOG.debug("Deleting {}", string(edge));
boolean forceDelete =
(typeCategory == TypeCategory.STRUCT || typeCategory == TypeCategory.CLASSIFICATION) && forceDeleteStructTrait;
......@@ -250,7 +255,7 @@ public abstract class DeleteHandlerV1 {
if (isRelationshipEdge(edge)) {
deleteEdge(edge, false);
AtlasObjectId deletedReferenceObjectId = getReferenceObjectId(edge, relationshipDirection);
AtlasObjectId deletedReferenceObjectId = getReferenceObjectId(edge, relationshipDirection, entityVertex);
RequestContextV1.get().recordEntityUpdate(deletedReferenceObjectId);
} else {
//legacy case - not a relationship edge
......@@ -344,7 +349,7 @@ public abstract class DeleteHandlerV1 {
if (edges != null) {
while (edges.hasNext()) {
AtlasEdge edge = edges.next();
deleteEdgeReference(edge, elemType.getTypeCategory(), isOwned, false);
deleteEdgeReference(edge, elemType.getTypeCategory(), isOwned, false, instanceVertex);
}
}
}
......@@ -377,7 +382,7 @@ public abstract class DeleteHandlerV1 {
boolean isOwned) throws AtlasBaseException {
AtlasEdge edge = graphHelper.getEdgeForLabel(outVertex, edgeLabel);
if (edge != null) {
deleteEdgeReference(edge, typeCategory, isOwned, false);
deleteEdgeReference(edge, typeCategory, isOwned, false, outVertex);
}
}
......
repository/src/main/java/org/apache/atlas/repository/store/graph/v1/EntityGraphMapper.java
......@@ -51,6 +51,7 @@ import org.apache.atlas.type.AtlasType;
import org.apache.atlas.type.AtlasTypeRegistry;
import org.apache.atlas.type.AtlasTypeUtil;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections.IteratorUtils;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
......@@ -70,7 +71,9 @@ import static org.apache.atlas.repository.graph.GraphHelper.getTypeName;
import static org.apache.atlas.repository.graph.GraphHelper.isRelationshipEdge;
import static org.apache.atlas.repository.graph.GraphHelper.string;
import static org.apache.atlas.repository.store.graph.v1.AtlasGraphUtilsV1.getIdFromVertex;
import static org.apache.atlas.type.AtlasStructType.AtlasAttribute.AtlasRelationshipEdgeDirection.BOTH;
import static org.apache.atlas.type.AtlasStructType.AtlasAttribute.AtlasRelationshipEdgeDirection.IN;
import static org.apache.atlas.type.AtlasStructType.AtlasAttribute.AtlasRelationshipEdgeDirection.OUT;
@Component
public class EntityGraphMapper {
......@@ -353,7 +356,7 @@ public class EntityGraphMapper {
AtlasEdge newEdge = mapStructValue(ctx, context);
if (currentEdge != null && !currentEdge.equals(newEdge)) {
deleteHandler.deleteEdgeReference(currentEdge, ctx.getAttrType().getTypeCategory(), false, true);
deleteHandler.deleteEdgeReference(currentEdge, ctx.getAttrType().getTypeCategory(), false, true, ctx.getReferringVertex());
}
return newEdge;
......@@ -423,7 +426,7 @@ public class EntityGraphMapper {
//delete old reference
deleteHandler.deleteEdgeReference(currentEdge, ctx.getAttrType().getTypeCategory(), ctx.getAttribute().isOwnedRef(),
true, ctx.getAttribute().getRelationshipEdgeDirection());
true, ctx.getAttribute().getRelationshipEdgeDirection(), ctx.getReferringVertex());
}
return newEdge;
......@@ -457,7 +460,7 @@ public class EntityGraphMapper {
if (!inverseEdge.equals(newEdge)) {
// Disconnect old reference
deleteHandler.deleteEdgeReference(inverseEdge, inverseAttribute.getAttributeType().getTypeCategory(),
inverseAttribute.isOwnedRef(), true);
inverseAttribute.isOwnedRef(), true, inverseVertex);
}
else {
// Edge already exists for this attribute between these vertices.
......@@ -675,9 +678,7 @@ public class EntityGraphMapper {
Map<String, Object> relationshipAttributes = getRelationshipAttributes(ctx.getValue());
if (ctx.getCurrentEdge() != null) {
ret = updateRelationship(ctx.getCurrentEdge(), attributeVertex, edgeDirection, relationshipAttributes);
recordEntityUpdate(attributeVertex);
ret = updateRelationship(ctx.getCurrentEdge(), entityVertex, attributeVertex, edgeDirection, relationshipAttributes);
} else {
String relationshipName = graphHelper.getRelationshipDefName(entityVertex, entityType, attributeName);
......@@ -805,10 +806,16 @@ public class EntityGraphMapper {
List newElements = (List) ctx.getValue();
AtlasArrayType arrType = (AtlasArrayType) attribute.getAttributeType();
AtlasType elementType = arrType.getElementType();
List<Object> currentElements = getArrayElementsProperty(elementType, ctx.getReferringVertex(), ctx.getVertexProperty());
boolean isReference = AtlasGraphUtilsV1.isReference(elementType);
AtlasAttribute inverseRefAttribute = attribute.getInverseRefAttribute();
List<Object> newElementsCreated = new ArrayList<>();
List<Object> currentElements;
if (isRelationshipAttribute(attribute)) {
currentElements = getArrayElementsUsingRelationship(ctx.getReferringVertex(), attribute, elementType);
} else {
currentElements = getArrayElementsProperty(elementType, ctx.getReferringVertex(), ctx.getVertexProperty());
}
if (CollectionUtils.isNotEmpty(newElements)) {
for (int index = 0; index < newElements.size(); index++) {
......@@ -817,6 +824,7 @@ public class EntityGraphMapper {
ctx.getVertexProperty(), elementType, existingEdge);
Object newEntry = mapCollectionElementsToVertex(arrCtx, context);
if (isReference && newEntry instanceof AtlasEdge && inverseRefAttribute != null) {
// Update the inverse reference value.
AtlasEdge newEdge = (AtlasEdge) newEntry;
......@@ -829,7 +837,7 @@ public class EntityGraphMapper {
}
if (isReference) {
List<AtlasEdge> additionalEdges = removeUnusedArrayEntries(attribute, (List) currentElements, (List) newElementsCreated);
List<AtlasEdge> additionalEdges = removeUnusedArrayEntries(attribute, (List) currentElements, (List) newElementsCreated, ctx.getReferringVertex());
newElementsCreated.addAll(additionalEdges);
}
......@@ -1048,7 +1056,7 @@ public class EntityGraphMapper {
AtlasEdge currentEdge = (AtlasEdge)currentMap.get(currentKey);
if (!newMap.values().contains(currentEdge)) {
boolean deleted = deleteHandler.deleteEdgeReference(currentEdge, mapType.getValueType().getTypeCategory(), attribute.isOwnedRef(), true);
boolean deleted = deleteHandler.deleteEdgeReference(currentEdge, mapType.getValueType().getTypeCategory(), attribute.isOwnedRef(), true, vertex);
if (!deleted) {
additionalMap.put(currentKey, currentEdge);
......@@ -1104,8 +1112,10 @@ public class EntityGraphMapper {
return newEdge;
}
private AtlasEdge updateRelationship(AtlasEdge currentEdge, final AtlasVertex newEntityVertex, AtlasRelationshipEdgeDirection edgeDirection,
Map<String, Object> relationshipAttributes) throws AtlasBaseException {
private AtlasEdge updateRelationship(AtlasEdge currentEdge, final AtlasVertex parentEntityVertex, final AtlasVertex newEntityVertex,
AtlasRelationshipEdgeDirection edgeDirection, Map<String, Object> relationshipAttributes)
throws AtlasBaseException {
if (LOG.isDebugEnabled()) {
LOG.debug("Updating entity reference using relationship {} for reference attribute {}", getTypeName(newEntityVertex));
}
......@@ -1115,8 +1125,15 @@ public class EntityGraphMapper {
// Max's mentor updated from John to Jane (John.mentee --> Max.mentor)
// mentor attribute (IN direction), current mentee vertex (John) (OUT vertex)
String currentEntityId = (edgeDirection == IN) ? getIdFromVertex(currentEdge.getOutVertex()) :
getIdFromVertex(currentEdge.getInVertex());
String currentEntityId;
if (edgeDirection == IN) {
currentEntityId = getIdFromOutVertex(currentEdge);
} else if (edgeDirection == OUT) {
currentEntityId = getIdFromInVertex(currentEdge);
} else {
currentEntityId = getIdFromBothVertex(currentEdge, parentEntityVertex);
}
String newEntityId = getIdFromVertex(newEntityVertex);
AtlasEdge ret = currentEdge;
......@@ -1129,8 +1146,17 @@ public class EntityGraphMapper {
relationshipName = currentEdge.getLabel();
}
ret = (edgeDirection == IN) ? getOrCreateRelationship(newEntityVertex, currentEdge.getInVertex(), relationshipName, relationshipAttributes) :
getOrCreateRelationship(currentEdge.getOutVertex(), newEntityVertex, relationshipName, relationshipAttributes);
if (edgeDirection == IN) {
ret = getOrCreateRelationship(newEntityVertex, currentEdge.getInVertex(), relationshipName, relationshipAttributes);
} else if (edgeDirection == OUT) {
ret = getOrCreateRelationship(currentEdge.getOutVertex(), newEntityVertex, relationshipName, relationshipAttributes);
} else {
ret = getOrCreateRelationship(newEntityVertex, parentEntityVertex, relationshipName, relationshipAttributes);
}
//record entity update on new relationship vertex
recordEntityUpdate(newEntityVertex);
}
return ret;
......@@ -1145,6 +1171,21 @@ public class EntityGraphMapper {
}
}
public static List<Object> getArrayElementsUsingRelationship(AtlasVertex vertex, AtlasAttribute attribute, AtlasType elementType) {
List<Object> ret = null;
if (AtlasGraphUtilsV1.isReference(elementType)) {
AtlasRelationshipEdgeDirection edgeDirection = attribute.getRelationshipEdgeDirection();
String edgeLabel = attribute.getRelationshipEdgeLabel();
Iterator<AtlasEdge> edgesForLabel = GraphHelper.getEdgesForLabel(vertex, edgeLabel, edgeDirection);
ret = IteratorUtils.toList(edgesForLabel);
}
return ret;
}
private AtlasEdge getEdgeAt(List<Object> currentElements, int index, AtlasType elemType) {
AtlasEdge ret = null;
......@@ -1158,7 +1199,8 @@ public class EntityGraphMapper {
}
//Removes unused edges from the old collection, compared to the new collection
private List<AtlasEdge> removeUnusedArrayEntries(AtlasAttribute attribute, List<AtlasEdge> currentEntries, List<AtlasEdge> newEntries) throws AtlasBaseException {
private List<AtlasEdge> removeUnusedArrayEntries(AtlasAttribute attribute, List<AtlasEdge> currentEntries, List<AtlasEdge> newEntries, AtlasVertex entityVertex) throws AtlasBaseException {
if (CollectionUtils.isNotEmpty(currentEntries)) {
AtlasType entryType = ((AtlasArrayType) attribute.getAttributeType()).getElementType();
......@@ -1170,7 +1212,7 @@ public class EntityGraphMapper {
for (AtlasEdge edge : edgesToRemove) {
boolean deleted = deleteHandler.deleteEdgeReference(edge, entryType.getTypeCategory(), attribute.isOwnedRef(),
true, attribute.getRelationshipEdgeDirection());
true, attribute.getRelationshipEdgeDirection(), entityVertex);
if (!deleted) {
additionalElements.add(edge);
......@@ -1184,7 +1226,6 @@ public class EntityGraphMapper {
return Collections.emptyList();
}
private void setArrayElementsProperty(AtlasType elementType, AtlasVertex vertex, String vertexPropertyName, List<Object> values) {
if (AtlasGraphUtilsV1.isReference(elementType)) {
GraphHelper.setListPropertyFromElementIds(vertex, vertexPropertyName, (List) values);
......@@ -1334,7 +1375,7 @@ public class EntityGraphMapper {
String relationshipLabel = GraphHelper.getTraitLabel(entityTypeName, classificationName);
AtlasEdge edge = graphHelper.getEdgeForLabel(instanceVertex, relationshipLabel);
if (edge != null) {
deleteHandler.deleteEdgeReference(edge, TypeCategory.CLASSIFICATION, false, true);
deleteHandler.deleteEdgeReference(edge, TypeCategory.CLASSIFICATION, false, true, instanceVertex);
// update the traits in entity once trait removal is successful
traitNames.remove(classificationName);
......@@ -1433,7 +1474,7 @@ public class EntityGraphMapper {
private static void compactAttributes(AtlasEntity entity) {
if (entity != null) {
Map<String, Object> relationshipAttributes = entity.getRelationshipAttributes();
Map<String, Object> attributes = entity.getAttributes();
Map<String, Object> attributes = entity.getAttributes();
if (MapUtils.isNotEmpty(relationshipAttributes) && MapUtils.isNotEmpty(attributes)) {
for (String attrName : relationshipAttributes.keySet()) {
......@@ -1444,4 +1485,23 @@ public class EntityGraphMapper {
}
}
}
}
private String getIdFromInVertex(AtlasEdge edge) {
return getIdFromVertex(edge.getInVertex());
}
private String getIdFromOutVertex(AtlasEdge edge) {
return getIdFromVertex(edge.getOutVertex());
}
private String getIdFromBothVertex(AtlasEdge currentEdge, AtlasVertex parentEntityVertex) {
String parentEntityId = getIdFromVertex(parentEntityVertex);
String currentEntityId = getIdFromVertex(currentEdge.getInVertex());
if (StringUtils.equals(currentEntityId, parentEntityId)) {
currentEntityId = getIdFromOutVertex(currentEdge);
}
return currentEntityId;
}
}
\ No newline at end of file
repository/src/main/java/org/apache/atlas/repository/store/graph/v1/EntityGraphRetriever.java
......@@ -72,6 +72,9 @@ import static org.apache.atlas.model.typedef.AtlasBaseTypeDef.ATLAS_TYPE_STRING;
import static org.apache.atlas.repository.graph.GraphHelper.EDGE_LABEL_PREFIX;
import static org.apache.atlas.repository.store.graph.v1.AtlasGraphUtilsV1.getIdFromVertex;
import static org.apache.atlas.type.AtlasStructType.AtlasAttribute.AtlasRelationshipEdgeDirection;
import static org.apache.atlas.type.AtlasStructType.AtlasAttribute.AtlasRelationshipEdgeDirection.BOTH;
import static org.apache.atlas.type.AtlasStructType.AtlasAttribute.AtlasRelationshipEdgeDirection.IN;
import static org.apache.atlas.type.AtlasStructType.AtlasAttribute.AtlasRelationshipEdgeDirection.OUT;
public final class EntityGraphRetriever {
......@@ -683,10 +686,12 @@ public final class EntityGraphRetriever {
List<AtlasRelatedObjectId> ret = new ArrayList<>();
Iterator<AtlasEdge> edges = null;
if (attribute.getRelationshipEdgeDirection() == AtlasRelationshipEdgeDirection.IN) {
if (attribute.getRelationshipEdgeDirection() == IN) {
edges = graphHelper.getIncomingEdgesByLabel(entityVertex, attribute.getRelationshipEdgeLabel());
} else if (attribute.getRelationshipEdgeDirection() == AtlasRelationshipEdgeDirection.OUT) {
} else if (attribute.getRelationshipEdgeDirection() == OUT) {
edges = graphHelper.getOutGoingEdgesByLabel(entityVertex, attribute.getRelationshipEdgeLabel());
} else if (attribute.getRelationshipEdgeDirection() == BOTH) {
edges = graphHelper.getAdjacentEdgesByLabel(entityVertex, AtlasEdgeDirection.BOTH, attribute.getRelationshipEdgeLabel());
}
if (edges != null) {
......
repository/src/test/java/org/apache/atlas/repository/store/graph/v1/AtlasRelationshipStoreHardDeleteV1Test.java
......@@ -20,9 +20,15 @@ package org.apache.atlas.repository.store.graph.v1;
import com.google.common.collect.ImmutableList;
import org.apache.atlas.TestModules;
import org.apache.atlas.model.instance.AtlasEntity;
import org.apache.atlas.model.instance.AtlasObjectId;
import org.testng.annotations.Guice;
import java.util.List;
import static org.apache.atlas.type.AtlasTypeUtil.getAtlasObjectId;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertNotNull;
import static org.testng.Assert.assertNull;
/**
* Inverse reference update test with {@link HardDeleteHandlerV1}
......@@ -51,4 +57,56 @@ public class AtlasRelationshipStoreHardDeleteV1Test extends AtlasRelationshipSto
protected void verifyRelationshipAttributeUpdate_NonComposite_OneToOne(AtlasEntity a1, AtlasEntity b) {
verifyRelationshipAttributeValue(a1, "b", null);
}
}
@Override
protected void verifyRelationshipAttributeUpdate_ManyToMany_Friends(AtlasEntity max, AtlasEntity julius, AtlasEntity mike, AtlasEntity john) throws Exception {
AtlasObjectId johnId = employeeNameIdMap.get("John");
AtlasObjectId mikeId = employeeNameIdMap.get("Mike");
AtlasObjectId juliusId = employeeNameIdMap.get("Julius");
AtlasObjectId maxId = employeeNameIdMap.get("Max");
List<AtlasObjectId> maxFriendsIds = toAtlasObjectIds(max.getRelationshipAttribute("friends"));
assertNotNull(maxFriendsIds);
assertEquals(maxFriendsIds.size(), 2);
assertObjectIdsContains(maxFriendsIds, johnId);
assertObjectIdsContains(maxFriendsIds, juliusId);
// Julius's updated friends: [Max]
List<AtlasObjectId> juliusFriendsIds = toAtlasObjectIds(julius.getRelationshipAttribute("friends"));
assertNotNull(juliusFriendsIds);
assertEquals(juliusFriendsIds.size(), 1);
assertObjectIdsContains(juliusFriendsIds, maxId);
// Mike's updated friends: [John]
List<AtlasObjectId> mikeFriendsIds = toAtlasObjectIds(mike.getRelationshipAttribute("friends"));
assertNotNull(mikeFriendsIds);
assertEquals(mikeFriendsIds.size(), 1);
assertObjectIdsContains(mikeFriendsIds, johnId);
// John's updated friends: [Max, Mike]
List<AtlasObjectId> johnFriendsIds = toAtlasObjectIds(john.getRelationshipAttribute("friends"));
assertNotNull(johnFriendsIds);
assertEquals(johnFriendsIds.size(), 2);
assertObjectIdsContains(johnFriendsIds, maxId);
assertObjectIdsContains(johnFriendsIds, mikeId);
}
protected void verifyRelationshipAttributeUpdate_OneToOne_Sibling(AtlasEntity julius, AtlasEntity jane, AtlasEntity mike) throws Exception {
AtlasObjectId juliusId = employeeNameIdMap.get("Julius");
AtlasObjectId mikeId = employeeNameIdMap.get("Mike");
// Julius sibling updated to Mike
AtlasObjectId juliusSiblingId = toAtlasObjectId(julius.getRelationshipAttribute("sibling"));
assertNotNull(juliusSiblingId);
assertObjectIdEquals(juliusSiblingId, mikeId);
// Mike's sibling is Julius
AtlasObjectId mikeSiblingId = toAtlasObjectId(mike.getRelationshipAttribute("sibling"));
assertNotNull(mikeSiblingId);
assertObjectIdEquals(mikeSiblingId, juliusId);
// Julius removed from Jane's sibling (hard delete)
AtlasObjectId janeSiblingId = toAtlasObjectId(jane.getRelationshipAttribute("sibling"));
assertNull(janeSiblingId);
}
}
\ No newline at end of file
repository/src/test/java/org/apache/atlas/repository/store/graph/v1/AtlasRelationshipStoreSoftDeleteV1Test.java
......@@ -20,9 +20,14 @@ package org.apache.atlas.repository.store.graph.v1;
import com.google.common.collect.ImmutableList;
import org.apache.atlas.TestModules;
import org.apache.atlas.model.instance.AtlasEntity;
import org.apache.atlas.model.instance.AtlasObjectId;
import org.testng.annotations.Guice;
import java.util.List;
import static org.apache.atlas.type.AtlasTypeUtil.getAtlasObjectId;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertNotNull;
/**
......@@ -52,4 +57,60 @@ public class AtlasRelationshipStoreSoftDeleteV1Test extends AtlasRelationshipSto
protected void verifyRelationshipAttributeUpdate_NonComposite_OneToOne(AtlasEntity a1, AtlasEntity b) {
verifyRelationshipAttributeValue(a1, "b", b.getGuid());
}
}
@Override
protected void verifyRelationshipAttributeUpdate_ManyToMany_Friends(AtlasEntity max, AtlasEntity julius, AtlasEntity mike, AtlasEntity john) throws Exception {
AtlasObjectId johnId = employeeNameIdMap.get("John");
AtlasObjectId mikeId = employeeNameIdMap.get("Mike");
AtlasObjectId juliusId = employeeNameIdMap.get("Julius");
AtlasObjectId maxId = employeeNameIdMap.get("Max");
// Max's updated friends: [Julius, John, Mike(soft deleted)]
List<AtlasObjectId> maxFriendsIds = toAtlasObjectIds(max.getRelationshipAttribute("friends"));
assertNotNull(maxFriendsIds);
assertEquals(maxFriendsIds.size(), 3);
assertObjectIdsContains(maxFriendsIds, johnId);
assertObjectIdsContains(maxFriendsIds, juliusId);
assertObjectIdsContains(maxFriendsIds, mikeId);
// Julius's updated friends: [Max]
List<AtlasObjectId> juliusFriendsIds = toAtlasObjectIds(julius.getRelationshipAttribute("friends"));
assertNotNull(juliusFriendsIds);
assertEquals(juliusFriendsIds.size(), 1);
assertObjectIdsContains(juliusFriendsIds, maxId);
// Mike's updated friends: [John, Max(soft deleted)]
List<AtlasObjectId> mikeFriendsIds = toAtlasObjectIds(mike.getRelationshipAttribute("friends"));
assertNotNull(mikeFriendsIds);
assertEquals(mikeFriendsIds.size(), 2);
assertObjectIdsContains(mikeFriendsIds, johnId);
assertObjectIdsContains(mikeFriendsIds, maxId);
// John's updated friends: [Max, Mike]
List<AtlasObjectId> johnFriendsIds = toAtlasObjectIds(john.getRelationshipAttribute("friends"));
assertNotNull(johnFriendsIds);
assertEquals(johnFriendsIds.size(), 2);
assertObjectIdsContains(johnFriendsIds, maxId);
assertObjectIdsContains(johnFriendsIds, mikeId);
}
protected void verifyRelationshipAttributeUpdate_OneToOne_Sibling(AtlasEntity julius, AtlasEntity jane, AtlasEntity mike) throws Exception {
AtlasObjectId juliusId = employeeNameIdMap.get("Julius");
AtlasObjectId mikeId = employeeNameIdMap.get("Mike");
// Julius sibling updated to Mike
AtlasObjectId juliusSiblingId = toAtlasObjectId(julius.getRelationshipAttribute("sibling"));
assertNotNull(juliusSiblingId);
assertObjectIdEquals(juliusSiblingId, mikeId);
// Mike's sibling is Julius
AtlasObjectId mikeSiblingId = toAtlasObjectId(mike.getRelationshipAttribute("sibling"));
assertNotNull(mikeSiblingId);
assertObjectIdEquals(mikeSiblingId, juliusId);
// Jane's sibling is still Julius (soft delete)
AtlasObjectId janeSiblingId = toAtlasObjectId(jane.getRelationshipAttribute("sibling"));
assertNotNull(janeSiblingId);
assertObjectIdEquals(janeSiblingId, juliusId);
}
}
\ No newline at end of file
repository/src/test/java/org/apache/atlas/repository/store/graph/v1/AtlasRelationshipStoreV1Test.java
......@@ -131,21 +131,24 @@ public abstract class AtlasRelationshipStoreV1Test {
AtlasObjectId johnId = employeeNameIdMap.get("John");
AtlasObjectId juliusId = employeeNameIdMap.get("Julius");
AtlasObjectId janeId = employeeNameIdMap.get("Jane");
AtlasObjectId mikeId = employeeNameIdMap.get("Mike");
AtlasEntity hrDept = getEntityFromStore(hrId.getGuid());
AtlasEntity max = getEntityFromStore(maxId.getGuid());
AtlasEntity john = getEntityFromStore(johnId.getGuid());
AtlasEntity julius = getEntityFromStore(juliusId.getGuid());
AtlasEntity jane = getEntityFromStore(janeId.getGuid());
AtlasEntity mike = getEntityFromStore(mikeId.getGuid());
// Department relationship attributes
List<AtlasObjectId> deptEmployees = toAtlasObjectIds(hrDept.getRelationshipAttribute("employees"));
assertNotNull(deptEmployees);
assertEquals(deptEmployees.size(), 4);
assertEquals(deptEmployees.size(), 5);
assertObjectIdsContains(deptEmployees, maxId);
assertObjectIdsContains(deptEmployees, johnId);
assertObjectIdsContains(deptEmployees, juliusId);
assertObjectIdsContains(deptEmployees, janeId);
assertObjectIdsContains(deptEmployees, mikeId);
// Max employee validation
AtlasObjectId maxDepartmentId = toAtlasObjectId(max.getRelationshipAttribute("department"));
......@@ -156,15 +159,22 @@ public abstract class AtlasRelationshipStoreV1Test {
assertNotNull(maxManagerId);
assertObjectIdEquals(maxManagerId, janeId);
AtlasObjectId maxMentorId = toAtlasObjectId(max.getRelationshipAttribute("mentor"));
assertNotNull(maxMentorId);
assertObjectIdEquals(maxMentorId, juliusId);
List<AtlasObjectId> maxMentorsId = toAtlasObjectIds(max.getRelationshipAttribute("mentors"));
assertNotNull(maxMentorsId);
assertEquals(maxMentorsId.size(), 1);
assertObjectIdEquals(maxMentorsId.get(0), juliusId);
List<AtlasObjectId> maxMenteesId = toAtlasObjectIds(max.getRelationshipAttribute("mentees"));
assertNotNull(maxMenteesId);
assertEquals(maxMenteesId.size(), 1);
assertObjectIdEquals(maxMenteesId.get(0), johnId);
List<AtlasObjectId> maxFriendsIds = toAtlasObjectIds(max.getRelationshipAttribute("friends"));
assertNotNull(maxFriendsIds);
assertEquals(maxFriendsIds.size(), 2);
assertObjectIdsContains(maxFriendsIds, mikeId);
assertObjectIdsContains(maxFriendsIds, johnId);
// John Employee validation
AtlasObjectId johnDepartmentId = toAtlasObjectId(john.getRelationshipAttribute("department"));
assertNotNull(johnDepartmentId);
......@@ -174,13 +184,42 @@ public abstract class AtlasRelationshipStoreV1Test {
assertNotNull(johnManagerId);
assertObjectIdEquals(johnManagerId, janeId);
AtlasObjectId johnMentorId = toAtlasObjectId(john.getRelationshipAttribute("mentor"));
assertNotNull(johnMentorId);
assertObjectIdEquals(johnMentorId, maxId);
List<AtlasObjectId> johnMentorIds = toAtlasObjectIds(john.getRelationshipAttribute("mentors"));
assertNotNull(johnMentorIds);
assertEquals(johnMentorIds.size(), 2);
assertObjectIdsContains(johnMentorIds, maxId);
assertObjectIdsContains(johnMentorIds, juliusId);
List<AtlasObjectId> johnMenteesId = toAtlasObjectIds(john.getRelationshipAttribute("mentees"));
assertEmpty(johnMenteesId);
List<AtlasObjectId> johnFriendsIds = toAtlasObjectIds(john.getRelationshipAttribute("friends"));
assertNotNull(johnFriendsIds);
assertEquals(johnFriendsIds.size(), 2);
assertObjectIdsContains(johnFriendsIds, mikeId);
assertObjectIdsContains(johnFriendsIds, maxId);
// Mike Employee validation
AtlasObjectId mikeDepartmentId = toAtlasObjectId(mike.getRelationshipAttribute("department"));
assertNotNull(mikeDepartmentId);
assertObjectIdEquals(mikeDepartmentId, hrId);
AtlasObjectId mikeManagerId = toAtlasObjectId(mike.getRelationshipAttribute("manager"));
assertNotNull(mikeManagerId);
assertObjectIdEquals(mikeManagerId, juliusId);
List<AtlasObjectId> mikeMentorIds = toAtlasObjectIds(mike.getRelationshipAttribute("mentors"));
assertEmpty(mikeMentorIds);
List<AtlasObjectId> mikeMenteesId = toAtlasObjectIds(mike.getRelationshipAttribute("mentees"));
assertEmpty(mikeMenteesId);
List<AtlasObjectId> mikeFriendsIds = toAtlasObjectIds(mike.getRelationshipAttribute("friends"));
assertNotNull(mikeFriendsIds);
assertEquals(mikeFriendsIds.size(), 2);
assertObjectIdsContains(mikeFriendsIds, maxId);
assertObjectIdsContains(mikeFriendsIds, johnId);
// Jane Manager validation
AtlasObjectId janeDepartmentId = toAtlasObjectId(jane.getRelationshipAttribute("department"));
assertNotNull(janeDepartmentId);
......@@ -189,8 +228,8 @@ public abstract class AtlasRelationshipStoreV1Test {
AtlasObjectId janeManagerId = toAtlasObjectId(jane.getRelationshipAttribute("manager"));
assertNull(janeManagerId);
AtlasObjectId janeMentorId = toAtlasObjectId(jane.getRelationshipAttribute("mentor"));
assertNull(janeMentorId);
List<AtlasObjectId> janeMentorIds = toAtlasObjectIds(jane.getRelationshipAttribute("mentors"));
assertEmpty(janeMentorIds);
List<AtlasObjectId> janeMenteesId = toAtlasObjectIds(jane.getRelationshipAttribute("mentees"));
assertEmpty(janeMenteesId);
......@@ -201,6 +240,13 @@ public abstract class AtlasRelationshipStoreV1Test {
assertObjectIdsContains(janeSubordinateIds, maxId);
assertObjectIdsContains(janeSubordinateIds, johnId);
List<AtlasObjectId> janeFriendsIds = toAtlasObjectIds(jane.getRelationshipAttribute("friends"));
assertEmpty(janeFriendsIds);
AtlasObjectId janeSiblingId = toAtlasObjectId(jane.getRelationshipAttribute("sibling"));
assertNotNull(janeSiblingId);
assertObjectIdEquals(janeSiblingId, juliusId);
// Julius Manager validation
AtlasObjectId juliusDepartmentId = toAtlasObjectId(julius.getRelationshipAttribute("department"));
assertNotNull(juliusDepartmentId);
......@@ -209,16 +255,26 @@ public abstract class AtlasRelationshipStoreV1Test {
AtlasObjectId juliusManagerId = toAtlasObjectId(julius.getRelationshipAttribute("manager"));
assertNull(juliusManagerId);
AtlasObjectId juliusMentorId = toAtlasObjectId(julius.getRelationshipAttribute("mentor"));
assertNull(juliusMentorId);
List<AtlasObjectId> juliusMentorIds = toAtlasObjectIds(julius.getRelationshipAttribute("mentors"));
assertEmpty(juliusMentorIds);
List<AtlasObjectId> juliusMenteesId = toAtlasObjectIds(julius.getRelationshipAttribute("mentees"));
assertNotNull(juliusMenteesId);
assertEquals(juliusMenteesId.size(), 1);
assertEquals(juliusMenteesId.size(), 2);
assertObjectIdsContains(juliusMenteesId, maxId);
assertObjectIdsContains(juliusMenteesId, johnId);
List<AtlasObjectId> juliusSubordinateIds = toAtlasObjectIds(julius.getRelationshipAttribute("subordinates"));
assertEmpty(juliusSubordinateIds);
assertNotNull(juliusSubordinateIds);
assertEquals(juliusSubordinateIds.size(), 1);
assertObjectIdsContains(juliusSubordinateIds, mikeId);
List<AtlasObjectId> juliusFriendsIds = toAtlasObjectIds(julius.getRelationshipAttribute("friends"));
assertEmpty(juliusFriendsIds);
AtlasObjectId juliusSiblingId = toAtlasObjectId(julius.getRelationshipAttribute("sibling"));
assertNotNull(juliusSiblingId);
assertObjectIdEquals(juliusSiblingId, janeId);
}
@Test
......@@ -226,6 +282,8 @@ public abstract class AtlasRelationshipStoreV1Test {
AtlasObjectId maxId = employeeNameIdMap.get("Max");
AtlasObjectId juliusId = employeeNameIdMap.get("Julius");
AtlasObjectId janeId = employeeNameIdMap.get("Jane");
AtlasObjectId mikeId = employeeNameIdMap.get("Mike");
AtlasObjectId johnId = employeeNameIdMap.get("John");
// Change Max's Employee.manager reference to Julius and apply the change as a partial update.
// This should also update Julius to add Max to the inverse Manager.subordinates reference.
......@@ -249,9 +307,9 @@ public abstract class AtlasRelationshipStoreV1Test {
AtlasEntity maxEntity = updatedEntities.getEntity(maxId.getGuid());
verifyRelationshipAttributeValue(maxEntity, "manager", juliusId.getGuid());
// Max added to the subordinate list of Julius
// Max added to the subordinate list of Julius, existing subordinate is Mike
AtlasEntity juliusEntity = updatedEntities.getEntity(juliusId.getGuid());
verifyRelationshipAttributeList(juliusEntity, "subordinates", ImmutableList.of(maxId));
verifyRelationshipAttributeList(juliusEntity, "subordinates", ImmutableList.of(maxId, mikeId));
// Max removed from the subordinate list of Julius
AtlasEntity janeEntity = updatedEntities.getEntity(janeId.getGuid());
......@@ -259,6 +317,48 @@ public abstract class AtlasRelationshipStoreV1Test {
// Jane's subordinates list includes John and Max for soft delete
// Jane's subordinates list includes only John for hard delete
verifyRelationshipAttributeUpdate_NonComposite_OneToMany(janeEntity);
// Remove Mike from Max's friends list
// Max's current friends: [Mike, John]
// Max's updated friends: [Julius, John]
maxEntityForUpdate = new AtlasEntity(EMPLOYEE_TYPE);
maxEntityForUpdate.setRelationshipAttribute("friends", ImmutableList.of(johnId, juliusId));
init();
updateResponse = entityStore.updateByUniqueAttributes(employeeType, uniqAttributes , new AtlasEntityWithExtInfo(maxEntityForUpdate));
partialUpdatedEntities = updateResponse.getPartialUpdatedEntities();
assertEquals(partialUpdatedEntities.size(), 3);
// 3 entities should have been updated:
// * Max added Julius and removed Mike from Employee.friends
// * Mike removed Max from Employee.friends
// * Julius added Max in Employee.friends
updatedEntities = entityStore.getByIds(ImmutableList.of(maxId.getGuid(), mikeId.getGuid(), johnId.getGuid(), juliusId.getGuid()));
maxEntity = updatedEntities.getEntity(maxId.getGuid());
juliusEntity = updatedEntities.getEntity(juliusId.getGuid());
AtlasEntity mikeEntity = updatedEntities.getEntity(mikeId.getGuid());
AtlasEntity johnEntity = updatedEntities.getEntity(johnId.getGuid());
verifyRelationshipAttributeUpdate_ManyToMany_Friends(maxEntity, juliusEntity, mikeEntity, johnEntity);
// Remove Julius from Jane's sibling and add Mike as new sibling
AtlasEntity juliusEntityForUpdate = new AtlasEntity(EMPLOYEE_TYPE);
juliusEntityForUpdate.setRelationshipAttribute("sibling", mikeId);
init();
updateResponse = entityStore.updateByUniqueAttributes(employeeType, Collections.<String, Object>singletonMap("name", "Julius") , new AtlasEntityWithExtInfo(juliusEntityForUpdate));
partialUpdatedEntities = updateResponse.getPartialUpdatedEntities();
assertEquals(partialUpdatedEntities.size(), 3);
updatedEntities = entityStore.getByIds(ImmutableList.of(juliusId.getGuid(), janeId.getGuid(), mikeId.getGuid()));
juliusEntity = updatedEntities.getEntity(juliusId.getGuid());
janeEntity = updatedEntities.getEntity(janeId.getGuid());
mikeEntity = updatedEntities.getEntity(mikeId.getGuid());
verifyRelationshipAttributeUpdate_OneToOne_Sibling(juliusEntity, janeEntity, mikeEntity);
}
@Test
......@@ -445,12 +545,16 @@ public abstract class AtlasRelationshipStoreV1Test {
protected abstract void verifyRelationshipAttributeUpdate_NonComposite_ManyToOne(AtlasEntity a1, AtlasEntity a2, AtlasEntity a3, AtlasEntity b);
private static void assertObjectIdsContains(List<AtlasObjectId> objectIds, AtlasObjectId objectId) {
protected abstract void verifyRelationshipAttributeUpdate_ManyToMany_Friends(AtlasEntity e1, AtlasEntity e2, AtlasEntity e3, AtlasEntity e4) throws Exception;
protected abstract void verifyRelationshipAttributeUpdate_OneToOne_Sibling(AtlasEntity e1, AtlasEntity e2, AtlasEntity e3) throws Exception;
protected static void assertObjectIdsContains(List<AtlasObjectId> objectIds, AtlasObjectId objectId) {
assertTrue(CollectionUtils.isNotEmpty(objectIds));
assertTrue(objectIds.contains(objectId));
}
private static void assertObjectIdEquals(AtlasObjectId objId1, AtlasObjectId objId2) {
protected static void assertObjectIdEquals(AtlasObjectId objId1, AtlasObjectId objId2) {
assertTrue(objId1.equals(objId2));
}
......@@ -458,7 +562,7 @@ public abstract class AtlasRelationshipStoreV1Test {
assertTrue(collection != null && collection.isEmpty());
}
private static List<AtlasObjectId> toAtlasObjectIds(Object object) {
protected static List<AtlasObjectId> toAtlasObjectIds(Object object) {
List<AtlasObjectId> ret = new ArrayList<>();
if (object instanceof List) {
......@@ -477,7 +581,7 @@ public abstract class AtlasRelationshipStoreV1Test {
return ret;
}
private static AtlasObjectId toAtlasObjectId(Object object) {
protected static AtlasObjectId toAtlasObjectId(Object object) {
if (object instanceof AtlasRelatedObjectId) {
AtlasRelatedObjectId relatedObjectId = (AtlasRelatedObjectId) object;
return new AtlasObjectId(relatedObjectId.getGuid(), relatedObjectId.getTypeName(), relatedObjectId.getUniqueAttributes());
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment