repository/src/main/java/org/apache/atlas/repository/store/graph/v1/AtlasGraphUtilsV1.java - incubator-atlas - Git at Google

 /**
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package org.apache.atlas.repository.store.graph.v1;


 import org.apache.atlas.AtlasErrorCode;
 import org.apache.atlas.exception.AtlasBaseException;
 import org.apache.atlas.model.TypeCategory;
 import org.apache.atlas.model.instance.AtlasEntity;
 import org.apache.atlas.model.typedef.AtlasBaseTypeDef;
 import org.apache.atlas.repository.Constants;
 import org.apache.atlas.repository.graph.AtlasGraphProvider;
 import org.apache.atlas.repository.graph.GraphHelper;
 import org.apache.atlas.repository.graphdb.AtlasEdge;
 import org.apache.atlas.repository.graphdb.AtlasElement;
 import org.apache.atlas.repository.graphdb.AtlasGraphQuery;
 import org.apache.atlas.repository.graphdb.AtlasVertex;
 import org.apache.atlas.type.AtlasEntityType;
 import org.apache.atlas.type.AtlasStructType;
 import org.apache.atlas.type.AtlasStructType.AtlasAttribute;
 import org.apache.atlas.type.AtlasType;
 import org.apache.commons.collections.MapUtils;
 import org.apache.commons.lang.StringUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 import java.util.Collection;
 import java.util.Date;
 import java.util.Iterator;
 import java.util.Map;

 /**
  * Utility methods for Graph.
  */
 public class AtlasGraphUtilsV1 {
     private static final Logger LOG = LoggerFactory.getLogger(AtlasGraphUtilsV1.class);

     public static final String PROPERTY_PREFIX      = Constants.INTERNAL_PROPERTY_KEY_PREFIX + "type.";
     public static final String SUPERTYPE_EDGE_LABEL = PROPERTY_PREFIX + ".supertype";
     public static final String VERTEX_TYPE          = "typeSystem";
     public static final String RELATIONSHIPTYPE_EDGE_LABEL = PROPERTY_PREFIX + ".relationshipType";


     public static String getTypeDefPropertyKey(AtlasBaseTypeDef typeDef) {
         return getTypeDefPropertyKey(typeDef.getName());
     }

     public static String getTypeDefPropertyKey(AtlasBaseTypeDef typeDef, String child) {
         return getTypeDefPropertyKey(typeDef.getName(), child);
     }

     public static String getTypeDefPropertyKey(String typeName) {
         return PROPERTY_PREFIX + typeName;
     }

     public static String getTypeDefPropertyKey(String typeName, String child) {
         return PROPERTY_PREFIX + typeName + "." + child;
     }

     public static String getIdFromVertex(AtlasVertex vertex) {
         return vertex.getProperty(Constants.GUID_PROPERTY_KEY, String.class);
     }

     public static String getTypeName(AtlasElement element) {
         return element.getProperty(Constants.ENTITY_TYPE_PROPERTY_KEY, String.class);
     }

     public static String getEdgeLabel(String fromNode, String toNode) {
         return PROPERTY_PREFIX + "edge." + fromNode + "." + toNode;
     }

     public static String getEdgeLabel(String property) {
         return GraphHelper.EDGE_LABEL_PREFIX + property;
     }

     public static String getAttributeEdgeLabel(AtlasStructType fromType, String attributeName) throws AtlasBaseException {
         return getEdgeLabel(getQualifiedAttributePropertyKey(fromType, attributeName));
     }

     public static String getQualifiedAttributePropertyKey(AtlasStructType fromType, String attributeName) throws AtlasBaseException {
         switch (fromType.getTypeCategory()) {
          case ENTITY:
          case STRUCT:
          case CLASSIFICATION:
              return fromType.getQualifiedAttributeName(attributeName);
         default:
             throw new AtlasBaseException(AtlasErrorCode.UNKNOWN_TYPE, fromType.getTypeCategory().name());
         }
     }

     public static boolean isEntityVertex(AtlasVertex vertex) {
         return StringUtils.isNotEmpty(getIdFromVertex(vertex)) && StringUtils.isNotEmpty(getTypeName(vertex));
     }

     public static boolean isReference(AtlasType type) {
         return isReference(type.getTypeCategory());
     }

     public static boolean isReference(TypeCategory typeCategory) {
         return typeCategory == TypeCategory.STRUCT ||
             typeCategory == TypeCategory.ENTITY ||
             typeCategory == TypeCategory.CLASSIFICATION ||
             typeCategory == TypeCategory.OBJECT_ID_TYPE;
     }

     public static String encodePropertyKey(String key) {
         String ret = AtlasStructType.AtlasAttribute.encodePropertyKey(key);

         return ret;
     }

     public static String decodePropertyKey(String key) {
         String ret = AtlasStructType.AtlasAttribute.decodePropertyKey(key);

         return ret;
     }

     /**
      * Adds an additional value to a multi-property.
      *
      * @param propertyName
      * @param value
      */
     public static AtlasVertex addProperty(AtlasVertex vertex, String propertyName, Object value) {
         if (LOG.isDebugEnabled()) {
             LOG.debug("==> addProperty({}, {}, {})", toString(vertex), propertyName, value);
         }
         propertyName = encodePropertyKey(propertyName);
         vertex.addProperty(propertyName, value);
         return vertex;
     }

     public static <T extends AtlasElement> void setProperty(T element, String propertyName, Object value) {
         if (LOG.isDebugEnabled()) {
             LOG.debug("==> setProperty({}, {}, {})", toString(element), propertyName, value);
         }

         propertyName = encodePropertyKey(propertyName);

         Object existingValue = element.getProperty(propertyName, Object.class);

         if (value == null || (value instanceof Collection && ((Collection)value).isEmpty())) {
             if (existingValue != null) {
                 if (LOG.isDebugEnabled()) {
                     LOG.debug("Removing property {} from {}", propertyName, toString(element));
                 }

                 element.removeProperty(propertyName);
             }
         } else {
             if (!value.equals(existingValue)) {
                 if (LOG.isDebugEnabled()) {
                     LOG.debug("Setting property {} in {}", propertyName, toString(element));
                 }

                 if ( value instanceof Date) {
                     Long encodedValue = ((Date) value).getTime();
                     element.setProperty(propertyName, encodedValue);
                 } else {
                     element.setProperty(propertyName, value);
                 }
             }
         }
     }

     public static <T extends AtlasElement, O> O getProperty(T element, String propertyName, Class<O> returnType) {
         Object property = element.getProperty(encodePropertyKey(propertyName), returnType);

         if (LOG.isDebugEnabled()) {
             LOG.debug("getProperty({}, {}) ==> {}", toString(element), propertyName, returnType.cast(property));
         }

         return returnType.cast(property);
     }

     public static AtlasVertex getVertexByUniqueAttributes(AtlasEntityType entityType, Map<String, Object> attrValues) throws AtlasBaseException {
         AtlasVertex vertex = findByUniqueAttributes(entityType, attrValues);

         if (vertex == null) {
             throw new AtlasBaseException(AtlasErrorCode.INSTANCE_BY_UNIQUE_ATTRIBUTE_NOT_FOUND, entityType.getTypeName(),
                                          attrValues.toString());
         }

         return vertex;
     }

     public static String getGuidByUniqueAttributes(AtlasEntityType entityType, Map<String, Object> attrValues) throws AtlasBaseException {
         AtlasVertex vertexByUniqueAttributes = getVertexByUniqueAttributes(entityType, attrValues);
         return getIdFromVertex(vertexByUniqueAttributes);
     }

     public static AtlasVertex findByUniqueAttributes(AtlasEntityType entityType, Map<String, Object> attrValues) {
         AtlasVertex vertex = null;

         final Map<String, AtlasAttribute> uniqueAttributes = entityType.getUniqAttributes();

         if (MapUtils.isNotEmpty(uniqueAttributes) && MapUtils.isNotEmpty(attrValues)) {
             for (AtlasAttribute attribute : uniqueAttributes.values()) {
                 Object attrValue = attrValues.get(attribute.getName());

                 if (attrValue == null) {
                     continue;
                 }

                 vertex = AtlasGraphUtilsV1.findByTypeAndPropertyName(entityType.getTypeName(), attribute.getVertexPropertyName(), attrValue);

                 if (vertex == null) {
                     vertex = AtlasGraphUtilsV1.findBySuperTypeAndPropertyName(entityType.getTypeName(), attribute.getVertexPropertyName(), attrValue);
                 }

                 if (vertex != null) {
                     break;
                 }
             }
         }

         return vertex;
     }

     public static AtlasVertex findByGuid(String guid) {
         AtlasGraphQuery query = AtlasGraphProvider.getGraphInstance().query()
                                                   .has(Constants.GUID_PROPERTY_KEY, guid);

         Iterator<AtlasVertex> results = query.vertices().iterator();

         AtlasVertex vertex = results.hasNext() ? results.next() : null;

         return vertex;
     }

     public static String getTypeNameFromGuid(String guid) {
         String ret = null;

         if (StringUtils.isNotEmpty(guid)) {
             AtlasVertex vertex = AtlasGraphUtilsV1.findByGuid(guid);

             ret = (vertex != null) ? AtlasGraphUtilsV1.getTypeName(vertex) : null;
         }

         return ret;
     }

     public static boolean typeHasInstanceVertex(String typeName) throws AtlasBaseException {
         AtlasGraphQuery query = AtlasGraphProvider.getGraphInstance()
                 .query()
                 .has(Constants.TYPE_NAME_PROPERTY_KEY, AtlasGraphQuery.ComparisionOperator.EQUAL, typeName);

         Iterator<AtlasVertex> results = query.vertices().iterator();

         boolean hasInstanceVertex = results != null && results.hasNext();

         if (LOG.isDebugEnabled()) {
             LOG.debug("typeName {} has instance vertex {}", typeName, hasInstanceVertex);
         }

         return hasInstanceVertex;
     }

     public static AtlasVertex findByTypeAndPropertyName(String typeName, String propertyName, Object attrVal) {
         AtlasGraphQuery query = AtlasGraphProvider.getGraphInstance().query()
                                                     .has(Constants.ENTITY_TYPE_PROPERTY_KEY, typeName)
                                                     .has(Constants.STATE_PROPERTY_KEY, AtlasEntity.Status.ACTIVE.name())
                                                     .has(propertyName, attrVal);

         Iterator<AtlasVertex> results = query.vertices().iterator();

         AtlasVertex vertex = results.hasNext() ? results.next() : null;

         return vertex;
     }

     public static AtlasVertex findBySuperTypeAndPropertyName(String typeName, String propertyName, Object attrVal) {
         AtlasGraphQuery query = AtlasGraphProvider.getGraphInstance().query()
                                                     .has(Constants.SUPER_TYPES_PROPERTY_KEY, typeName)
                                                     .has(Constants.STATE_PROPERTY_KEY, AtlasEntity.Status.ACTIVE.name())
                                                     .has(propertyName, attrVal);

         Iterator<AtlasVertex> results = query.vertices().iterator();

         AtlasVertex vertex = results.hasNext() ? results.next() : null;

         return vertex;
     }

     public static boolean relationshipTypeHasInstanceEdges(String typeName) throws AtlasBaseException {
         AtlasGraphQuery query = AtlasGraphProvider.getGraphInstance()
                 .query()
                 .has(Constants.TYPE_NAME_PROPERTY_KEY, AtlasGraphQuery.ComparisionOperator.EQUAL, typeName);

         Iterator<AtlasEdge> results = query.edges().iterator();

         boolean hasInstanceEdges = results != null && results.hasNext();

         if (LOG.isDebugEnabled()) {
             LOG.debug("relationshipType {} has instance edges {}", typeName, hasInstanceEdges);
         }

         return hasInstanceEdges;
     }

     private static String toString(AtlasElement element) {
         if (element instanceof AtlasVertex) {
             return toString((AtlasVertex) element);
         } else if (element instanceof AtlasEdge) {
             return toString((AtlasEdge)element);
         }

         return element.toString();
     }

     public static String toString(AtlasVertex vertex) {
         if(vertex == null) {
             return "vertex[null]";
         } else {
             if (LOG.isDebugEnabled()) {
                 return getVertexDetails(vertex);
             } else {
                 return String.format("vertex[id=%s]", vertex.getId().toString());
             }
         }
     }


     public static String toString(AtlasEdge edge) {
         if(edge == null) {
             return "edge[null]";
         } else {
             if (LOG.isDebugEnabled()) {
                 return getEdgeDetails(edge);
             } else {
                 return String.format("edge[id=%s]", edge.getId().toString());
             }
         }
     }

     public static String getVertexDetails(AtlasVertex vertex) {
         return String.format("vertex[id=%s type=%s guid=%s]",
                 vertex.getId().toString(), getTypeName(vertex), getIdFromVertex(vertex));
     }

     public static String getEdgeDetails(AtlasEdge edge) {
         return String.format("edge[id=%s label=%s from %s -> to %s]", edge.getId(), edge.getLabel(),
                 toString(edge.getOutVertex()), toString(edge.getInVertex()));
     }

     public static AtlasEntity.Status getState(AtlasElement element) {
         String state = getStateAsString(element);
         return state == null ? null : AtlasEntity.Status.valueOf(state);
     }

     public static String getStateAsString(AtlasElement element) {
         return element.getProperty(Constants.STATE_PROPERTY_KEY, String.class);
     }
 }
	/**
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package org.apache.atlas.repository.store.graph.v1;


	import org.apache.atlas.AtlasErrorCode;
	import org.apache.atlas.exception.AtlasBaseException;
	import org.apache.atlas.model.TypeCategory;
	import org.apache.atlas.model.instance.AtlasEntity;
	import org.apache.atlas.model.typedef.AtlasBaseTypeDef;
	import org.apache.atlas.repository.Constants;
	import org.apache.atlas.repository.graph.AtlasGraphProvider;
	import org.apache.atlas.repository.graph.GraphHelper;
	import org.apache.atlas.repository.graphdb.AtlasEdge;
	import org.apache.atlas.repository.graphdb.AtlasElement;
	import org.apache.atlas.repository.graphdb.AtlasGraphQuery;
	import org.apache.atlas.repository.graphdb.AtlasVertex;
	import org.apache.atlas.type.AtlasEntityType;
	import org.apache.atlas.type.AtlasStructType;
	import org.apache.atlas.type.AtlasStructType.AtlasAttribute;
	import org.apache.atlas.type.AtlasType;
	import org.apache.commons.collections.MapUtils;
	import org.apache.commons.lang.StringUtils;
	import org.slf4j.Logger;
	import org.slf4j.LoggerFactory;

	import java.util.Collection;
	import java.util.Date;
	import java.util.Iterator;
	import java.util.Map;

	/**
	* Utility methods for Graph.
	*/
	public class AtlasGraphUtilsV1 {
	private static final Logger LOG = LoggerFactory.getLogger(AtlasGraphUtilsV1.class);

	public static final String PROPERTY_PREFIX = Constants.INTERNAL_PROPERTY_KEY_PREFIX + "type.";
	public static final String SUPERTYPE_EDGE_LABEL = PROPERTY_PREFIX + ".supertype";
	public static final String VERTEX_TYPE = "typeSystem";
	public static final String RELATIONSHIPTYPE_EDGE_LABEL = PROPERTY_PREFIX + ".relationshipType";


	public static String getTypeDefPropertyKey(AtlasBaseTypeDef typeDef) {
	return getTypeDefPropertyKey(typeDef.getName());
	}

	public static String getTypeDefPropertyKey(AtlasBaseTypeDef typeDef, String child) {
	return getTypeDefPropertyKey(typeDef.getName(), child);
	}

	public static String getTypeDefPropertyKey(String typeName) {
	return PROPERTY_PREFIX + typeName;
	}

	public static String getTypeDefPropertyKey(String typeName, String child) {
	return PROPERTY_PREFIX + typeName + "." + child;
	}

	public static String getIdFromVertex(AtlasVertex vertex) {
	return vertex.getProperty(Constants.GUID_PROPERTY_KEY, String.class);
	}

	public static String getTypeName(AtlasElement element) {
	return element.getProperty(Constants.ENTITY_TYPE_PROPERTY_KEY, String.class);
	}

	public static String getEdgeLabel(String fromNode, String toNode) {
	return PROPERTY_PREFIX + "edge." + fromNode + "." + toNode;
	}

	public static String getEdgeLabel(String property) {
	return GraphHelper.EDGE_LABEL_PREFIX + property;
	}

	public static String getAttributeEdgeLabel(AtlasStructType fromType, String attributeName) throws AtlasBaseException {
	return getEdgeLabel(getQualifiedAttributePropertyKey(fromType, attributeName));
	}

	public static String getQualifiedAttributePropertyKey(AtlasStructType fromType, String attributeName) throws AtlasBaseException {
	switch (fromType.getTypeCategory()) {
	case ENTITY:
	case STRUCT:
	case CLASSIFICATION:
	return fromType.getQualifiedAttributeName(attributeName);
	default:
	throw new AtlasBaseException(AtlasErrorCode.UNKNOWN_TYPE, fromType.getTypeCategory().name());
	}
	}

	public static boolean isEntityVertex(AtlasVertex vertex) {
	return StringUtils.isNotEmpty(getIdFromVertex(vertex)) && StringUtils.isNotEmpty(getTypeName(vertex));
	}

	public static boolean isReference(AtlasType type) {
	return isReference(type.getTypeCategory());
	}

	public static boolean isReference(TypeCategory typeCategory) {
	return typeCategory == TypeCategory.STRUCT \|\|
	typeCategory == TypeCategory.ENTITY \|\|
	typeCategory == TypeCategory.CLASSIFICATION \|\|
	typeCategory == TypeCategory.OBJECT_ID_TYPE;
	}

	public static String encodePropertyKey(String key) {
	String ret = AtlasStructType.AtlasAttribute.encodePropertyKey(key);

	return ret;
	}

	public static String decodePropertyKey(String key) {
	String ret = AtlasStructType.AtlasAttribute.decodePropertyKey(key);

	return ret;
	}

	/**
	* Adds an additional value to a multi-property.
	*
	* @param propertyName
	* @param value
	*/
	public static AtlasVertex addProperty(AtlasVertex vertex, String propertyName, Object value) {
	if (LOG.isDebugEnabled()) {
	LOG.debug("==> addProperty({}, {}, {})", toString(vertex), propertyName, value);
	}
	propertyName = encodePropertyKey(propertyName);
	vertex.addProperty(propertyName, value);
	return vertex;
	}

	public static <T extends AtlasElement> void setProperty(T element, String propertyName, Object value) {
	if (LOG.isDebugEnabled()) {
	LOG.debug("==> setProperty({}, {}, {})", toString(element), propertyName, value);
	}

	propertyName = encodePropertyKey(propertyName);

	Object existingValue = element.getProperty(propertyName, Object.class);

	if (value == null \|\| (value instanceof Collection && ((Collection)value).isEmpty())) {
	if (existingValue != null) {
	if (LOG.isDebugEnabled()) {
	LOG.debug("Removing property {} from {}", propertyName, toString(element));
	}

	element.removeProperty(propertyName);
	}
	} else {
	if (!value.equals(existingValue)) {
	if (LOG.isDebugEnabled()) {
	LOG.debug("Setting property {} in {}", propertyName, toString(element));
	}

	if ( value instanceof Date) {
	Long encodedValue = ((Date) value).getTime();
	element.setProperty(propertyName, encodedValue);
	} else {
	element.setProperty(propertyName, value);
	}
	}
	}
	}

	public static <T extends AtlasElement, O> O getProperty(T element, String propertyName, Class<O> returnType) {
	Object property = element.getProperty(encodePropertyKey(propertyName), returnType);

	if (LOG.isDebugEnabled()) {
	LOG.debug("getProperty({}, {}) ==> {}", toString(element), propertyName, returnType.cast(property));
	}

	return returnType.cast(property);
	}

	public static AtlasVertex getVertexByUniqueAttributes(AtlasEntityType entityType, Map<String, Object> attrValues) throws AtlasBaseException {
	AtlasVertex vertex = findByUniqueAttributes(entityType, attrValues);

	if (vertex == null) {
	throw new AtlasBaseException(AtlasErrorCode.INSTANCE_BY_UNIQUE_ATTRIBUTE_NOT_FOUND, entityType.getTypeName(),
	attrValues.toString());
	}

	return vertex;
	}

	public static String getGuidByUniqueAttributes(AtlasEntityType entityType, Map<String, Object> attrValues) throws AtlasBaseException {
	AtlasVertex vertexByUniqueAttributes = getVertexByUniqueAttributes(entityType, attrValues);
	return getIdFromVertex(vertexByUniqueAttributes);
	}

	public static AtlasVertex findByUniqueAttributes(AtlasEntityType entityType, Map<String, Object> attrValues) {
	AtlasVertex vertex = null;

	final Map<String, AtlasAttribute> uniqueAttributes = entityType.getUniqAttributes();

	if (MapUtils.isNotEmpty(uniqueAttributes) && MapUtils.isNotEmpty(attrValues)) {
	for (AtlasAttribute attribute : uniqueAttributes.values()) {
	Object attrValue = attrValues.get(attribute.getName());

	if (attrValue == null) {
	continue;
	}

	vertex = AtlasGraphUtilsV1.findByTypeAndPropertyName(entityType.getTypeName(), attribute.getVertexPropertyName(), attrValue);

	if (vertex == null) {
	vertex = AtlasGraphUtilsV1.findBySuperTypeAndPropertyName(entityType.getTypeName(), attribute.getVertexPropertyName(), attrValue);
	}

	if (vertex != null) {
	break;
	}
	}
	}

	return vertex;
	}

	public static AtlasVertex findByGuid(String guid) {
	AtlasGraphQuery query = AtlasGraphProvider.getGraphInstance().query()
	.has(Constants.GUID_PROPERTY_KEY, guid);

	Iterator<AtlasVertex> results = query.vertices().iterator();

	AtlasVertex vertex = results.hasNext() ? results.next() : null;

	return vertex;
	}

	public static String getTypeNameFromGuid(String guid) {
	String ret = null;

	if (StringUtils.isNotEmpty(guid)) {
	AtlasVertex vertex = AtlasGraphUtilsV1.findByGuid(guid);

	ret = (vertex != null) ? AtlasGraphUtilsV1.getTypeName(vertex) : null;
	}

	return ret;
	}

	public static boolean typeHasInstanceVertex(String typeName) throws AtlasBaseException {
	AtlasGraphQuery query = AtlasGraphProvider.getGraphInstance()
	.query()
	.has(Constants.TYPE_NAME_PROPERTY_KEY, AtlasGraphQuery.ComparisionOperator.EQUAL, typeName);

	Iterator<AtlasVertex> results = query.vertices().iterator();

	boolean hasInstanceVertex = results != null && results.hasNext();

	if (LOG.isDebugEnabled()) {
	LOG.debug("typeName {} has instance vertex {}", typeName, hasInstanceVertex);
	}

	return hasInstanceVertex;
	}

	public static AtlasVertex findByTypeAndPropertyName(String typeName, String propertyName, Object attrVal) {
	AtlasGraphQuery query = AtlasGraphProvider.getGraphInstance().query()
	.has(Constants.ENTITY_TYPE_PROPERTY_KEY, typeName)
	.has(Constants.STATE_PROPERTY_KEY, AtlasEntity.Status.ACTIVE.name())
	.has(propertyName, attrVal);

	Iterator<AtlasVertex> results = query.vertices().iterator();

	AtlasVertex vertex = results.hasNext() ? results.next() : null;

	return vertex;
	}

	public static AtlasVertex findBySuperTypeAndPropertyName(String typeName, String propertyName, Object attrVal) {
	AtlasGraphQuery query = AtlasGraphProvider.getGraphInstance().query()
	.has(Constants.SUPER_TYPES_PROPERTY_KEY, typeName)
	.has(Constants.STATE_PROPERTY_KEY, AtlasEntity.Status.ACTIVE.name())
	.has(propertyName, attrVal);

	Iterator<AtlasVertex> results = query.vertices().iterator();

	AtlasVertex vertex = results.hasNext() ? results.next() : null;

	return vertex;
	}

	public static boolean relationshipTypeHasInstanceEdges(String typeName) throws AtlasBaseException {
	AtlasGraphQuery query = AtlasGraphProvider.getGraphInstance()
	.query()
	.has(Constants.TYPE_NAME_PROPERTY_KEY, AtlasGraphQuery.ComparisionOperator.EQUAL, typeName);

	Iterator<AtlasEdge> results = query.edges().iterator();

	boolean hasInstanceEdges = results != null && results.hasNext();

	if (LOG.isDebugEnabled()) {
	LOG.debug("relationshipType {} has instance edges {}", typeName, hasInstanceEdges);
	}

	return hasInstanceEdges;
	}

	private static String toString(AtlasElement element) {
	if (element instanceof AtlasVertex) {
	return toString((AtlasVertex) element);
	} else if (element instanceof AtlasEdge) {
	return toString((AtlasEdge)element);
	}

	return element.toString();
	}

	public static String toString(AtlasVertex vertex) {
	if(vertex == null) {
	return "vertex[null]";
	} else {
	if (LOG.isDebugEnabled()) {
	return getVertexDetails(vertex);
	} else {
	return String.format("vertex[id=%s]", vertex.getId().toString());
	}
	}
	}


	public static String toString(AtlasEdge edge) {
	if(edge == null) {
	return "edge[null]";
	} else {
	if (LOG.isDebugEnabled()) {
	return getEdgeDetails(edge);
	} else {
	return String.format("edge[id=%s]", edge.getId().toString());
	}
	}
	}

	public static String getVertexDetails(AtlasVertex vertex) {
	return String.format("vertex[id=%s type=%s guid=%s]",
	vertex.getId().toString(), getTypeName(vertex), getIdFromVertex(vertex));
	}

	public static String getEdgeDetails(AtlasEdge edge) {
	return String.format("edge[id=%s label=%s from %s -> to %s]", edge.getId(), edge.getLabel(),
	toString(edge.getOutVertex()), toString(edge.getInVertex()));
	}

	public static AtlasEntity.Status getState(AtlasElement element) {
	String state = getStateAsString(element);
	return state == null ? null : AtlasEntity.Status.valueOf(state);
	}

	public static String getStateAsString(AtlasElement element) {
	return element.getProperty(Constants.STATE_PROPERTY_KEY, String.class);
	}
	}