org.openecomp.sdc.be.dao.titan

Class TitanGenericDao

java.lang.Object

org.openecomp.sdc.be.dao.titan.TitanGenericDao

@Component(value="titan-generic-dao")
public class TitanGenericDao
extends Object

Constructor Summary

Constructors

Constructor and Description
TitanGenericDao()

Method Summary

Modifier and Type	Method and Description
TitanOperationStatus	commit()
TitanOperationStatus	createEdge(com.thinkaurelius.titan.core.TitanVertex vertexOut, GraphNode to, GraphEdgeLabels type, Map<String,Object> properties)
TitanOperationStatus	createEdge(com.thinkaurelius.titan.core.TitanVertex vertexOut, com.thinkaurelius.titan.core.TitanVertex vertexIn, GraphEdgeLabels type, Map<String,Object> properties)
fj.data.Either<com.thinkaurelius.titan.core.TitanVertex,TitanOperationStatus>	createNode(GraphNode node)
<T extends GraphNode> fj.data.Either<T,TitanOperationStatus>	createNode(T node, Class<T> clazz)
fj.data.Either<GraphRelation,TitanOperationStatus>	createRelation(GraphNode from, GraphNode to, GraphEdgeLabels label, Map<String,Object> properties)
fj.data.Either<GraphRelation,TitanOperationStatus>	createRelation(GraphRelation relation)
<T extends GraphNode> fj.data.Either<List<org.apache.commons.lang3.tuple.ImmutablePair<T,GraphEdge>>,TitanOperationStatus>	deleteChildrenNodes(String key, String uniqueId, GraphEdgeLabels edgeType, NodeTypeEnum nodeTypeEnum, Class<T> clazz)
fj.data.Either<GraphRelation,TitanOperationStatus>	deleteIncomingRelation(GraphRelation relation)
fj.data.Either<GraphRelation,TitanOperationStatus>	deleteIncomingRelationByCriteria(GraphNode to, GraphEdgeLabels label, Map<String,Object> props)
<T extends GraphNode> fj.data.Either<T,TitanOperationStatus>	deleteNode(GraphNode node, Class<T> clazz)
<T extends GraphNode> fj.data.Either<T,TitanOperationStatus>	deleteNode(String keyName, Object keyValue, Class<T> clazz)
fj.data.Either<GraphRelation,TitanOperationStatus>	deleteOutgoingRelation(GraphRelation relation)
fj.data.Either<GraphRelation,TitanOperationStatus>	deleteRelation(GraphNode from, GraphNode to, GraphEdgeLabels label)
fj.data.Either<GraphRelation,TitanOperationStatus>	deleteRelation(GraphRelation relation)
<T extends GraphNode> fj.data.Either<List<T>,TitanOperationStatus>	getAll(NodeTypeEnum type, Class<T> clazz)
<T extends GraphNode> fj.data.Either<List<T>,TitanOperationStatus>	getByCriteria(NodeTypeEnum type, Class<T> clazz, List<org.apache.commons.lang3.tuple.ImmutableTriple<QueryType,String,Object>> props)
<T extends GraphNode> fj.data.Either<List<T>,TitanOperationStatus>	getByCriteria(NodeTypeEnum type, Map<String,Object> props, Class<T> clazz)
<T extends GraphNode> fj.data.Either<List<T>,TitanOperationStatus>	getByCriteria(NodeTypeEnum type, Map<String,Object> hasProps, Map<String,Object> hasNotProps, Class<T> clazz)
<T extends GraphNode> fj.data.Either<List<T>,TitanOperationStatus>	getByCriteriaWithPradicat(NodeTypeEnum type, Map<String,Map.Entry<com.thinkaurelius.titan.graphdb.query.TitanPredicate,Object>> props, Class<T> clazz)
<T extends GraphNode> fj.data.Either<org.apache.commons.lang3.tuple.ImmutablePair<T,GraphEdge>,TitanOperationStatus>	getChild(String key, String uniqueId, GraphEdgeLabels edgeType, NodeTypeEnum nodeTypeEnum, Class<T> clazz)
<T extends GraphNode> fj.data.Either<org.apache.commons.lang3.tuple.ImmutablePair<T,GraphEdge>,TitanOperationStatus>	getChildByEdgeCriteria(String key, String uniqueId, GraphEdgeLabels edgeType, NodeTypeEnum nodeTypeEnum, Class<T> clazz, Map<String,Object> edgeProperties)
fj.data.Either<org.apache.commons.lang3.tuple.ImmutablePair<com.thinkaurelius.titan.core.TitanVertex,org.apache.tinkerpop.gremlin.structure.Edge>,TitanOperationStatus>	getChildByEdgeCriteria(com.thinkaurelius.titan.core.TitanVertex vertex, GraphEdgeLabels edgeType, Map<String,Object> edgeProperties)
<T extends GraphNode> fj.data.Either<List<org.apache.commons.lang3.tuple.ImmutablePair<T,GraphEdge>>,TitanOperationStatus>	getChildrenByEdgeCriteria(org.apache.tinkerpop.gremlin.structure.Vertex vertex, String vertexUniqueId, GraphEdgeLabels edgeType, NodeTypeEnum nodeTypeEnum, Class<T> clazz, Map<String,Object> edgeProperties)
<T extends GraphNode> fj.data.Either<List<org.apache.commons.lang3.tuple.ImmutablePair<T,GraphEdge>>,TitanOperationStatus>	getChildrenNodes(String key, String uniqueId, GraphEdgeLabels edgeType, NodeTypeEnum nodeTypeEnum, Class<T> clazz)
<T extends GraphNode> fj.data.Either<List<org.apache.commons.lang3.tuple.ImmutablePair<T,GraphEdge>>,TitanOperationStatus>	getChildrenNodes(String key, String uniqueId, GraphEdgeLabels edgeType, NodeTypeEnum nodeTypeEnum, Class<T> clazz, boolean withEdges)
fj.data.Either<List<org.apache.commons.lang3.tuple.ImmutablePair<com.thinkaurelius.titan.core.TitanVertex,org.apache.tinkerpop.gremlin.structure.Edge>>,TitanOperationStatus>	getChildrenVertecies(String key, String uniqueId, GraphEdgeLabels edgeType)
org.apache.commons.lang3.tuple.ImmutablePair<com.thinkaurelius.titan.core.TitanVertex,org.apache.tinkerpop.gremlin.structure.Edge>	getChildVertex(com.thinkaurelius.titan.core.TitanVertex vertex, GraphEdgeLabels edgeType)
fj.data.Either<List<org.apache.tinkerpop.gremlin.structure.Edge>,TitanOperationStatus>	getEdgesForNode(GraphNode node, org.apache.tinkerpop.gremlin.structure.Direction requestedDirection)
fj.data.Either<com.thinkaurelius.titan.core.TitanGraph,TitanOperationStatus>	getGraph()
fj.data.Either<org.apache.tinkerpop.gremlin.structure.Edge,TitanOperationStatus>	getIncomingEdgeByCriteria(GraphNode to, GraphEdgeLabels label, Map<String,Object> props)
fj.data.Either<GraphRelation,TitanOperationStatus>	getIncomingRelationByCriteria(GraphNode to, GraphEdgeLabels label, Map<String,Object> props)
<T extends GraphNode> fj.data.Either<T,TitanOperationStatus>	getNode(String keyName, Object keyValue, Class<T> clazz)
fj.data.Either<org.apache.tinkerpop.gremlin.structure.Edge,TitanOperationStatus>	getOutgoingEdgeByCriteria(String key, String value, GraphEdgeLabels label, Map<String,Object> props)
fj.data.Either<org.apache.tinkerpop.gremlin.structure.Edge,TitanOperationStatus>	getOutgoingEdgeByCriteria(com.thinkaurelius.titan.core.TitanVertex vertex, GraphEdgeLabels label, Map<String,Object> props)
fj.data.Either<List<org.apache.tinkerpop.gremlin.structure.Edge>,TitanOperationStatus>	getOutgoingEdgesByCriteria(org.apache.tinkerpop.gremlin.structure.Vertex vertexFrom, GraphEdgeLabels label, Map<String,Object> props)
<T extends GraphNode> fj.data.Either<org.apache.commons.lang3.tuple.ImmutablePair<T,GraphEdge>,TitanOperationStatus>	getParentNode(String key, String uniqueId, GraphEdgeLabels edgeType, NodeTypeEnum nodeTypeEnum, Class<T> clazz)
<T extends GraphNode> fj.data.Either<List<org.apache.commons.lang3.tuple.ImmutablePair<T,GraphEdge>>,TitanOperationStatus>	getParentNodes(String key, String uniqueId, GraphEdgeLabels edgeType, NodeTypeEnum nodeTypeEnum, Class<T> clazz)
Map<String,Object>	getProperties(org.apache.tinkerpop.gremlin.structure.Element element)
Object	getProperty(org.apache.tinkerpop.gremlin.structure.Edge edge, String key)
Object	getProperty(com.thinkaurelius.titan.core.TitanVertex vertex, String key)
fj.data.Either<GraphRelation,TitanOperationStatus>	getRelation(GraphNode from, GraphNode to, GraphEdgeLabels label)
fj.data.Either<com.thinkaurelius.titan.core.TitanVertex,TitanOperationStatus>	getVertexByProperty(String name, Object value)
boolean	isGraphOpen()
TitanOperationStatus	lockElement(GraphNode node)
TitanOperationStatus	lockElement(String id, NodeTypeEnum type)
TitanOperationStatus	releaseElement(GraphNode node)
TitanOperationStatus	releaseElement(String id, NodeTypeEnum type)
fj.data.Either<GraphRelation,TitanOperationStatus>	replaceRelationLabel(GraphNode from, GraphNode to, GraphEdgeLabels label, GraphEdgeLabels newLabel)
TitanOperationStatus	rollback()
void	setProperties(org.apache.tinkerpop.gremlin.structure.Element element, Map<String,Object> properties)
void	setTitanGraphClient(TitanGraphClient titanGraphClient)
<T extends GraphNode> fj.data.Either<T,TitanOperationStatus>	updateNode(GraphNode node, Class<T> clazz)
fj.data.Either<GraphRelation,TitanOperationStatus>	updateRelation(GraphNode from, GraphNode to, GraphEdgeLabels label, Map<String,Object> properties)
fj.data.Either<GraphRelation,TitanOperationStatus>	updateRelation(GraphRelation relation)
TitanOperationStatus	updateVertex(GraphNode node, com.thinkaurelius.titan.core.TitanVertex vertex)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

TitanGenericDao

public TitanGenericDao()

Method Detail

commit

public TitanOperationStatus commit()

rollback

public TitanOperationStatus rollback()

getGraph

public fj.data.Either<com.thinkaurelius.titan.core.TitanGraph,TitanOperationStatus> getGraph()

isGraphOpen

public boolean isGraphOpen()

createNode

public <T extends GraphNode> fj.data.Either<T,TitanOperationStatus> createNode(T node,
                                                                               Class<T> clazz)

Parameters:

node -

clazz -

Returns:

createNode

public fj.data.Either<com.thinkaurelius.titan.core.TitanVertex,TitanOperationStatus> createNode(GraphNode node)

createRelation

public fj.data.Either<GraphRelation,TitanOperationStatus> createRelation(GraphRelation relation)

Parameters:

relation -

Returns:

createEdge

public TitanOperationStatus createEdge(com.thinkaurelius.titan.core.TitanVertex vertexOut,
                                       com.thinkaurelius.titan.core.TitanVertex vertexIn,
                                       GraphEdgeLabels type,
                                       Map<String,Object> properties)

createEdge

public TitanOperationStatus createEdge(com.thinkaurelius.titan.core.TitanVertex vertexOut,
                                       GraphNode to,
                                       GraphEdgeLabels type,
                                       Map<String,Object> properties)

createRelation

public fj.data.Either<GraphRelation,TitanOperationStatus> createRelation(GraphNode from,
                                                                         GraphNode to,
                                                                         GraphEdgeLabels label,
                                                                         Map<String,Object> properties)

Parameters:

from -

to -

label -

properties -

Returns:

replaceRelationLabel

public fj.data.Either<GraphRelation,TitanOperationStatus> replaceRelationLabel(GraphNode from,
                                                                               GraphNode to,
                                                                               GraphEdgeLabels label,
                                                                               GraphEdgeLabels newLabel)

getNode

public <T extends GraphNode> fj.data.Either<T,TitanOperationStatus> getNode(String keyName,
                                                                            Object keyValue,
                                                                            Class<T> clazz)

Parameters:

keyName -

keyValue -

clazz -

Returns:

getRelation

public fj.data.Either<GraphRelation,TitanOperationStatus> getRelation(GraphNode from,
                                                                      GraphNode to,
                                                                      GraphEdgeLabels label)

Parameters:

from -

to -

label -

Returns:

deleteIncomingRelationByCriteria

public fj.data.Either<GraphRelation,TitanOperationStatus> deleteIncomingRelationByCriteria(GraphNode to,
                                                                                           GraphEdgeLabels label,
                                                                                           Map<String,Object> props)

getIncomingRelationByCriteria

public fj.data.Either<GraphRelation,TitanOperationStatus> getIncomingRelationByCriteria(GraphNode to,
                                                                                        GraphEdgeLabels label,
                                                                                        Map<String,Object> props)

getIncomingEdgeByCriteria

public fj.data.Either<org.apache.tinkerpop.gremlin.structure.Edge,TitanOperationStatus> getIncomingEdgeByCriteria(GraphNode to,
                                                                                                                  GraphEdgeLabels label,
                                                                                                                  Map<String,Object> props)

getEdgesForNode

public fj.data.Either<List<org.apache.tinkerpop.gremlin.structure.Edge>,TitanOperationStatus> getEdgesForNode(GraphNode node,
                                                                                                              org.apache.tinkerpop.gremlin.structure.Direction requestedDirection)

updateRelation

public fj.data.Either<GraphRelation,TitanOperationStatus> updateRelation(GraphNode from,
                                                                         GraphNode to,
                                                                         GraphEdgeLabels label,
                                                                         Map<String,Object> properties)

Parameters:

from -

to -

label -

properties -

Returns:

updateRelation

public fj.data.Either<GraphRelation,TitanOperationStatus> updateRelation(GraphRelation relation)

Parameters:

relation -

Returns:

getVertexByProperty

public fj.data.Either<com.thinkaurelius.titan.core.TitanVertex,TitanOperationStatus> getVertexByProperty(String name,
                                                                                                         Object value)

getByCriteria

public <T extends GraphNode> fj.data.Either<List<T>,TitanOperationStatus> getByCriteria(NodeTypeEnum type,
                                                                                        Map<String,Object> hasProps,
                                                                                        Map<String,Object> hasNotProps,
                                                                                        Class<T> clazz)

getByCriteria

public <T extends GraphNode> fj.data.Either<List<T>,TitanOperationStatus> getByCriteria(NodeTypeEnum type,
                                                                                        Class<T> clazz,
                                                                                        List<org.apache.commons.lang3.tuple.ImmutableTriple<QueryType,String,Object>> props)

getByCriteria

public <T extends GraphNode> fj.data.Either<List<T>,TitanOperationStatus> getByCriteria(NodeTypeEnum type,
                                                                                        Map<String,Object> props,
                                                                                        Class<T> clazz)

getByCriteriaWithPradicat

public <T extends GraphNode> fj.data.Either<List<T>,TitanOperationStatus> getByCriteriaWithPradicat(NodeTypeEnum type,
                                                                                                    Map<String,Map.Entry<com.thinkaurelius.titan.graphdb.query.TitanPredicate,Object>> props,
                                                                                                    Class<T> clazz)

getAll

public <T extends GraphNode> fj.data.Either<List<T>,TitanOperationStatus> getAll(NodeTypeEnum type,
                                                                                 Class<T> clazz)

updateNode

public <T extends GraphNode> fj.data.Either<T,TitanOperationStatus> updateNode(GraphNode node,
                                                                               Class<T> clazz)

Parameters:

node -

clazz -

Returns:

updateVertex

public TitanOperationStatus updateVertex(GraphNode node,
                                         com.thinkaurelius.titan.core.TitanVertex vertex)

deleteNode

public <T extends GraphNode> fj.data.Either<T,TitanOperationStatus> deleteNode(GraphNode node,
                                                                               Class<T> clazz)

Parameters:

node -

clazz -

Returns:

deleteNode

public <T extends GraphNode> fj.data.Either<T,TitanOperationStatus> deleteNode(String keyName,
                                                                               Object keyValue,
                                                                               Class<T> clazz)

Parameters:

keyName -

keyValue -

clazz -

Returns:

deleteRelation

public fj.data.Either<GraphRelation,TitanOperationStatus> deleteRelation(GraphRelation relation)

deleteRelation

public fj.data.Either<GraphRelation,TitanOperationStatus> deleteRelation(GraphNode from,
                                                                         GraphNode to,
                                                                         GraphEdgeLabels label)

setTitanGraphClient

public void setTitanGraphClient(TitanGraphClient titanGraphClient)

deleteIncomingRelation

public fj.data.Either<GraphRelation,TitanOperationStatus> deleteIncomingRelation(GraphRelation relation)

deleteOutgoingRelation

public fj.data.Either<GraphRelation,TitanOperationStatus> deleteOutgoingRelation(GraphRelation relation)

lockElement

public TitanOperationStatus lockElement(String id,
                                        NodeTypeEnum type)

Parameters:

id -

Returns:

lockElement

public TitanOperationStatus lockElement(GraphNode node)

getChildrenNodes

public <T extends GraphNode> fj.data.Either<List<org.apache.commons.lang3.tuple.ImmutablePair<T,GraphEdge>>,TitanOperationStatus> getChildrenNodes(String key,
                                                                                                                                                   String uniqueId,
                                                                                                                                                   GraphEdgeLabels edgeType,
                                                                                                                                                   NodeTypeEnum nodeTypeEnum,
                                                                                                                                                   Class<T> clazz,
                                                                                                                                                   boolean withEdges)

getChildrenVertecies

public fj.data.Either<List<org.apache.commons.lang3.tuple.ImmutablePair<com.thinkaurelius.titan.core.TitanVertex,org.apache.tinkerpop.gremlin.structure.Edge>>,TitanOperationStatus> getChildrenVertecies(String key,
                                                                                                                                                                                                          String uniqueId,
                                                                                                                                                                                                          GraphEdgeLabels edgeType)

getChildrenNodes

public <T extends GraphNode> fj.data.Either<List<org.apache.commons.lang3.tuple.ImmutablePair<T,GraphEdge>>,TitanOperationStatus> getChildrenNodes(String key,
                                                                                                                                                   String uniqueId,
                                                                                                                                                   GraphEdgeLabels edgeType,
                                                                                                                                                   NodeTypeEnum nodeTypeEnum,
                                                                                                                                                   Class<T> clazz)

releaseElement

public TitanOperationStatus releaseElement(GraphNode node)

Parameters:

node -

Returns:

releaseElement

public TitanOperationStatus releaseElement(String id,
                                           NodeTypeEnum type)

getChild

public <T extends GraphNode> fj.data.Either<org.apache.commons.lang3.tuple.ImmutablePair<T,GraphEdge>,TitanOperationStatus> getChild(String key,
                                                                                                                                     String uniqueId,
                                                                                                                                     GraphEdgeLabels edgeType,
                                                                                                                                     NodeTypeEnum nodeTypeEnum,
                                                                                                                                     Class<T> clazz)

getChildVertex

public org.apache.commons.lang3.tuple.ImmutablePair<com.thinkaurelius.titan.core.TitanVertex,org.apache.tinkerpop.gremlin.structure.Edge> getChildVertex(com.thinkaurelius.titan.core.TitanVertex vertex,
                                                                                                                                                         GraphEdgeLabels edgeType)

getParentNodes

public <T extends GraphNode> fj.data.Either<List<org.apache.commons.lang3.tuple.ImmutablePair<T,GraphEdge>>,TitanOperationStatus> getParentNodes(String key,
                                                                                                                                                 String uniqueId,
                                                                                                                                                 GraphEdgeLabels edgeType,
                                                                                                                                                 NodeTypeEnum nodeTypeEnum,
                                                                                                                                                 Class<T> clazz)

getParentNode

public <T extends GraphNode> fj.data.Either<org.apache.commons.lang3.tuple.ImmutablePair<T,GraphEdge>,TitanOperationStatus> getParentNode(String key,
                                                                                                                                          String uniqueId,
                                                                                                                                          GraphEdgeLabels edgeType,
                                                                                                                                          NodeTypeEnum nodeTypeEnum,
                                                                                                                                          Class<T> clazz)

getChildByEdgeCriteria

public <T extends GraphNode> fj.data.Either<org.apache.commons.lang3.tuple.ImmutablePair<T,GraphEdge>,TitanOperationStatus> getChildByEdgeCriteria(String key,
                                                                                                                                                   String uniqueId,
                                                                                                                                                   GraphEdgeLabels edgeType,
                                                                                                                                                   NodeTypeEnum nodeTypeEnum,
                                                                                                                                                   Class<T> clazz,
                                                                                                                                                   Map<String,Object> edgeProperties)

getChildByEdgeCriteria

public fj.data.Either<org.apache.commons.lang3.tuple.ImmutablePair<com.thinkaurelius.titan.core.TitanVertex,org.apache.tinkerpop.gremlin.structure.Edge>,TitanOperationStatus> getChildByEdgeCriteria(com.thinkaurelius.titan.core.TitanVertex vertex,
                                                                                                                                                                                                      GraphEdgeLabels edgeType,
                                                                                                                                                                                                      Map<String,Object> edgeProperties)

getOutgoingEdgeByCriteria

public fj.data.Either<org.apache.tinkerpop.gremlin.structure.Edge,TitanOperationStatus> getOutgoingEdgeByCriteria(String key,
                                                                                                                  String value,
                                                                                                                  GraphEdgeLabels label,
                                                                                                                  Map<String,Object> props)

getOutgoingEdgeByCriteria

public fj.data.Either<org.apache.tinkerpop.gremlin.structure.Edge,TitanOperationStatus> getOutgoingEdgeByCriteria(com.thinkaurelius.titan.core.TitanVertex vertex,
                                                                                                                  GraphEdgeLabels label,
                                                                                                                  Map<String,Object> props)

deleteChildrenNodes

public <T extends GraphNode> fj.data.Either<List<org.apache.commons.lang3.tuple.ImmutablePair<T,GraphEdge>>,TitanOperationStatus> deleteChildrenNodes(String key,
                                                                                                                                                      String uniqueId,
                                                                                                                                                      GraphEdgeLabels edgeType,
                                                                                                                                                      NodeTypeEnum nodeTypeEnum,
                                                                                                                                                      Class<T> clazz)

setProperties

public void setProperties(org.apache.tinkerpop.gremlin.structure.Element element,
                          Map<String,Object> properties)

getProperties

public Map<String,Object> getProperties(org.apache.tinkerpop.gremlin.structure.Element element)

getProperty

public Object getProperty(com.thinkaurelius.titan.core.TitanVertex vertex,
                          String key)

getProperty

public Object getProperty(org.apache.tinkerpop.gremlin.structure.Edge edge,
                          String key)

getChildrenByEdgeCriteria

public <T extends GraphNode> fj.data.Either<List<org.apache.commons.lang3.tuple.ImmutablePair<T,GraphEdge>>,TitanOperationStatus> getChildrenByEdgeCriteria(org.apache.tinkerpop.gremlin.structure.Vertex vertex,
                                                                                                                                                            String vertexUniqueId,
                                                                                                                                                            GraphEdgeLabels edgeType,
                                                                                                                                                            NodeTypeEnum nodeTypeEnum,
                                                                                                                                                            Class<T> clazz,
                                                                                                                                                            Map<String,Object> edgeProperties)

getOutgoingEdgesByCriteria

public fj.data.Either<List<org.apache.tinkerpop.gremlin.structure.Edge>,TitanOperationStatus> getOutgoingEdgesByCriteria(org.apache.tinkerpop.gremlin.structure.Vertex vertexFrom,
                                                                                                                         GraphEdgeLabels label,
                                                                                                                         Map<String,Object> props)