com.thinkaurelius.titan.graphdb.internal.InternalRelationType Java Examples

public MizoTitanRelationType(InternalRelationType relationType) {
    status = relationType.getStatus();
    sortKey = relationType.getSortKey();
    name = relationType.name();
    id = relationType.longId();
    isInvisibleType = relationType.isInvisibleType();
    signature = relationType.getSignature();
    sortOrder = relationType.getSortOrder();
    multiplicity = relationType.multiplicity();
    consistencyModifier = relationType.getConsistencyModifier();
    ttl = relationType.getTTL();
    isPropertyKey = relationType.isPropertyKey();
    isEdgeLabel = relationType.isEdgeLabel();

    if (relationType instanceof PropertyKey) {
        dataType = ((PropertyKey)relationType).dataType();
        cardinality = ((PropertyKey)relationType).cardinality();
    } else {
        dataType = null;
        cardinality = null;
    }
}
 

@Override
public <T extends RelationType> Iterable<T> getRelationTypes(Class<T> clazz) {
    Preconditions.checkNotNull(clazz);
    Iterable<? extends TitanVertex> types = null;
    if (PropertyKey.class.equals(clazz)) {
        types = QueryUtil.getVertices(transaction, BaseKey.SchemaCategory, TitanSchemaCategory.PROPERTYKEY);
    } else if (EdgeLabel.class.equals(clazz)) {
        types = QueryUtil.getVertices(transaction, BaseKey.SchemaCategory, TitanSchemaCategory.EDGELABEL);
    } else if (RelationType.class.equals(clazz)) {
        types = Iterables.concat(getRelationTypes(EdgeLabel.class), getRelationTypes(PropertyKey.class));
    } else throw new IllegalArgumentException("Unknown type class: " + clazz);
    return Iterables.filter(Iterables.filter(types, clazz), new Predicate<T>() {
        @Override
        public boolean apply(@Nullable T t) {
            //Filter out all relation type indexes
            return ((InternalRelationType) t).getBaseType() == null;
        }
    });
}
 

@Override
public Iterable<RelationTypeIndex> getRelationIndexes(final RelationType type) {
    Preconditions.checkArgument(type != null && type instanceof InternalRelationType, "Invalid relation type provided: %s", type);
    return Iterables.transform(Iterables.filter(((InternalRelationType) type).getRelationIndexes(), new Predicate<InternalRelationType>() {
        @Override
        public boolean apply(@Nullable InternalRelationType internalRelationType) {
            return !type.equals(internalRelationType);
        }
    }), new Function<InternalRelationType, RelationTypeIndex>() {
        @Nullable
        @Override
        public RelationTypeIndex apply(@Nullable InternalRelationType internalType) {
            return new RelationTypeIndexWrapper(internalType);
        }
    });
}
 

/**
 * Given a path for Titan config file, connects and gets the internal Titan types,
 * converting them to MizoTitanRelationTypes mapped by type-ids
 * @param titanConfigPath Path to Titan's config path
 * @return Mapping between relation type-ids to InternalRelationType instances
 */
protected static HashMap<Long, MizoTitanRelationType> loadRelationTypes(String titanConfigPath) {
    TitanGraph g = TitanFactory.open(titanConfigPath);
    StandardTitanTx tx = (StandardTitanTx)g.buildTransaction().readOnly().start();

    HashMap<Long, MizoTitanRelationType> relations = Maps.newHashMap();

    tx.query()
            .has(BaseKey.SchemaCategory, Contain.IN, Lists.newArrayList(TitanSchemaCategory.values()))
            .vertices()
            .forEach(v -> {
                if (v instanceof InternalRelationType)
                    relations.put(v.longId(), new MizoTitanRelationType((InternalRelationType)v));
            });

    tx.close();

    try {
        ((StandardTitanGraph)g).getBackend().close();
    } catch (BackendException e) {
        e.printStackTrace();
    }

    return relations;
}
 

@Override
public boolean evaluate(E element) {
    RelationType type;
    if (key instanceof String) {
        type = ((InternalElement) element).tx().getRelationType((String) key);
        if (type == null)
            return satisfiesCondition(null);
    } else {
        type = (RelationType) key;
    }

    Preconditions.checkNotNull(type);

    if (type.isPropertyKey()) {
        Iterator<Object> iter = ElementHelper.getValues(element,(PropertyKey)type).iterator();
        if (iter.hasNext()) {
            while (iter.hasNext()) {
                if (satisfiesCondition(iter.next()))
                    return true;
            }
            return false;
        }
        return satisfiesCondition(null);
    } else {
        assert ((InternalRelationType)type).multiplicity().isUnique(Direction.OUT);
        return satisfiesCondition((TitanVertex)element.value(type.name()));
    }
}
 

public static InternalRelationType getType(StandardTitanTx tx, String typeName) {
    RelationType t = tx.getRelationType(typeName);
    if (t == null && !tx.getConfiguration().getAutoSchemaMaker().ignoreUndefinedQueryTypes()) {
        throw new IllegalArgumentException("Undefined type used in query: " + typeName);
    }
    return (InternalRelationType) t;
}
 

public Iterable<InternalRelationType> getRelationIndexes() {
    return Iterables.concat(ImmutableList.of(this),Iterables.transform(getRelated(TypeDefinitionCategory.RELATIONTYPE_INDEX,Direction.OUT),new Function<Entry, InternalRelationType>() {
        @Nullable
        @Override
        public InternalRelationType apply(@Nullable Entry entry) {
            assert entry.getSchemaType() instanceof InternalRelationType;
            return (InternalRelationType)entry.getSchemaType();
        }
    }));
}
 

public TitanSchemaElement getSchemaElement(long id) {
    TitanVertex v = transaction.getVertex(id);
    if (v == null) return null;
    if (v instanceof RelationType) {
        if (((InternalRelationType) v).getBaseType() == null) return (RelationType) v;
        return new RelationTypeIndexWrapper((InternalRelationType) v);
    }
    if (v instanceof TitanSchemaVertex) {
        TitanSchemaVertex sv = (TitanSchemaVertex) v;
        if (sv.getDefinition().containsKey(TypeDefinitionCategory.INTERNAL_INDEX)) {
            return new TitanGraphIndexWrapper(sv.asIndexType());
        }
    }
    throw new IllegalArgumentException("Not a valid schema element vertex: " + id);
}
 

/**
 * Retrieves the consistency level for a schema element (types and internal indexes)
 *
 * @param element
 * @return
 */
@Override
public ConsistencyModifier getConsistency(TitanSchemaElement element) {
    Preconditions.checkArgument(element != null);
    if (element instanceof RelationType) return ((InternalRelationType) element).getConsistencyModifier();
    else if (element instanceof TitanGraphIndex) {
        IndexType index = ((TitanGraphIndexWrapper) element).getBaseIndex();
        if (index.isMixedIndex()) return ConsistencyModifier.DEFAULT;
        return ((CompositeIndexType) index).getConsistencyModifier();
    } else return ConsistencyModifier.DEFAULT;
}
 

public SliceQuery getQuery(final InternalRelationType type, Direction dir) {
    CacheEntry ce;
    try {
        ce = cache.get(type.longId(),new Callable<CacheEntry>() {
            @Override
            public CacheEntry call() throws Exception {
                return new CacheEntry(edgeSerializer,type);
            }
        });
    } catch (ExecutionException e) {
        throw new AssertionError("Should not happen: " + e.getMessage());
    }
    assert ce!=null;
    return ce.get(dir);
}
 

public CacheEntry(EdgeSerializer edgeSerializer, InternalRelationType t) {
    if (t.isPropertyKey()) {
        out = edgeSerializer.getQuery(t, Direction.OUT,new EdgeSerializer.TypedInterval[t.getSortKey().length]);
        in = out;
        both = out;
    } else {
        out = edgeSerializer.getQuery(t,Direction.OUT,
                    new EdgeSerializer.TypedInterval[t.getSortKey().length]);
        in = edgeSerializer.getQuery(t,Direction.IN,
                new EdgeSerializer.TypedInterval[t.getSortKey().length]);
        both = edgeSerializer.getQuery(t,Direction.BOTH,
                new EdgeSerializer.TypedInterval[t.getSortKey().length]);
    }
}
 

public static boolean hasSimpleInternalVertexKeyIndex(PropertyKey key) {
        InternalRelationType type = (InternalRelationType)key;
        for (IndexType index : type.getKeyIndexes()) {
            if (index.getElement()== ElementCategory.VERTEX && index.isCompositeIndex()) {
                if (index.indexesKey(key)) return true;
//                InternalIndexType iIndex = (InternalIndexType)index;
//                if (iIndex.getFieldKeys().length==1) {
//                    assert iIndex.getFieldKeys()[0].getFieldKey().equals(key);
//                    return true;
//                }
            }
        }
        return false;
    }
 

@Override
public InternalRelationType getBaseType() {
    return null;
}
 

@Override
public Iterable<InternalRelationType> getRelationIndexes() {
    return ImmutableSet.of((InternalRelationType)this);
}
 

public InternalRelationType getBaseType() {
    Entry entry = Iterables.getOnlyElement(getRelated(TypeDefinitionCategory.RELATIONTYPE_INDEX,Direction.IN),null);
    if (entry==null) return null;
    assert entry.getSchemaType() instanceof InternalRelationType;
    return (InternalRelationType)entry.getSchemaType();
}
 

public static boolean hasAnyIndex(PropertyKey key) {
    InternalRelationType type = (InternalRelationType) key;
    return !Iterables.isEmpty(type.getKeyIndexes()) ||
            Iterables.size(type.getRelationIndexes())>1; //The type itself is also returned as an index
}
 

public static InternalRelationType getBaseType(InternalRelationType type) {
    InternalRelationType baseType = type.getBaseType();
    if (baseType == null) return type;
    else return baseType;
}
 

private static Iterable<MixedIndexType> getMixedIndexes(RelationType type) {
    if (!type.isPropertyKey()) return Collections.EMPTY_LIST;
    return Iterables.filter(Iterables.filter(((InternalRelationType)type).getKeyIndexes(),MIXED_INDEX_FILTER),MixedIndexType.class);
}
 

public InternalRelationType getWrappedType() {
    return type;
}
 

public RelationTypeIndexWrapper(InternalRelationType type) {
    Preconditions.checkArgument(type != null && type.getBaseType() != null);
    this.type = type;
}
 

public static boolean acquireLock(InternalRelation relation, int pos, boolean acquireLocksConfig) {
    InternalRelationType type = (InternalRelationType)relation.getType();
    return acquireLocksConfig && type.getConsistencyModifier()== ConsistencyModifier.LOCK &&
            ( type.multiplicity().isUnique(EdgeDirection.fromPosition(pos))
                    || pos==0 && type.multiplicity()== Multiplicity.SIMPLE);
}
 

@Override
public Iterable<InternalRelationType> getRelationIndexes() {
    return null;
}
 

@Override
public InternalRelationType getBaseType() {
    return null;
}