Esempio n. 1
0
 private TitanType getEdgeType(
     String name, Map<String, TitanType> etCache, InternalTitanTransaction tx) {
   TitanType et = etCache.get(name);
   if (et == null) {
     et = tx.getType(name);
     etCache.put(name, et);
   }
   return et;
 }
Esempio n. 2
0
 private static TypeSignature getSignature(
     InternalTitanTransaction tx, TitanType et, Map<TitanType, TypeSignature> signatures) {
   TypeSignature ets = signatures.get(et);
   if (ets == null) {
     ets = new TypeSignature(et, tx);
     signatures.put(et, ets);
   }
   return ets;
 }
Esempio n. 3
0
  private List<Entry> queryForEntries(AtomicQuery query, TransactionHandle txh) {
    ByteBuffer key = IDHandler.getKey(query.getVertexID());
    List<Entry> entries = null;
    LimitTracker limit = new LimitTracker(query);

    boolean dirs[] = getAllowedDirections(query);

    if (query.hasEdgeTypeCondition()) {
      TitanType et = query.getTypeCondition();
      if (!et.isNew()) { // Result set must be empty if TitanType is new
        ArrayList<Object> applicableConstraints = null;
        boolean isRange = false;
        if (query.hasConstraints()) {
          assert !et.isSimple();
          TypeDefinition def = ((InternalTitanType) et).getDefinition();
          String[] keysig = def.getKeySignature();
          applicableConstraints = new ArrayList<Object>(keysig.length);
          Map<String, Object> constraints = query.getConstraints();
          for (int i = 0; i < keysig.length; i++) {
            if (constraints.containsKey(keysig[i])) {
              Object iv = constraints.get(keysig[i]);
              applicableConstraints.add(iv);
              if (iv != null && (iv instanceof AtomicInterval) && ((AtomicInterval) iv).isRange()) {
                isRange = true;
                break;
              }
            } else break;
          }
          if (applicableConstraints.isEmpty()) applicableConstraints = null;
        }

        for (int dirID = 0; dirID < 4; dirID++) {
          if (dirs[dirID]) {
            if (applicableConstraints != null) {
              assert !applicableConstraints.isEmpty();

              DataOutput start = serializer.getDataOutput(defaultOutputCapacity, true);
              DataOutput end = null;
              if (isRange) end = serializer.getDataOutput(defaultOutputCapacity, true);

              IDHandler.writeEdgeType(start, et.getID(), dirID, idManager);
              if (isRange) IDHandler.writeEdgeType(end, et.getID(), dirID, idManager);

              // Write all applicable key constraints
              for (Object iv : applicableConstraints) {
                if (iv instanceof AtomicInterval) {
                  AtomicInterval interval = (AtomicInterval) iv;
                  if (interval.isPoint()) {
                    start.writeObject(interval.getStartPoint());
                    if (isRange) end.writeObject(interval.getStartPoint());
                  } else {
                    assert isRange;
                    assert interval.isRange();

                    ByteBuffer startColumn, endColumn;

                    if (interval.getStartPoint() != null) {
                      start.writeObject(interval.getStartPoint());
                      startColumn = start.getByteBuffer();
                      if (!interval.startInclusive())
                        startColumn = ByteBufferUtil.nextBiggerBuffer(startColumn);
                    } else {
                      assert interval.startInclusive();
                      startColumn = start.getByteBuffer();
                    }

                    if (interval.getEndPoint() != null) {
                      end.writeObject(interval.getEndPoint());
                    } else {
                      assert interval.endInclusive();
                    }
                    endColumn = end.getByteBuffer();
                    if (interval.endInclusive())
                      endColumn = ByteBufferUtil.nextBiggerBuffer(endColumn);

                    entries = appendResults(key, startColumn, endColumn, entries, limit, txh);
                    break; // redundant, this must be the last iteration because its a range
                  }
                } else {
                  assert iv == null || (iv instanceof TitanVertex);
                  long id = 0;
                  if (iv != null) id = ((TitanVertex) iv).getID();
                  VariableLong.writePositive(start, id);
                  if (isRange) VariableLong.writePositive(end, id);
                }
              }
              if (!isRange)
                entries = appendResults(key, start.getByteBuffer(), entries, limit, txh);
            } else {
              ByteBuffer columnStart = IDHandler.getEdgeType(et.getID(), dirID, idManager);
              entries = appendResults(key, columnStart, entries, limit, txh);
            }
          }
        }
      }
    } else if (query.hasGroupCondition()) {
      int groupid = query.getGroupCondition().getID();
      for (int dirID = 0; dirID < 4; dirID++) {
        if (dirs[dirID]) {
          ByteBuffer columnStart = IDHandler.getEdgeTypeGroup(groupid, dirID, idManager);
          entries = appendResults(key, columnStart, entries, limit, txh);
        }
      }
    } else {
      int lastDirID = -1;
      for (int dirID = 0; dirID <= 4; dirID++) {
        if ((dirID >= 4 || !dirs[dirID]) && lastDirID >= 0) {
          ByteBuffer columnStart = IDHandler.getEdgeTypeGroup(0, lastDirID, idManager);
          ByteBuffer columnEnd =
              IDHandler.getEdgeTypeGroup(idManager.getMaxGroupID() + 1, dirID - 1, idManager);
          entries = appendResults(key, columnStart, columnEnd, entries, limit, txh);
          lastDirID = -1;
        }
        if (dirID < 4) {
          if (dirs[dirID] && lastDirID == -1) lastDirID = dirID;
        }
      }
    }

    if (entries == null) return ImmutableList.of();
    else return entries;
  }