@Test
  public void getSliceRespectsAllBoundsInclusionArguments() throws Exception {
    // Test case where endColumn=startColumn+1
    ByteBuffer key = KeyColumnValueStoreUtil.longToByteBuffer(0);
    ByteBuffer columnBeforeStart = KeyColumnValueStoreUtil.longToByteBuffer(776);
    ByteBuffer columnStart = KeyColumnValueStoreUtil.longToByteBuffer(777);
    ByteBuffer columnEnd = KeyColumnValueStoreUtil.longToByteBuffer(778);
    ByteBuffer columnAfterEnd = KeyColumnValueStoreUtil.longToByteBuffer(779);

    // First insert four test Entries
    TransactionHandle txn = manager.beginTransaction();
    List<Entry> entries =
        Arrays.asList(
            new Entry(columnBeforeStart, columnBeforeStart),
            new Entry(columnStart, columnStart),
            new Entry(columnEnd, columnEnd),
            new Entry(columnAfterEnd, columnAfterEnd));
    store.mutate(key, entries, null, txn);
    txn.commit();

    // getSlice() with only start inclusive
    txn = manager.beginTransaction();
    List<Entry> result = store.getSlice(key, columnStart, columnEnd, txn);
    assertEquals(1, result.size());
    assertEquals(777, result.get(0).getColumn().getLong());
    txn.commit();
  }
  public void checkSlice(
      String[][] values, Set<KeyColumn> removed, int key, int start, int end, int limit) {
    List<Entry> entries;
    if (limit <= 0)
      entries =
          store.getSlice(
              KeyValueStoreUtil.getBuffer(key),
              KeyValueStoreUtil.getBuffer(start),
              KeyValueStoreUtil.getBuffer(end),
              tx);
    else
      entries =
          store.getSlice(
              KeyValueStoreUtil.getBuffer(key),
              KeyValueStoreUtil.getBuffer(start),
              KeyValueStoreUtil.getBuffer(end),
              limit,
              tx);

    int pos = 0;
    for (int i = start; i < end; i++) {
      if (removed.contains(new KeyColumn(key, i))) continue;
      if (limit <= 0 || pos < limit) {
        Entry entry = entries.get(pos);
        int col = KeyValueStoreUtil.getID(entry.getColumn());
        String str = KeyValueStoreUtil.getString(entry.getValue());
        assertEquals(i, col);
        assertEquals(values[key][i], str);
      }
      pos++;
    }
    assertNotNull(entries);
    if (limit > 0 && pos > limit) assertEquals(limit, entries.size());
    else assertEquals(pos, entries.size());
  }
 public void checkKeys(Set<Integer> removed) {
   for (int i = 0; i < numKeys; i++) {
     if (removed.contains(i)) {
       assertFalse(store.containsKey(KeyValueStoreUtil.getBuffer(i), tx));
     } else {
       assertTrue(store.containsKey(KeyValueStoreUtil.getBuffer(i), tx));
     }
   }
 }
  @Test
  public void containsKeyReturnsTrueOnExtantKey() throws Exception {
    ByteBuffer key1 = KeyColumnValueStoreUtil.longToByteBuffer(1);
    TransactionHandle txn = manager.beginTransaction();
    assertFalse(store.containsKey(key1.duplicate(), txn));
    KeyColumnValueStoreUtil.insert(store, txn, 1, "c", "v");
    txn.commit();

    txn = manager.beginTransaction();
    assertTrue(store.containsKey(key1.duplicate(), txn));
    txn.commit();
  }
Esempio n. 5
0
  @Override
  public long[] indexRetrieval(Object key, TitanKey pt, InternalTitanTransaction tx) {
    Preconditions.checkArgument(
        pt.isSimple(), "Currently, only simple properties are supported for index retrieval");
    Preconditions.checkArgument(
        pt.hasIndex(), "Cannot retrieve for given property key - it does not have an index");

    long[] vertices = null;

    Preconditions.checkArgument(
        pt.getDataType().isInstance(key),
        "Specified object is incompatible with property data type [" + pt.getName() + "]");

    for (int readAttempt = 0; readAttempt < maxReadRetryAttempts; readAttempt++) {
      try {
        if (pt.isUnique()) {
          ByteBuffer value =
              propertyIndex.get(getIndexKey(key), getKeyedIndexColumn(pt), tx.getTxHandle());
          if (value != null) {
            vertices = new long[1];
            vertices[0] = VariableLong.readPositive(value);
          }
        } else {
          ByteBuffer startColumn = VariableLong.positiveByteBuffer(pt.getID());
          List<Entry> entries =
              propertyIndex.getSlice(
                  getIndexKey(key),
                  startColumn,
                  ByteBufferUtil.nextBiggerBuffer(startColumn),
                  tx.getTxHandle());
          vertices = new long[entries.size()];
          int i = 0;
          for (Entry ent : entries) {
            vertices[i++] = VariableLong.readPositive(ent.getValue());
          }
        }

        break;
      } catch (StorageException e) {
        if (e instanceof TemporaryStorageException) {
          if (readAttempt < maxReadRetryAttempts - 1) temporaryStorageException(e);
          else throw readException(e, maxReadRetryAttempts);
        } else throw readException(e);
      }
    }

    if (vertices == null) return new long[0];
    else return vertices;
  }
Esempio n. 6
0
  private List<Entry> appendResults(
      ByteBuffer key,
      ByteBuffer columnStart,
      ByteBuffer columnEnd,
      List<Entry> entries,
      LimitTracker limit,
      TransactionHandle txh) {
    if (limit.limitExhausted()) return null;
    List<Entry> results = null;

    for (int readAttempt = 0; readAttempt < maxReadRetryAttempts; readAttempt++) {
      try {
        results = edgeStore.getSlice(key, columnStart, columnEnd, limit.getLimit(), txh);
        break;
      } catch (StorageException e) {
        if (e instanceof TemporaryStorageException) {
          if (readAttempt < maxReadRetryAttempts - 1) temporaryStorageException(e);
          else throw readException(e, maxReadRetryAttempts);
        } else throw readException(e);
      }
    }

    limit.retrieved(results.size());

    if (entries == null) return results;
    else {
      entries.addAll(results);
      return entries;
    }
  }
Esempio n. 7
0
  @Override
  public synchronized void shutdown() throws TitanException {
    if (!isOpen) return;
    super.shutdown();
    etManager.close();
    idAssigner.close();

    try {
      edgeStore.close();
      propertyIndex.close();
      storage.close();
    } catch (StorageException e) {
      throw new TitanException("Could not close storage backend", e);
    }
    isOpen = false;
  }
 @Test
 public void containsKeyReturnsFalseOnNonexistentKey() throws Exception {
   TransactionHandle txn = manager.beginTransaction();
   ByteBuffer key1 = KeyColumnValueStoreUtil.longToByteBuffer(1);
   assertFalse(store.containsKey(key1.duplicate(), txn));
   txn.commit();
 }
 public void loadValues(String[][] values) {
   for (int i = 0; i < numKeys; i++) {
     List<Entry> entries = new ArrayList<Entry>();
     for (int j = 0; j < numColumns; j++) {
       entries.add(
           new Entry(KeyValueStoreUtil.getBuffer(j), KeyValueStoreUtil.getBuffer(values[i][j])));
     }
     store.mutate(KeyValueStoreUtil.getBuffer(i), entries, null, tx);
   }
 }
Esempio n. 10
0
  @Test
  public void getSliceRespectsColumnLimit() throws Exception {
    TransactionHandle txn = manager.beginTransaction();
    ByteBuffer key = KeyColumnValueStoreUtil.longToByteBuffer(0);

    final int cols = 1024;

    List<Entry> entries = new LinkedList<Entry>();
    for (int i = 0; i < cols; i++) {
      ByteBuffer col = KeyColumnValueStoreUtil.longToByteBuffer(i);
      entries.add(new Entry(col, col));
    }
    store.mutate(key, entries, null, txn);
    txn.commit();

    txn = manager.beginTransaction();
    ByteBuffer columnStart = KeyColumnValueStoreUtil.longToByteBuffer(0);
    ByteBuffer columnEnd = KeyColumnValueStoreUtil.longToByteBuffer(cols);
    /*
     * When limit is greater than or equal to the matching column count,
     * all matching columns must be returned.
     */
    List<Entry> result = store.getSlice(key, columnStart, columnEnd, cols, txn);
    assertEquals(cols, result.size());
    assertEquals(entries, result);
    result = store.getSlice(key, columnStart, columnEnd, cols + 10, txn);
    assertEquals(cols, result.size());
    assertEquals(entries, result);

    /*
     * When limit is less the matching column count, the columns up to the
     * limit (ordered bytewise) must be returned.
     */
    result = store.getSlice(key, columnStart, columnEnd, cols - 1, txn);
    assertEquals(cols - 1, result.size());
    entries.remove(entries.size() - 1);
    assertEquals(entries, result);
    result = store.getSlice(key, columnStart, columnEnd, 1, txn);
    assertEquals(1, result.size());
    List<Entry> firstEntrySingleton = Arrays.asList(entries.get(0));
    assertEquals(firstEntrySingleton, result);
    txn.commit();
  }
Esempio n. 11
0
 public void checkValues(String[][] values, Set<KeyColumn> removed) {
   for (int i = 0; i < numKeys; i++) {
     for (int j = 0; j < numColumns; j++) {
       ByteBuffer result =
           store.get(KeyValueStoreUtil.getBuffer(i), KeyValueStoreUtil.getBuffer(j), tx);
       if (removed.contains(new KeyColumn(i, j))) {
         assertNull(result);
       } else {
         Assert.assertEquals(values[i][j], KeyValueStoreUtil.getString(result));
       }
     }
   }
 }
Esempio n. 12
0
 public Set<Integer> deleteKeys(int every) {
   Set<Integer> removed = new HashSet<Integer>();
   for (int i = 0; i < numKeys; i++) {
     if (i % every == 0) {
       removed.add(i);
       List<ByteBuffer> deletions = new ArrayList<ByteBuffer>();
       for (int j = 0; j < numColumns; j++) {
         deletions.add(KeyValueStoreUtil.getBuffer(j));
       }
       store.mutate(KeyValueStoreUtil.getBuffer(i), null, deletions, tx);
     }
   }
   return removed;
 }
Esempio n. 13
0
 public void checkValueExistence(String[][] values, Set<KeyColumn> removed) {
   for (int i = 0; i < numKeys; i++) {
     for (int j = 0; j < numColumns; j++) {
       boolean result =
           store.containsKeyColumn(
               KeyValueStoreUtil.getBuffer(i), KeyValueStoreUtil.getBuffer(j), tx);
       if (removed.contains(new KeyColumn(i, j))) {
         assertFalse(result);
       } else {
         assertTrue(result);
       }
     }
   }
 }
Esempio n. 14
0
  @Override
  public boolean containsVertexID(long id, InternalTitanTransaction tx) {
    log.trace("Checking node existence for {}", id);

    for (int readAttempt = 0; readAttempt < maxReadRetryAttempts; readAttempt++) {
      try {
        return edgeStore.containsKey(IDHandler.getKey(id), tx.getTxHandle());
      } catch (StorageException e) {
        if (e instanceof TemporaryStorageException) {
          if (readAttempt < maxReadRetryAttempts - 1) temporaryStorageException(e);
          else throw readException(e, maxReadRetryAttempts);
        } else throw readException(e);
      }
    }
    throw new AssertionError("Illegal program state");
  }
Esempio n. 15
0
 public Set<KeyColumn> deleteValues(int every) {
   Set<KeyColumn> removed = new HashSet<KeyColumn>();
   int counter = 0;
   for (int i = 0; i < numKeys; i++) {
     List<ByteBuffer> deletions = new ArrayList<ByteBuffer>();
     for (int j = 0; j < numColumns; j++) {
       counter++;
       if (counter % every == 0) {
         // remove
         removed.add(new KeyColumn(i, j));
         deletions.add(KeyValueStoreUtil.getBuffer(j));
       }
     }
     store.mutate(KeyValueStoreUtil.getBuffer(i), null, deletions, tx);
   }
   return removed;
 }
Esempio n. 16
0
 public void close() {
   if (tx != null) tx.commit();
   store.close();
   manager.close();
 }