public void addOutEdge(final Edge edge) {
boolean adding = false;
String label = edge.getLabel();
// Set<String> outs = getOutEdges();
Set<String> outs = getOutEdgesSet(label);
synchronized (outs) {
if (!outs.contains((String) edge.getId())) {
adding = true;
outs.add((String) edge.getId());
}
}
if (adding) {
getParent().startTransaction(this);
Map map = getOutDirtyMap();
synchronized (map) {
map.put(label, true);
}
Set<Edge> outLabelObjs = getOutEdgeCache(label);
synchronized (outLabelObjs) {
outLabelObjs.add(edge);
}
// outDirty_ = true;
// Set<Edge> outObjs = getOutEdgeObjects();
// synchronized (outObjs) {
// outObjs.add(edge);
// }
}
// setProperty(DominoVertex.OUT_NAME, outEdges_);
}
public void addInEdge(final Edge edge) {
boolean adding = false;
String label = edge.getLabel();
// Set<String> ins = getInEdges();
Set<String> ins = getInEdgesSet(label);
synchronized (ins) {
if (!ins.contains((String) edge.getId())) {
adding = true;
ins.add((String) edge.getId());
}
}
if (adding) {
getParent().startTransaction(this);
Map map = getInDirtyMap();
synchronized (map) {
map.put(label, true);
}
Set<Edge> inLabelObjs = getInEdgeCache(label);
synchronized (inLabelObjs) {
inLabelObjs.add(edge);
}
// inDirty_ = true;
// Set<Edge> inObjs = getInEdgeObjects();
// synchronized (inObjs) {
// inObjs.add(edge);
// }
}
}
public void removeEdge(final Edge edge) {
getParent().startTransaction(this);
String label = edge.getLabel();
boolean inChanged = false;
Set<String> ins = getInEdgesSet(label);
if (ins != null) {
// System.out.println("Removing an in edge from " + label + " with id " + edge.getId() + "
// from a vertex of type "
// + getProperty("Form"));
synchronized (ins) {
inChanged = ins.remove(edge.getId());
}
} else {
// System.out.println("in edges were null from a vertex of type " + getProperty("Form") + ":
// " + getId());
}
// Set<Edge> inObjs = getInEdgeObjects();
// synchronized (inObjs) {
// inObjs.remove(edge);
// }
if (inChanged) {
// System.out.println("Ins were changed so recording cache invalidation...");
Set<Edge> inObjsLabel = getInEdgeCache(label);
synchronized (inObjsLabel) {
inObjsLabel.remove(edge);
}
Map<String, Boolean> inDirtyMap = getInDirtyMap();
synchronized (inDirtyMap) {
inDirtyMap.put(label, true);
}
}
boolean outChanged = false;
Set<String> outs = getOutEdgesSet(label);
if (outs != null) {
// System.out.println("Removing an out edge from " + label + " with id " + edge.getId() + "
// from a vertex of type "
// + getProperty("Form"));
synchronized (outs) {
outChanged = outs.remove(edge.getId());
}
} else {
// System.out.println("out edges were null from a vertex of type " + getProperty("Form") +
// ": " + getId());
}
if (outChanged) {
// System.out.println("Out were changed so recording cache invalidation...");
Set<Edge> outObjsLabel = getOutEdgeCache(label);
synchronized (outObjsLabel) {
outObjsLabel.remove(edge);
}
Map<String, Boolean> outDirtyMap = getOutDirtyMap();
synchronized (outDirtyMap) {
outDirtyMap.put(label, true);
}
}
}
static Edge addEdge(Graph graph, Edge edge) {
Edge newEdge = graph.getEdge(edge.getId());
if (null == newEdge) {
Vertex outVertex = addNode(graph, edge.getVertex(Direction.OUT));
Vertex inVertex = addNode(graph, edge.getVertex(Direction.IN));
String label = edge.getLabel();
newEdge = graph.addEdge(edge.getId(), outVertex, inVertex, label);
copyProperties(edge, edge);
}
return newEdge;
}
public void run2() {
long testStartTime = System.nanoTime();
marktime = System.nanoTime();
try {
timelog("Beginning graph2 test...");
for (Vertex v : graph.getVertices()) {
System.out.println("RESULT: " + v.getId().toString());
}
for (Edge e : graph.getEdges()) {
System.out.println("RESULT: " + e.getId().toString() + ":" + e.getLabel());
}
// lotus.domino.Session s = Factory.terminate();
// s.recycle();
graph = null;
System.gc();
} catch (Throwable t) {
t.printStackTrace();
}
long testEndTime = System.nanoTime();
System.out.println(
"Completed "
+ getClass().getSimpleName()
+ " run2 in "
+ ((testEndTime - testStartTime) / 1000000)
+ " ms");
}
/*
* (non-Javadoc)
*
* @see
* com.tinkerpop.blueprints.Graph#removeEdge(com.tinkerpop.blueprints
* .pgm.Edge)
*/
@Override
public void removeEdge(final Edge edge) {
autoStartTransaction();
assert edge instanceof DexEdge;
getRawGraph().drop((Long) edge.getId());
}
private void writeEdgeProperties(Writer writer, Edge e) throws IOException {
Object blueprintsId = e.getId();
if (!useId) {
writeKey(writer, edgeIdKey);
if (blueprintsId instanceof Number) {
writeNumberProperty(writer, (Number) blueprintsId);
} else {
writeStringProperty(writer, blueprintsId);
}
}
writeProperties(writer, e);
}
/**
* Deletes the edge between outvertex and inVertex. The edge is for attribute attributeName of
* outVertex
*
* @param outVertex
* @param inVertex
* @param attributeName
* @throws AtlasException
*/
protected void deleteEdgeBetweenVertices(Vertex outVertex, Vertex inVertex, String attributeName)
throws AtlasException {
LOG.debug(
"Removing edge from {} to {} with attribute name {}",
string(outVertex),
string(inVertex),
attributeName);
String typeName = GraphHelper.getTypeName(outVertex);
String outId = GraphHelper.getIdFromVertex(outVertex);
Id.EntityState state = GraphHelper.getState(outVertex);
if ((outId != null && RequestContext.get().isDeletedEntity(outId))
|| state == Id.EntityState.DELETED) {
// If the reference vertex is marked for deletion, skip updating the reference
return;
}
IDataType type = typeSystem.getDataType(IDataType.class, typeName);
AttributeInfo attributeInfo = getFieldMapping(type).fields.get(attributeName);
String propertyName = GraphHelper.getQualifiedFieldName(type, attributeName);
String edgeLabel = EDGE_LABEL_PREFIX + propertyName;
Edge edge = null;
switch (attributeInfo.dataType().getTypeCategory()) {
case CLASS:
// If its class attribute, its the only edge between two vertices
if (attributeInfo.multiplicity.nullAllowed()) {
edge = GraphHelper.getEdgeForLabel(outVertex, edgeLabel);
if (shouldUpdateReverseAttribute) {
GraphHelper.setProperty(outVertex, propertyName, null);
}
} else {
// Cannot unset a required attribute.
throw new NullRequiredAttributeException(
"Cannot unset required attribute "
+ GraphHelper.getQualifiedFieldName(type, attributeName)
+ " on "
+ string(outVertex)
+ " edge = "
+ edgeLabel);
}
break;
case ARRAY:
// If its array attribute, find the right edge between the two vertices and update array
// property
List<String> elements = outVertex.getProperty(propertyName);
if (elements != null) {
elements =
new ArrayList<>(
elements); // Make a copy, else list.remove reflects on titan.getProperty()
for (String elementEdgeId : elements) {
Edge elementEdge = graphHelper.getEdgeByEdgeId(outVertex, edgeLabel, elementEdgeId);
if (elementEdge == null) {
continue;
}
Vertex elementVertex = elementEdge.getVertex(Direction.IN);
if (elementVertex.getId().toString().equals(inVertex.getId().toString())) {
edge = elementEdge;
// TODO element.size includes deleted items as well. should exclude
if (!attributeInfo.multiplicity.nullAllowed()
&& elements.size() <= attributeInfo.multiplicity.lower) {
// Deleting this edge would violate the attribute's lower bound.
throw new NullRequiredAttributeException(
"Cannot remove array element from required attribute "
+ GraphHelper.getQualifiedFieldName(type, attributeName)
+ " on "
+ string(outVertex)
+ " "
+ string(elementEdge));
}
if (shouldUpdateReverseAttribute) {
// if composite attribute, remove the reference as well. else, just remove the edge
// for example, when table is deleted, process still references the table
// but when column is deleted, table will not reference the deleted column
LOG.debug(
"Removing edge {} from the array attribute {}",
string(elementEdge),
attributeName);
elements.remove(elementEdge.getId().toString());
GraphHelper.setProperty(outVertex, propertyName, elements);
break;
}
}
}
}
break;
case MAP:
// If its map attribute, find the right edge between two vertices and update map property
List<String> keys = outVertex.getProperty(propertyName);
if (keys != null) {
keys =
new ArrayList<>(
keys); // Make a copy, else list.remove reflects on titan.getProperty()
for (String key : keys) {
String keyPropertyName = GraphHelper.getQualifiedNameForMapKey(propertyName, key);
String mapEdgeId = outVertex.getProperty(keyPropertyName);
Edge mapEdge = graphHelper.getEdgeByEdgeId(outVertex, keyPropertyName, mapEdgeId);
Vertex mapVertex = mapEdge.getVertex(Direction.IN);
if (mapVertex.getId().toString().equals(inVertex.getId().toString())) {
// TODO keys.size includes deleted items as well. should exclude
if (attributeInfo.multiplicity.nullAllowed()
|| keys.size() > attributeInfo.multiplicity.lower) {
edge = mapEdge;
} else {
// Deleting this entry would violate the attribute's lower bound.
throw new NullRequiredAttributeException(
"Cannot remove map entry "
+ keyPropertyName
+ " from required attribute "
+ GraphHelper.getQualifiedFieldName(type, attributeName)
+ " on "
+ string(outVertex)
+ " "
+ string(mapEdge));
}
if (shouldUpdateReverseAttribute) {
// remove this key
LOG.debug(
"Removing edge {}, key {} from the map attribute {}",
string(mapEdge),
key,
attributeName);
keys.remove(key);
GraphHelper.setProperty(outVertex, propertyName, keys);
GraphHelper.setProperty(outVertex, keyPropertyName, null);
}
break;
}
}
}
break;
case STRUCT:
case TRAIT:
break;
default:
throw new IllegalStateException(
"There can't be an edge from "
+ string(outVertex)
+ " to "
+ string(inVertex)
+ " with attribute name "
+ attributeName
+ " which is not class/array/map attribute");
}
if (edge != null) {
deleteEdge(edge, false);
RequestContext requestContext = RequestContext.get();
GraphHelper.setProperty(
outVertex,
Constants.MODIFICATION_TIMESTAMP_PROPERTY_KEY,
requestContext.getRequestTime());
requestContext.recordEntityUpdate(outId);
}
}