Java BackendQueryHolder类代码示例

import com.thinkaurelius.titan.graphdb.query.BackendQueryHolder; //导入依赖的package包/类
protected<Q> Q execute(RelationCategory returnType, ResultConstructor<Q> resultConstructor) {
    BaseVertexCentricQuery bq = super.constructQuery(returnType);
    if (bq.isEmpty()) return resultConstructor.emptyResult();
    if (returnType==RelationCategory.PROPERTY && hasSingleType() && !hasQueryOnlyLoaded()
            && tx.getConfiguration().hasPropertyPrefetching()) {
        //Preload properties
        vertex.query().properties().iterator().hasNext();
    }

    if (isPartitionedVertex(vertex) && !hasQueryOnlyGivenVertex()) { //If it's a preloaded vertex we shouldn't preload data explicitly
        List<InternalVertex> vertices = allRequiredRepresentatives(vertex);
        profiler.setAnnotation(QueryProfiler.PARTITIONED_VERTEX_ANNOTATION,true);
        profiler.setAnnotation(QueryProfiler.NUMVERTICES_ANNOTATION,vertices.size());
        if (vertices.size()>1) {
            for (BackendQueryHolder<SliceQuery> sq : bq.getQueries()) {
                tx.executeMultiQuery(vertices, sq.getBackendQuery(),sq.getProfiler());
            }
        }
    } else profiler.setAnnotation(QueryProfiler.NUMVERTICES_ANNOTATION,1);
    return resultConstructor.getResult(vertex,bq);
}
 

import com.thinkaurelius.titan.graphdb.query.BackendQueryHolder; //导入依赖的package包/类
private List<SliceQuery> relations(RelationCategory returnType) {
    if (name==null) {
        if (hasSingleType()) name = getSingleType().getName();
        else throw new IllegalStateException("Need to specify an explicit name for this query");
    }
    try {
        BaseVertexCentricQuery vq = super.constructQuery(returnType);
        List<SliceQuery> queries = new ArrayList<SliceQuery>(vq.numSubQueries());
        for (int i = 0; i < vq.numSubQueries(); i++) {
            BackendQueryHolder<SliceQuery> bq = vq.getSubQuery(i);
            SliceQuery sq = bq.getBackendQuery();
            queries.add(sq.updateLimit(bq.isFitted() ? vq.getLimit() : hardQueryLimit));
        }
        return queries;
    } finally {
        tx.rollback();
    }
}
 

import com.thinkaurelius.titan.graphdb.query.BackendQueryHolder; //导入依赖的package包/类
public BaseVertexCentricQuery(Condition<TitanRelation> condition, Direction direction,
                              List<BackendQueryHolder<SliceQuery>> queries, OrderList orders,
                              int limit) {
    super(limit);
    Preconditions.checkArgument(condition != null && queries != null && direction != null);
    Preconditions.checkArgument(QueryUtil.isQueryNormalForm(condition) && limit>=0);
    this.condition = condition;
    this.queries = queries;
    this.orders = orders;
    this.direction=direction;
}
 

import com.thinkaurelius.titan.graphdb.query.BackendQueryHolder; //导入依赖的package包/类
public SimpleVertexQueryProcessor(VertexCentricQuery query, StandardTitanTx tx) {
    Preconditions.checkArgument(query.isSimple());
    this.query=query;
    this.tx=tx;
    BackendQueryHolder<SliceQuery> bqh = query.getSubQuery(0);
    this.sliceQuery=bqh.getBackendQuery();
    this.profiler=bqh.getProfiler();
    this.vertex=query.getVertex();
    this.edgeSerializer=tx.getEdgeSerializer();
}
 

import com.thinkaurelius.titan.graphdb.query.BackendQueryHolder; //导入依赖的package包/类
public VertexCentricQuery(InternalVertex vertex, Condition<TitanRelation> condition,
                          Direction direction,
                          List<BackendQueryHolder<SliceQuery>> queries,
                          OrderList orders,
                          int limit) {
    super(condition, direction, queries, orders, limit);
    Preconditions.checkNotNull(vertex);
    this.vertex = vertex;
}
 

import com.thinkaurelius.titan.graphdb.query.BackendQueryHolder; //导入依赖的package包/类
public GraphCentricQuery(ElementCategory resultType, Condition<TitanElement> condition, OrderList orders,
                         BackendQueryHolder<JointIndexQuery> indexQuery, int limit) {
    super(limit);
    Preconditions.checkNotNull(condition);
    Preconditions.checkArgument(orders != null && orders.isImmutable());
    Preconditions.checkArgument(QueryUtil.isQueryNormalForm(condition));
    Preconditions.checkNotNull(resultType);
    Preconditions.checkNotNull(indexQuery);
    this.condition = condition;
    this.orders = orders;
    this.resultType = resultType;
    this.indexQuery = indexQuery;
}
 

import com.thinkaurelius.titan.graphdb.query.BackendQueryHolder; //导入依赖的package包/类
protected<Q> Q execute(RelationCategory returnType, ResultConstructor<Q> resultConstructor) {
    BaseVertexCentricQuery bq = super.constructQuery(returnType);
    if (bq.isEmpty()) return resultConstructor.emptyResult();
    if (isPartitionedVertex(vertex)) {
        List<InternalVertex> vertices = allRepresentatives(vertex);
        if (vertices.size()>1) {
            for (BackendQueryHolder<SliceQuery> sq : bq.getQueries()) {
                tx.executeMultiQuery(vertices, sq.getBackendQuery());
            }
        }
    }
    return resultConstructor.getResult(vertex,bq);
}
 

import com.thinkaurelius.titan.graphdb.query.BackendQueryHolder; //导入依赖的package包/类
protected List<BackendQueryHolder<SliceQuery>> getQueries() {
    return queries;
}
 

import com.thinkaurelius.titan.graphdb.query.BackendQueryHolder; //导入依赖的package包/类
public BackendQueryHolder<SliceQuery> getSubQuery(int position) {
    return queries.get(position);
}
 

import com.thinkaurelius.titan.graphdb.query.BackendQueryHolder; //导入依赖的package包/类
public static final GraphCentricQuery emptyQuery(ElementCategory resultType) {
    Condition<TitanElement> cond = new FixedCondition<TitanElement>(false);
    return new GraphCentricQuery(resultType, cond, OrderList.NO_ORDER,
            new BackendQueryHolder<JointIndexQuery>(new JointIndexQuery(),
                    true, false), 0);
}
 

import com.thinkaurelius.titan.graphdb.query.BackendQueryHolder; //导入依赖的package包/类
@Override
public BackendQueryHolder<JointIndexQuery> getSubQuery(int position) {
    if (position == 0) return indexQuery;
    else throw new IndexOutOfBoundsException();
}
 

import com.thinkaurelius.titan.graphdb.query.BackendQueryHolder; //导入依赖的package包/类
public static final GraphCentricQuery emptyQuery(ElementCategory resultType) {
    Condition<TitanElement> cond = new FixedCondition<TitanElement>(false);
    return new GraphCentricQuery(resultType, cond, OrderList.NO_ORDER,
            new BackendQueryHolder<JointIndexQuery>(new JointIndexQuery(),
                    true, false, null), 0);
}