org.janusgraph.core.PropertyKey Java Examples

public AtlasJanusGraph(JanusGraph graphInstance) {
    //determine multi-properties once at startup
    JanusGraphManagement mgmt = null;

    try {
        mgmt = graphInstance.openManagement();

        Iterable<PropertyKey> keys = mgmt.getRelationTypes(PropertyKey.class);

        for (PropertyKey key : keys) {
            if (key.cardinality() != Cardinality.SINGLE) {
                multiProperties.add(key.name());
            }
        }
    } finally {
        if (mgmt != null) {
            mgmt.rollback();
        }
    }

    janusGraph = (StandardJanusGraph) graphInstance;
}
 

@Override
public String addMixedIndex(String indexName, AtlasPropertyKey propertyKey, boolean isStringField) {
    PropertyKey     janusKey        = AtlasJanusObjectFactory.createPropertyKey(propertyKey);
    JanusGraphIndex janusGraphIndex = management.getGraphIndex(indexName);

    if(isStringField) {
        management.addIndexKey(janusGraphIndex, janusKey, Mapping.STRING.asParameter());
        LOG.debug("created a string type for {} with janueKey {}.", propertyKey.getName(), janusKey);
    } else {
        management.addIndexKey(janusGraphIndex, janusKey);
        LOG.debug("created a default type for {} with janueKey {}.", propertyKey.getName(), janusKey);
    }

    String encodedName = "";
    if(isStringField) {
        encodedName = graph.getIndexFieldName(propertyKey, janusGraphIndex, STRING_PARAMETER_ARRAY);
    } else {
        encodedName = graph.getIndexFieldName(propertyKey, janusGraphIndex);
    }


    LOG.info("property '{}' is encoded to '{}'.", propertyKey.getName(), encodedName);

    return encodedName;
}
 

@Override
public AtlasPropertyKey makePropertyKey(String propertyName, Class propertyClass, AtlasCardinality cardinality) {
    if (cardinality.isMany()) {
        newMultProperties.add(propertyName);
    }

    PropertyKeyMaker propertyKeyBuilder = management.makePropertyKey(propertyName).dataType(propertyClass);
    if (cardinality != null) {
        Cardinality janusCardinality = AtlasJanusObjectFactory.createCardinality(cardinality);
        propertyKeyBuilder.cardinality(janusCardinality);
    }

    PropertyKey propertyKey = propertyKeyBuilder.make();

    return GraphDbObjectFactory.createPropertyKey(propertyKey);
}
 

private PropertyKey getOrCreatePropertyKey(JanusGraphManagement janusGraphManagement, String key, Class<?> dataType, Cardinality cardinality)
{
    PropertyKey propertyKey = janusGraphManagement.getPropertyKey(key);
    if (propertyKey == null)
    {
        propertyKey = janusGraphManagement.makePropertyKey(key).dataType(dataType).cardinality(cardinality).make();
    }
    return propertyKey;
}
 

private void createIndex(JanusGraphManagement management,
                         String indexName,
                         String propertyName,
                         String propertyKeyName,
                         boolean unique,
                         Class type) {

    String className = immutableCorePropertyTypes.get(propertyName);

    Class clazz;
    try {
        clazz = Class.forName(className);
    } catch (ClassNotFoundException e) {
        log.error("class not found for property {}", propertyName);
        log.error("NO INDEX created for property {}", propertyName);
        return;
    }

    PropertyKey propertyKey;
    boolean oldKey = false;
    PropertyKey existingPropertyKey = management.getPropertyKey(propertyKeyName);
    if (existingPropertyKey != null) {
        log.debug("property key already exists for property {}", propertyKeyName);
        propertyKey = existingPropertyKey;
        oldKey = true;
    } else {
        log.debug("make property key for property {}", propertyKeyName);
        propertyKey = management.makePropertyKey(propertyKeyName).dataType(clazz).make();
    }

    buildIndex(management,indexName,propertyKey,unique,oldKey,type);

}
 

private static void createHotelSchema(final JanusGraph graph) {
    //another issue, you should only try to create the schema once.
    //you use uniqueness constraints, so you need to define the schema up front with the unique() call,
    //but if you did not use uniqueness constraints, you could just let JanusGraph create the schema for you.
    final JanusGraphManagement mgmt = graph.openManagement();
    final PropertyKey brandtypePropertyKey = mgmt.makePropertyKey("brandtype").dataType(String.class).make();
    mgmt.buildIndex("brandtypeIndex", Vertex.class).addKey(brandtypePropertyKey).unique().buildCompositeIndex();
    final PropertyKey namePropertyKey = mgmt.makePropertyKey("name").dataType(String.class).make();
    mgmt.buildIndex("nameIndex", Vertex.class).addKey(namePropertyKey).unique().buildCompositeIndex();
    mgmt.makeEdgeLabel(Relationship.hotelBrandType.name()).multiplicity(Multiplicity.MANY2ONE).make();
    mgmt.makeEdgeLabel(Relationship.instanceOf.name()).multiplicity(Multiplicity.MANY2ONE).make();
    mgmt.commit();
}
 

/**
 * Create both <i>posts</i> and <i>follows</i> edges and related index.
 * <br/>
 *
 * Because the property and index for both follows and posts is the same we create them at the same point here.
 */
private void createWeightIndex() {
  LOGGER.info("create weight index");
  EdgeLabel follows = mgt.getEdgeLabel(Schema.FOLLOWS);
  PropertyKey weight = mgt.makePropertyKey(WEIGHT).dataType(Float.class).make();

  mgt.buildIndex(Schema.indexName(Schema.FOLLOWS, WEIGHT), Edge.class).
      addKey(weight).
      indexOnly(follows).
      buildMixedIndex(Schema.BACKING_INDEX);
}
 

String getIndexFieldName(AtlasPropertyKey propertyKey, JanusGraphIndex graphIndex, Parameter ... parameters) {
    PropertyKey janusKey = AtlasJanusObjectFactory.createPropertyKey(propertyKey);
    if(parameters == null) {
        parameters = EMPTY_PARAMETER_ARRAY;
    }
    return janusGraph.getIndexSerializer().getDefaultFieldName(janusKey, parameters, graphIndex.getBackingIndex());
}
 

/**
 * @param propertyKey The Gremlin propertyKey.
 *
 */
public static AtlasJanusPropertyKey createPropertyKey(PropertyKey propertyKey) {
    if (propertyKey == null) {
        return null;
    }
    return new AtlasJanusPropertyKey(propertyKey);
}
 

@Override
public void createEdgeCompositeIndex(String propertyName, boolean isUnique, List<AtlasPropertyKey> propertyKeys) {
    IndexBuilder indexBuilder = management.buildIndex(propertyName, Edge.class);

    for (AtlasPropertyKey key : propertyKeys) {
        PropertyKey janusKey = AtlasJanusObjectFactory.createPropertyKey(key);
        indexBuilder.addKey(janusKey);
    }

    if (isUnique) {
        indexBuilder.unique();
    }

    indexBuilder.buildCompositeIndex();
}
 

@Override
public void createVertexCompositeIndex(String propertyName, boolean isUnique, List<AtlasPropertyKey> propertyKeys) {
    IndexBuilder indexBuilder = management.buildIndex(propertyName, Vertex.class);

    for (AtlasPropertyKey key : propertyKeys) {
        PropertyKey janusKey = AtlasJanusObjectFactory.createPropertyKey(key);
        indexBuilder.addKey(janusKey);
    }

    if (isUnique) {
        indexBuilder.unique();
    }

    indexBuilder.buildCompositeIndex();
}
 

@Override
public void deletePropertyKey(String propertyKey) {
    PropertyKey janusPropertyKey = management.getPropertyKey(propertyKey);

    if (null == janusPropertyKey) return;

    for (int i = 0;; i++) {
        String deletedKeyName = janusPropertyKey + "_deleted_" + i;

        if (null == management.getPropertyKey(deletedKeyName)) {
            management.changeName(janusPropertyKey, deletedKeyName);
            break;
        }
    }
}
 

@Override
public void createFullTextMixedIndex(String indexName, String backingIndex, List<AtlasPropertyKey> propertyKeys) {
    IndexBuilder indexBuilder = management.buildIndex(indexName, Vertex.class);

    for (AtlasPropertyKey key : propertyKeys) {
        PropertyKey janusKey = AtlasJanusObjectFactory.createPropertyKey(key);
        indexBuilder.addKey(janusKey, org.janusgraph.core.schema.Parameter.of("mapping", Mapping.TEXT));
    }

    indexBuilder.buildMixedIndex(backingIndex);
}
 

@Override
public void createEdgeIndex(String label, String indexName, AtlasEdgeDirection edgeDirection, List<AtlasPropertyKey> propertyKeys) {
    EdgeLabel edgeLabel = management.getEdgeLabel(label);

    if (edgeLabel == null) {
        edgeLabel = management.makeEdgeLabel(label).make();
    }

    Direction     direction = AtlasJanusObjectFactory.createDirection(edgeDirection);
    PropertyKey[] keys      = AtlasJanusObjectFactory.createPropertyKeys(propertyKeys);

    if (management.getRelationIndex(edgeLabel, indexName) == null) {
        management.buildEdgeIndex(edgeLabel, indexName, direction, keys);
    }
}
 

@Override
public void createEdgeMixedIndex(String indexName, String backingIndex, List<AtlasPropertyKey> propertyKeys) {
    IndexBuilder indexBuilder = management.buildIndex(indexName, Edge.class);

    for (AtlasPropertyKey key : propertyKeys) {
        PropertyKey janusKey = AtlasJanusObjectFactory.createPropertyKey(key);
        indexBuilder.addKey(janusKey);
    }

    indexBuilder.buildMixedIndex(backingIndex);
}
 

@Override
public void createVertexMixedIndex(String indexName, String backingIndex, List<AtlasPropertyKey> propertyKeys) {
    IndexBuilder indexBuilder = management.buildIndex(indexName, Vertex.class);

    for (AtlasPropertyKey key : propertyKeys) {
        PropertyKey janusKey = AtlasJanusObjectFactory.createPropertyKey(key);
        indexBuilder.addKey(janusKey);
    }

    indexBuilder.buildMixedIndex(backingIndex);
}
 

public static PropertyKey[] createPropertyKeys(List<AtlasPropertyKey> keys) {
    PropertyKey[] ret = new PropertyKey[keys.size()];

    int i = 0;
    for (AtlasPropertyKey key : keys) {
        ret[i] = createPropertyKey(key);

        i++;
    }

    return ret;
}
 

@Override
public Set<AtlasPropertyKey> getFieldKeys() {
    PropertyKey[] keys = wrapped.getFieldKeys();
    Set<AtlasPropertyKey> result = new HashSet<AtlasPropertyKey>();
    for(PropertyKey key  : keys) {
        result.add(GraphDbObjectFactory.createPropertyKey(key));
    }
    return result;
}
 

public static PropertyKey createPropertyKey(AtlasPropertyKey key) {
    return ((AtlasJanusPropertyKey)key).getWrappedPropertyKey();
}
 

/**
 * @return
 */
public PropertyKey getWrappedPropertyKey() {
    return wrapped;
}
 

public AtlasJanusPropertyKey(PropertyKey toWrap) {
    wrapped = toWrap;
}
 

private boolean createControlIndex() {

        final String methodName = "createControlIndex";


        // Prior to creating the control vertex - create an index to allow us to find it without a full scan
        JanusGraphManagement management = graph.openManagement();
        String indexName = "controlIndex";

        try {

            // Check if index exists
            JanusGraphIndex controlIndex = management.getGraphIndex(indexName);
            if (controlIndex == null) {
                log.info("{} index create {} for control vertex", methodName, indexName);
                // Property key should not already exist - but check it anyway.
                PropertyKey propertyKey = management.getPropertyKey(controlVertexIdPropertyName);

                if (propertyKey != null) {
                    // Somehow - despite this being a new graph - the property key already exists. Stop.
                    log.error("{} property key {} already exists", methodName, controlVertexIdPropertyName);
                    management.rollback();
                    return false;
                } else {
                    log.info("{} make property key {}", methodName, controlVertexIdPropertyName);
                    propertyKey = management.makePropertyKey(controlVertexIdPropertyName).dataType(String.class).make();
                }

                if (propertyKey == null) {
                    // Could not create property key. Stop.
                    log.error("{} property key {} could not be created", methodName, controlVertexIdPropertyName);
                    management.rollback();
                    return false;
                } else {
                    log.info("{} create index {}", methodName, indexName);
                    JanusGraphManagement.IndexBuilder indexBuilder = management.buildIndex(indexName, Vertex.class).addKey(propertyKey).unique();
                    JanusGraphIndex index = indexBuilder.buildCompositeIndex();
                    management.setConsistency(index, ConsistencyModifier.LOCK);
                    management.commit();
                    // Enable the index - set a relatively short timeout (10 s vs the default of 1 minute)
                    log.info("{} await ENABLED for {}", methodName, indexName);
                    ManagementSystem.awaitGraphIndexStatus(graph, indexName).status(SchemaStatus.ENABLED).timeout(10, ChronoUnit.SECONDS).call();
                    return true;
                }
            } else {
                // That really should not be possible - a new graph should not have the index. Stop.
                log.error("{} control index already exists", methodName);
                management.rollback();
                return false;
            }
        } catch (Exception e) {
            log.error("{} caught interrupted exception from awaitGraphIndexStatus ENABLED {}", methodName, e);
            management.rollback();
            return false;
        }

    }