Examples with AtlasType org.apache.atlas.type.AtlasType used on opensource projects

Example 6 with AtlasType

use of org.apache.atlas.type.AtlasType in project atlas by apache.

the class DeleteHandlerV1 method getOwnedVertices.

/**
 * Get the GUIDs and vertices for all composite entities owned/contained by the specified root entity AtlasVertex.
 * The graph is traversed from the root entity through to the leaf nodes of the containment graph.
 *
 * @param entityVertex the root entity vertex
 * @return set of VertexInfo for all composite entities
 * @throws AtlasException
 */
public Collection<GraphHelper.VertexInfo> getOwnedVertices(AtlasVertex entityVertex) throws AtlasBaseException {
    Map<String, GraphHelper.VertexInfo> vertexInfoMap = new HashMap<>();
    Stack<AtlasVertex> vertices = new Stack<>();
    vertices.push(entityVertex);
    while (vertices.size() > 0) {
        AtlasVertex vertex = vertices.pop();
        AtlasEntity.Status state = getState(vertex);
        if (state == DELETED) {
            // If the reference vertex is marked for deletion, skip it
            continue;
        }
        String guid = GraphHelper.getGuid(vertex);
        if (vertexInfoMap.containsKey(guid)) {
            continue;
        }
        AtlasObjectId entity = entityRetriever.toAtlasObjectId(vertex);
        String typeName = entity.getTypeName();
        AtlasEntityType entityType = typeRegistry.getEntityTypeByName(typeName);
        if (entityType == null) {
            throw new AtlasBaseException(AtlasErrorCode.TYPE_NAME_INVALID, TypeCategory.ENTITY.name(), typeName);
        }
        vertexInfoMap.put(guid, new GraphHelper.VertexInfo(entity, vertex));
        for (AtlasStructType.AtlasAttribute attributeInfo : entityType.getAllAttributes().values()) {
            if (!attributeInfo.isOwnedRef()) {
                continue;
            }
            String edgeLabel = AtlasGraphUtilsV1.getAttributeEdgeLabel(entityType, attributeInfo.getName());
            AtlasType attrType = attributeInfo.getAttributeType();
            switch(attrType.getTypeCategory()) {
                case OBJECT_ID_TYPE:
                    {
                        AtlasEdge edge = graphHelper.getEdgeForLabel(vertex, edgeLabel);
                        if (edge != null && getState(edge) == AtlasEntity.Status.ACTIVE) {
                            vertices.push(edge.getInVertex());
                        }
                    }
                    break;
                case ARRAY:
                    {
                        AtlasArrayType arrType = (AtlasArrayType) attrType;
                        if (arrType.getElementType().getTypeCategory() != TypeCategory.OBJECT_ID_TYPE) {
                            continue;
                        }
                        Iterator<AtlasEdge> edges = graphHelper.getOutGoingEdgesByLabel(vertex, edgeLabel);
                        if (edges != null) {
                            while (edges.hasNext()) {
                                AtlasEdge edge = edges.next();
                                if (edge != null && getState(edge) == AtlasEntity.Status.ACTIVE) {
                                    vertices.push(edge.getInVertex());
                                }
                            }
                        }
                    }
                    break;
                case MAP:
                    {
                        AtlasMapType mapType = (AtlasMapType) attrType;
                        TypeCategory valueTypeCategory = mapType.getValueType().getTypeCategory();
                        if (valueTypeCategory != TypeCategory.OBJECT_ID_TYPE) {
                            continue;
                        }
                        String propertyName = AtlasGraphUtilsV1.getQualifiedAttributePropertyKey(entityType, attributeInfo.getName());
                        List<String> keys = vertex.getProperty(propertyName, List.class);
                        if (keys != null) {
                            for (String key : keys) {
                                String mapEdgeLabel = GraphHelper.getQualifiedNameForMapKey(edgeLabel, key);
                                AtlasEdge edge = graphHelper.getEdgeForLabel(vertex, mapEdgeLabel);
                                if (edge != null && getState(edge) == AtlasEntity.Status.ACTIVE) {
                                    vertices.push(edge.getInVertex());
                                }
                            }
                        }
                    }
                    break;
            }
        }
    }
    return vertexInfoMap.values();
}

Example 7 with AtlasType

use of org.apache.atlas.type.AtlasType in project atlas by apache.

the class DeleteHandlerV1 method deleteEdge.

protected void deleteEdge(AtlasEdge edge, boolean updateInverseAttribute, boolean force) throws AtlasBaseException {
    // update inverse attribute
    if (updateInverseAttribute) {
        AtlasEdgeLabel atlasEdgeLabel = new AtlasEdgeLabel(edge.getLabel());
        AtlasType parentType = typeRegistry.getType(atlasEdgeLabel.getTypeName());
        if (parentType instanceof AtlasEntityType) {
            AtlasEntityType parentEntityType = (AtlasEntityType) parentType;
            AtlasStructType.AtlasAttribute attribute = parentEntityType.getAttribute(atlasEdgeLabel.getAttributeName());
            if (attribute.getInverseRefAttribute() != null) {
                deleteEdgeBetweenVertices(edge.getInVertex(), edge.getOutVertex(), attribute.getInverseRefAttribute());
            }
        }
    }
    deleteEdge(edge, force);
}

Example 8 with AtlasType

use of org.apache.atlas.type.AtlasType in project atlas by apache.

the class DeleteHandlerV1 method deleteEdgeBetweenVertices.

/**
 * Deletes the edge between outvertex and inVertex. The edge is for attribute attributeName of outVertex
 * @param outVertex
 * @param inVertex
 * @param attribute
 * @throws AtlasException
 */
protected void deleteEdgeBetweenVertices(AtlasVertex outVertex, AtlasVertex inVertex, AtlasAttribute attribute) throws AtlasBaseException {
    if (LOG.isDebugEnabled()) {
        LOG.debug("Removing edge from {} to {} with attribute name {}", string(outVertex), string(inVertex), attribute.getName());
    }
    final String typeName = GraphHelper.getTypeName(outVertex);
    final String outId = GraphHelper.getGuid(outVertex);
    final AtlasEntity.Status state = getState(outVertex);
    if (state == DELETED || (outId != null && RequestContextV1.get().isDeletedEntity(outId))) {
        // If the reference vertex is marked for deletion, skip updating the reference
        return;
    }
    AtlasStructType parentType = (AtlasStructType) typeRegistry.getType(typeName);
    String propertyName = AtlasGraphUtilsV1.getQualifiedAttributePropertyKey(parentType, attribute.getName());
    String edgeLabel = EDGE_LABEL_PREFIX + propertyName;
    AtlasEdge edge = null;
    AtlasAttributeDef attrDef = attribute.getAttributeDef();
    AtlasType attrType = attribute.getAttributeType();
    switch(attrType.getTypeCategory()) {
        case OBJECT_ID_TYPE:
            {
                // If its class attribute, its the only edge between two vertices
                if (attrDef.getIsOptional()) {
                    edge = graphHelper.getEdgeForLabel(outVertex, edgeLabel);
                    if (shouldUpdateInverseReferences) {
                        GraphHelper.setProperty(outVertex, propertyName, null);
                    }
                } else {
                    // Cannot unset a required attribute.
                    throw new AtlasBaseException("Cannot unset required attribute " + propertyName + " on " + GraphHelper.vertexString(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 = GraphHelper.getListProperty(outVertex, propertyName);
                if (elements != null) {
                    // Make a copy, else list.remove reflects on titan.getProperty()
                    elements = new ArrayList<>(elements);
                    for (String elementEdgeId : elements) {
                        AtlasEdge elementEdge = graphHelper.getEdgeByEdgeId(outVertex, edgeLabel, elementEdgeId);
                        if (elementEdge == null) {
                            continue;
                        }
                        AtlasVertex elementVertex = elementEdge.getInVertex();
                        if (elementVertex.equals(inVertex)) {
                            edge = elementEdge;
                            // TODO element.size includes deleted items as well. should exclude
                            if (!attrDef.getIsOptional() && elements.size() <= attrDef.getValuesMinCount()) {
                                // Deleting this edge would violate the attribute's lower bound.
                                throw new AtlasBaseException("Cannot remove array element from required attribute " + propertyName + " on " + GraphHelper.getVertexDetails(outVertex) + " " + GraphHelper.getEdgeDetails(elementEdge));
                            }
                            if (shouldUpdateInverseReferences) {
                                // but when column is deleted, table will not reference the deleted column
                                if (LOG.isDebugEnabled()) {
                                    LOG.debug("Removing edge {} from the array attribute {}", string(elementEdge), attribute.getName());
                                }
                                // Remove all occurrences of the edge ID from the list.
                                // This prevents dangling edge IDs (i.e. edge IDs for deleted edges)
                                // from the remaining in the list if there are duplicates.
                                elements.removeAll(Collections.singletonList(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 = GraphHelper.getListProperty(outVertex, propertyName);
                if (keys != null) {
                    // Make a copy, else list.remove reflects on titan.getProperty()
                    keys = new ArrayList<>(keys);
                    for (String key : keys) {
                        String keyPropertyName = GraphHelper.getQualifiedNameForMapKey(propertyName, key);
                        String mapEdgeId = GraphHelper.getSingleValuedProperty(outVertex, keyPropertyName, String.class);
                        AtlasEdge mapEdge = graphHelper.getEdgeByEdgeId(outVertex, keyPropertyName, mapEdgeId);
                        if (mapEdge != null) {
                            AtlasVertex mapVertex = mapEdge.getInVertex();
                            if (mapVertex.getId().toString().equals(inVertex.getId().toString())) {
                                // TODO keys.size includes deleted items as well. should exclude
                                if (attrDef.getIsOptional() || keys.size() > attrDef.getValuesMinCount()) {
                                    edge = mapEdge;
                                } else {
                                    // Deleting this entry would violate the attribute's lower bound.
                                    throw new AtlasBaseException("Cannot remove map entry " + keyPropertyName + " from required attribute " + propertyName + " on " + GraphHelper.getVertexDetails(outVertex) + " " + GraphHelper.getEdgeDetails(mapEdge));
                                }
                                if (shouldUpdateInverseReferences) {
                                    // remove this key
                                    if (LOG.isDebugEnabled()) {
                                        LOG.debug("Removing edge {}, key {} from the map attribute {}", string(mapEdge), key, attribute.getName());
                                    }
                                    keys.remove(key);
                                    GraphHelper.setProperty(outVertex, propertyName, keys);
                                    GraphHelper.setProperty(outVertex, keyPropertyName, null);
                                }
                                break;
                            }
                        }
                    }
                }
            }
            break;
        case STRUCT:
        case CLASSIFICATION:
            break;
        default:
            throw new IllegalStateException("There can't be an edge from " + GraphHelper.getVertexDetails(outVertex) + " to " + GraphHelper.getVertexDetails(inVertex) + " with attribute name " + attribute.getName() + " which is not class/array/map attribute. found " + attrType.getTypeCategory().name());
    }
    if (edge != null) {
        deleteEdge(edge, false);
        RequestContextV1 requestContext = RequestContextV1.get();
        if (!requestContext.isUpdatedEntity(outId)) {
            GraphHelper.setProperty(outVertex, Constants.MODIFICATION_TIMESTAMP_PROPERTY_KEY, requestContext.getRequestTime());
            GraphHelper.setProperty(outVertex, Constants.MODIFIED_BY_KEY, requestContext.getUser());
            requestContext.recordEntityUpdate(entityRetriever.toAtlasObjectId(outVertex));
        }
    }
}

Example 9 with AtlasType

use of org.apache.atlas.type.AtlasType in project atlas by apache.

the class EntityGraphRetriever method mapVertexToAttribute.

private Object mapVertexToAttribute(AtlasVertex entityVertex, AtlasAttribute attribute, AtlasEntityExtInfo entityExtInfo) throws AtlasBaseException {
    Object ret = null;
    AtlasType attrType = attribute.getAttributeType();
    String vertexPropertyName = attribute.getQualifiedName();
    String edgeLabel = EDGE_LABEL_PREFIX + vertexPropertyName;
    boolean isOwnedAttribute = attribute.isOwnedRef();
    AtlasRelationshipEdgeDirection edgeDirection = attribute.getRelationshipEdgeDirection();
    if (LOG.isDebugEnabled()) {
        LOG.debug("Mapping vertex {} to atlas entity {}.{}", entityVertex, attribute.getDefinedInDef().getName(), attribute.getName());
    }
    switch(attrType.getTypeCategory()) {
        case PRIMITIVE:
            ret = mapVertexToPrimitive(entityVertex, vertexPropertyName, attribute.getAttributeDef());
            break;
        case ENUM:
            ret = GraphHelper.getProperty(entityVertex, vertexPropertyName);
            break;
        case STRUCT:
            ret = mapVertexToStruct(entityVertex, edgeLabel, null, entityExtInfo);
            break;
        case OBJECT_ID_TYPE:
            ret = mapVertexToObjectId(entityVertex, edgeLabel, null, entityExtInfo, isOwnedAttribute, edgeDirection);
            break;
        case ARRAY:
            ret = mapVertexToArray(entityVertex, (AtlasArrayType) attrType, vertexPropertyName, entityExtInfo, isOwnedAttribute, edgeDirection);
            break;
        case MAP:
            ret = mapVertexToMap(entityVertex, (AtlasMapType) attrType, vertexPropertyName, entityExtInfo, isOwnedAttribute, edgeDirection);
            break;
        case CLASSIFICATION:
            // do nothing
            break;
    }
    return ret;
}

Example 10 with AtlasType

use of org.apache.atlas.type.AtlasType in project atlas by apache.

the class EntityGraphRetriever method mapAttributes.

private void mapAttributes(AtlasVertex entityVertex, AtlasStruct struct, AtlasEntityExtInfo entityExtInfo) throws AtlasBaseException {
    AtlasType objType = typeRegistry.getType(struct.getTypeName());
    if (!(objType instanceof AtlasStructType)) {
        throw new AtlasBaseException(AtlasErrorCode.TYPE_NAME_INVALID, struct.getTypeName());
    }
    AtlasStructType structType = (AtlasStructType) objType;
    for (AtlasAttribute attribute : structType.getAllAttributes().values()) {
        Object attrValue = mapVertexToAttribute(entityVertex, attribute, entityExtInfo);
        struct.setAttribute(attribute.getName(), attrValue);
    }
}