Ejemplo n.º 1
0
  public void testTruncate() throws DatabaseException {

    SecondaryDatabase secDb = initDb();
    Database priDb = secDb.getPrimaryDatabase();
    Transaction txn = txnBegin();

    for (int i = 0; i < NUM_RECS; i += 1) {
      priDb.put(txn, entry(i), entry(i));
    }
    verifyRecords(txn, priDb, NUM_RECS, false);
    verifyRecords(txn, secDb, NUM_RECS, true);
    txnCommit(txn);
    secDb.close();
    priDb.close();

    txn = txnBegin();
    assertEquals(NUM_RECS, env.truncateDatabase(txn, "testDB", true));
    assertEquals(NUM_RECS, env.truncateDatabase(txn, "testSecDB", true));
    txnCommit(txn);

    secDb = initDb();
    priDb = secDb.getPrimaryDatabase();

    txn = txnBegin();
    verifyRecords(txn, priDb, 0, false);
    verifyRecords(txn, secDb, 0, true);
    txnCommit(txn);

    secDb.close();
    priDb.close();
  }
Ejemplo n.º 2
0
  public void testOpenAndClose() throws DatabaseException {

    Database priDb = openDatabase(false, "testDB", false);

    /* Open two secondaries as regular databases and as secondaries. */
    Database secDbDetached = openDatabase(true, "testSecDB", false);
    SecondaryDatabase secDb = openSecondary(priDb, true, "testSecDB", false, false);
    Database secDb2Detached = openDatabase(true, "testSecDB2", false);
    SecondaryDatabase secDb2 = openSecondary(priDb, true, "testSecDB2", false, false);
    assertEquals(
        priDb.getSecondaryDatabases(), Arrays.asList(new SecondaryDatabase[] {secDb, secDb2}));

    Transaction txn = txnBegin();

    /* Check that primary writes to both secondaries. */
    checkSecondaryUpdate(txn, priDb, 1, secDbDetached, true, secDb2Detached, true);

    /* New txn before closing database. */
    txnCommit(txn);
    txn = txnBegin();

    /* Close 2nd secondary. */
    secDb2.close();
    assertEquals(priDb.getSecondaryDatabases(), Arrays.asList(new SecondaryDatabase[] {secDb}));

    /* Check that primary writes to 1st secondary only. */
    checkSecondaryUpdate(txn, priDb, 2, secDbDetached, true, secDb2Detached, false);

    /* New txn before closing database. */
    txnCommit(txn);
    txn = txnBegin();

    /* Close 1st secondary. */
    secDb.close();
    assertEquals(0, priDb.getSecondaryDatabases().size());

    /* Check that primary writes to no secondaries. */
    checkSecondaryUpdate(txn, priDb, 3, secDbDetached, false, secDb2Detached, false);

    /* Open the two secondaries again. */
    secDb = openSecondary(priDb, true, "testSecDB", false, false);
    secDb2 = openSecondary(priDb, true, "testSecDB2", false, false);
    assertEquals(
        priDb.getSecondaryDatabases(), Arrays.asList(new SecondaryDatabase[] {secDb, secDb2}));

    /* Check that primary writes to both secondaries. */
    checkSecondaryUpdate(txn, priDb, 4, secDbDetached, true, secDb2Detached, true);

    /* Close the primary first to disassociate secondaries. */
    txnCommit(txn);
    priDb.close();
    assertNull(secDb.getPrimaryDatabase());
    assertNull(secDb2.getPrimaryDatabase());
    secDb2.close();
    secDb.close();

    secDb2Detached.close();
    secDbDetached.close();
  }
Ejemplo n.º 3
0
  public void testReadOnly() throws DatabaseException {

    SecondaryDatabase secDb = initDb();
    Database priDb = secDb.getPrimaryDatabase();
    OperationStatus status;
    Transaction txn = txnBegin();

    for (int i = 0; i < NUM_RECS; i += 1) {
      status = priDb.put(txn, entry(i), entry(i));
      assertSame(OperationStatus.SUCCESS, status);
    }

    /*
     * Secondaries can be opened without a key creator if the primary is
     * read only.  openSecondary will specify a null key creator if the
     * readOnly param is false.
     */
    Database readOnlyPriDb = openDatabase(false, "testDB", true);
    SecondaryDatabase readOnlySecDb = openSecondary(readOnlyPriDb, true, "testSecDB", false, true);
    assertNull(readOnlySecDb.getSecondaryConfig().getKeyCreator());
    verifyRecords(txn, readOnlySecDb, NUM_RECS, true);

    txnCommit(txn);
    readOnlySecDb.close();
    readOnlyPriDb.close();
    secDb.close();
    priDb.close();
  }
Ejemplo n.º 4
0
  private SecondaryDatabase openSecondary(
      Database priDb,
      boolean allowDuplicates,
      String dbName,
      boolean allowPopulate,
      boolean readOnly)
      throws DatabaseException {

    List secListBefore = priDb.getSecondaryDatabases();
    SecondaryConfig dbConfig = new SecondaryConfig();
    dbConfig.setTransactional(isTransactional);
    dbConfig.setAllowCreate(true);
    dbConfig.setSortedDuplicates(allowDuplicates);
    dbConfig.setReadOnly(readOnly);
    dbConfig.setAllowPopulate(allowPopulate);
    if (!readOnly) {
      if (useMultiKey) {
        dbConfig.setMultiKeyCreator(new SimpleMultiKeyCreator(new MyKeyCreator()));
      } else {
        dbConfig.setKeyCreator(new MyKeyCreator());
      }
    }
    Transaction txn = txnBegin();
    SecondaryDatabase secDb;
    try {
      secDb = env.openSecondaryDatabase(txn, dbName, priDb, dbConfig);
    } finally {
      txnCommit(txn);
    }
    assertNotNull(secDb);

    /* Check configuration. */
    assertSame(priDb, secDb.getPrimaryDatabase());
    SecondaryConfig config2 = secDb.getSecondaryConfig();
    assertEquals(allowPopulate, config2.getAllowPopulate());
    assertEquals(dbConfig.getKeyCreator(), config2.getKeyCreator());

    /* Make sure the new secondary is added to the primary's list. */
    List secListAfter = priDb.getSecondaryDatabases();
    assertTrue(secListAfter.remove(secDb));
    assertEquals(secListBefore, secListAfter);

    return secDb;
  }
Ejemplo n.º 5
0
  /** [#14966] */
  public void testDirtyReadPartialGet() throws DatabaseException {

    SecondaryDatabase secDb = initDb();
    Database priDb = secDb.getPrimaryDatabase();

    DatabaseEntry data = new DatabaseEntry();
    DatabaseEntry key = new DatabaseEntry();
    DatabaseEntry secKey = new DatabaseEntry();
    OperationStatus status;

    /* Put a record */
    Transaction txn = txnBegin();
    status = priDb.put(txn, entry(0), entry(0));
    assertSame(OperationStatus.SUCCESS, status);
    txnCommit(txn);

    /* Regular get */
    status = secDb.get(null, entry(0 + KEY_OFFSET), key, data, LockMode.DEFAULT);
    assertSame(OperationStatus.SUCCESS, status);
    assertDataEquals(entry(0), key);
    assertDataEquals(entry(0), data);

    /* Dirty read returning no data */
    data.setPartial(0, 0, true);
    status = secDb.get(null, entry(0 + KEY_OFFSET), key, data, LockMode.READ_UNCOMMITTED);
    assertSame(OperationStatus.SUCCESS, status);
    assertDataEquals(entry(0), key);
    assertEquals(0, data.getData().length);
    assertEquals(0, data.getSize());

    /* Dirty read returning partial data */
    data.setPartial(0, 1, true);
    status = secDb.get(null, entry(0 + KEY_OFFSET), key, data, LockMode.READ_UNCOMMITTED);
    assertSame(OperationStatus.SUCCESS, status);
    assertDataEquals(entry(0), key);
    assertEquals(1, data.getData().length);
    assertEquals(1, data.getSize());

    secDb.close();
    priDb.close();
  }
Ejemplo n.º 6
0
  /** Test that null can be passed for the LockMode to all get methods. */
  public void testNullLockMode() throws DatabaseException {

    SecondaryDatabase secDb = initDb();
    Database priDb = secDb.getPrimaryDatabase();
    Transaction txn = txnBegin();

    DatabaseEntry key = entry(0);
    DatabaseEntry data = entry(0);
    DatabaseEntry secKey = entry(KEY_OFFSET);
    DatabaseEntry found = new DatabaseEntry();
    DatabaseEntry found2 = new DatabaseEntry();
    DatabaseEntry found3 = new DatabaseEntry();

    assertEquals(OperationStatus.SUCCESS, priDb.put(txn, key, data));
    assertEquals(OperationStatus.SUCCESS, priDb.put(txn, entry(1), data));
    assertEquals(OperationStatus.SUCCESS, priDb.put(txn, entry(2), entry(2)));

    /* Database operations. */

    assertEquals(OperationStatus.SUCCESS, priDb.get(txn, key, found, null));
    assertEquals(OperationStatus.SUCCESS, priDb.getSearchBoth(txn, key, data, null));
    assertEquals(OperationStatus.SUCCESS, secDb.get(txn, secKey, found, null));
    assertEquals(OperationStatus.SUCCESS, secDb.get(txn, secKey, found, found2, null));
    assertEquals(OperationStatus.SUCCESS, secDb.getSearchBoth(txn, secKey, key, found, null));

    /* Cursor operations. */

    txnCommit(txn);
    txn = txnBeginCursor();
    Cursor cursor = priDb.openCursor(txn, null);
    SecondaryCursor secCursor = secDb.openSecondaryCursor(txn, null);

    assertEquals(OperationStatus.SUCCESS, cursor.getSearchKey(key, found, null));
    assertEquals(OperationStatus.SUCCESS, cursor.getSearchBoth(key, data, null));
    assertEquals(OperationStatus.SUCCESS, cursor.getSearchKeyRange(key, found, null));
    assertEquals(OperationStatus.SUCCESS, cursor.getSearchBothRange(key, data, null));
    assertEquals(OperationStatus.SUCCESS, cursor.getFirst(found, found2, null));
    assertEquals(OperationStatus.SUCCESS, cursor.getNext(found, found2, null));
    assertEquals(OperationStatus.SUCCESS, cursor.getPrev(found, found2, null));
    assertEquals(OperationStatus.NOTFOUND, cursor.getNextDup(found, found2, null));
    assertEquals(OperationStatus.NOTFOUND, cursor.getPrevDup(found, found2, null));
    assertEquals(OperationStatus.SUCCESS, cursor.getNextNoDup(found, found2, null));
    assertEquals(OperationStatus.SUCCESS, cursor.getPrevNoDup(found, found2, null));
    assertEquals(OperationStatus.SUCCESS, cursor.getLast(found, found2, null));

    assertEquals(OperationStatus.SUCCESS, secCursor.getSearchKey(secKey, found, null));
    assertEquals(OperationStatus.SUCCESS, secCursor.getSearchKeyRange(secKey, found, null));
    assertEquals(OperationStatus.SUCCESS, secCursor.getFirst(found, found2, null));
    assertEquals(OperationStatus.SUCCESS, secCursor.getNext(found, found2, null));
    assertEquals(OperationStatus.SUCCESS, secCursor.getPrev(found, found2, null));
    assertEquals(OperationStatus.SUCCESS, secCursor.getNextDup(found, found2, null));
    assertEquals(OperationStatus.SUCCESS, secCursor.getPrevDup(found, found2, null));
    assertEquals(OperationStatus.SUCCESS, secCursor.getNextNoDup(found, found2, null));
    assertEquals(OperationStatus.SUCCESS, secCursor.getPrevNoDup(found, found2, null));
    assertEquals(OperationStatus.SUCCESS, secCursor.getLast(found, found2, null));

    assertEquals(OperationStatus.SUCCESS, secCursor.getSearchKey(secKey, found, found2, null));
    assertEquals(OperationStatus.SUCCESS, secCursor.getSearchBoth(secKey, data, found, null));
    assertEquals(OperationStatus.SUCCESS, secCursor.getSearchKeyRange(secKey, found, found2, null));
    assertEquals(OperationStatus.SUCCESS, secCursor.getSearchBothRange(secKey, data, found, null));
    assertEquals(OperationStatus.SUCCESS, secCursor.getFirst(found, found2, found3, null));
    assertEquals(OperationStatus.SUCCESS, secCursor.getNext(found, found2, found3, null));
    assertEquals(OperationStatus.SUCCESS, secCursor.getPrev(found, found2, found3, null));
    assertEquals(OperationStatus.SUCCESS, secCursor.getNextDup(found, found2, found3, null));
    assertEquals(OperationStatus.SUCCESS, secCursor.getPrevDup(found, found2, found3, null));
    assertEquals(OperationStatus.SUCCESS, secCursor.getNextNoDup(found, found2, found3, null));
    assertEquals(OperationStatus.SUCCESS, secCursor.getPrevNoDup(found, found2, found3, null));
    assertEquals(OperationStatus.SUCCESS, secCursor.getLast(found, found2, found3, null));

    secCursor.close();
    cursor.close();
    txnCommit(txn);
    secDb.close();
    priDb.close();
    env.close();
    env = null;
  }
Ejemplo n.º 7
0
  /** @deprecated use of Database.truncate */
  public void testOperationsNotAllowed() throws DatabaseException {

    SecondaryDatabase secDb = initDb();
    Database priDb = secDb.getPrimaryDatabase();
    Transaction txn = txnBegin();

    /* Open secondary without a key creator. */
    try {
      env.openSecondaryDatabase(txn, "xxx", priDb, null);
      fail();
    } catch (NullPointerException expected) {
    }
    try {
      env.openSecondaryDatabase(txn, "xxx", priDb, new SecondaryConfig());
      fail();
    } catch (NullPointerException expected) {
    }

    /* Open secondary with both single and multi key creators. */
    SecondaryConfig config = new SecondaryConfig();
    config.setKeyCreator(new MyKeyCreator());
    config.setMultiKeyCreator(new SimpleMultiKeyCreator(new MyKeyCreator()));
    try {
      env.openSecondaryDatabase(txn, "xxx", priDb, config);
      fail();
    } catch (IllegalArgumentException expected) {
    }

    /* Database operations. */

    DatabaseEntry key = entry(1);
    DatabaseEntry data = entry(2);

    try {
      secDb.getSearchBoth(txn, key, data, LockMode.DEFAULT);
      fail();
    } catch (UnsupportedOperationException expected) {
    }

    try {
      secDb.put(txn, key, data);
      fail();
    } catch (UnsupportedOperationException expected) {
    }

    try {
      secDb.putNoOverwrite(txn, key, data);
      fail();
    } catch (UnsupportedOperationException expected) {
    }

    try {
      secDb.putNoDupData(txn, key, data);
      fail();
    } catch (UnsupportedOperationException expected) {
    }

    try {
      secDb.truncate(txn, true);
      fail();
    } catch (UnsupportedOperationException expected) {
    }

    try {
      secDb.join(new Cursor[0], null);
      fail();
    } catch (UnsupportedOperationException expected) {
    }

    /* Cursor operations. */

    txnCommit(txn);
    txn = txnBeginCursor();

    SecondaryCursor cursor = null;
    try {
      cursor = secDb.openSecondaryCursor(txn, null);

      try {
        cursor.getSearchBoth(key, data, LockMode.DEFAULT);
        fail();
      } catch (UnsupportedOperationException expected) {
      }

      try {
        cursor.getSearchBothRange(key, data, LockMode.DEFAULT);
        fail();
      } catch (UnsupportedOperationException expected) {
      }

      try {
        cursor.putCurrent(data);
        fail();
      } catch (UnsupportedOperationException expected) {
      }

      try {
        cursor.put(key, data);
        fail();
      } catch (UnsupportedOperationException expected) {
      }

      try {
        cursor.putNoOverwrite(key, data);
        fail();
      } catch (UnsupportedOperationException expected) {
      }

      try {
        cursor.putNoDupData(key, data);
        fail();
      } catch (UnsupportedOperationException expected) {
      }
    } finally {
      if (cursor != null) {
        cursor.close();
      }
    }

    txnCommit(txn);
    secDb.close();
    priDb.close();

    /* Primary with duplicates. */
    priDb = openDatabase(true, "testDBWithDups", false);
    try {
      openSecondary(priDb, true, "testSecDB", false, false);
      fail();
    } catch (IllegalArgumentException expected) {
    }

    priDb.close();

    /* Single secondary with two primaries.*/
    Database pri1 = openDatabase(false, "pri1", false);
    Database pri2 = openDatabase(false, "pri2", false);
    Database sec1 = openSecondary(pri1, false, "sec", false, false);
    try {
      openSecondary(pri2, false, "sec", false, false);
      fail();
    } catch (IllegalArgumentException expected) {
    }
    sec1.close();
    pri1.close();
    pri2.close();
  }
Ejemplo n.º 8
0
  public void testPutAndDelete() throws DatabaseException {

    SecondaryDatabase secDb = initDb();
    Database priDb = secDb.getPrimaryDatabase();

    DatabaseEntry data = new DatabaseEntry();
    DatabaseEntry key = new DatabaseEntry();
    OperationStatus status;
    Transaction txn = txnBegin();

    /* Database.put() */
    status = priDb.put(txn, entry(1), entry(2));
    assertSame(OperationStatus.SUCCESS, status);
    status = secDb.get(txn, entry(102), key, data, LockMode.DEFAULT);
    assertSame(OperationStatus.SUCCESS, status);
    assertDataEquals(entry(1), key);
    assertDataEquals(entry(2), data);

    /* Database.putNoOverwrite() */
    status = priDb.putNoOverwrite(txn, entry(1), entry(1));
    assertSame(OperationStatus.KEYEXIST, status);
    status = secDb.get(txn, entry(102), key, data, LockMode.DEFAULT);
    assertSame(OperationStatus.SUCCESS, status);
    assertDataEquals(entry(1), key);
    assertDataEquals(entry(2), data);

    /* Database.put() overwrite */
    status = priDb.put(txn, entry(1), entry(3));
    assertSame(OperationStatus.SUCCESS, status);
    status = secDb.get(txn, entry(102), key, data, LockMode.DEFAULT);
    assertSame(OperationStatus.NOTFOUND, status);
    status = secDb.get(txn, entry(103), key, data, LockMode.DEFAULT);
    assertSame(OperationStatus.SUCCESS, status);
    assertDataEquals(entry(1), key);
    assertDataEquals(entry(3), data);

    /* Database.delete() */
    status = priDb.delete(txn, entry(1));
    assertSame(OperationStatus.SUCCESS, status);
    status = priDb.delete(txn, entry(1));
    assertSame(OperationStatus.NOTFOUND, status);
    status = secDb.get(txn, entry(103), key, data, LockMode.DEFAULT);
    assertSame(OperationStatus.NOTFOUND, status);

    /* SecondaryDatabase.delete() */
    status = priDb.put(txn, entry(1), entry(1));
    assertSame(OperationStatus.SUCCESS, status);
    status = priDb.put(txn, entry(2), entry(1));
    assertSame(OperationStatus.SUCCESS, status);
    status = secDb.get(txn, entry(101), key, data, LockMode.DEFAULT);
    assertSame(OperationStatus.SUCCESS, status);
    assertDataEquals(entry(1), key);
    assertDataEquals(entry(1), data);
    status = secDb.delete(txn, entry(101));
    assertSame(OperationStatus.SUCCESS, status);
    status = secDb.delete(txn, entry(101));
    assertSame(OperationStatus.NOTFOUND, status);
    status = secDb.get(txn, entry(101), key, data, LockMode.DEFAULT);
    assertSame(OperationStatus.NOTFOUND, status);
    status = priDb.get(txn, entry(1), data, LockMode.DEFAULT);
    assertSame(OperationStatus.NOTFOUND, status);
    status = priDb.get(txn, entry(2), data, LockMode.DEFAULT);
    assertSame(OperationStatus.NOTFOUND, status);

    /*
     * Database.putNoDupData() cannot be called since the primary cannot be
     * configured for duplicates.
     */

    /* Primary and secondary are empty now. */

    /* Get a txn for a cursor. */
    txnCommit(txn);
    txn = txnBeginCursor();

    Cursor priCursor = null;
    SecondaryCursor secCursor = null;
    try {
      priCursor = priDb.openCursor(txn, null);
      secCursor = secDb.openSecondaryCursor(txn, null);

      /* Cursor.putNoOverwrite() */
      status = priCursor.putNoOverwrite(entry(1), entry(2));
      assertSame(OperationStatus.SUCCESS, status);
      status = secCursor.getSearchKey(entry(102), key, data, LockMode.DEFAULT);
      assertSame(OperationStatus.SUCCESS, status);
      assertDataEquals(entry(1), key);
      assertDataEquals(entry(2), data);

      /* Cursor.putCurrent() */
      status = priCursor.putCurrent(entry(3));
      assertSame(OperationStatus.SUCCESS, status);
      status = secCursor.getSearchKey(entry(102), key, data, LockMode.DEFAULT);
      assertSame(OperationStatus.NOTFOUND, status);
      status = secCursor.getSearchKey(entry(103), key, data, LockMode.DEFAULT);
      assertSame(OperationStatus.SUCCESS, status);
      assertDataEquals(entry(1), key);
      assertDataEquals(entry(3), data);

      /* Cursor.delete() */
      status = priCursor.delete();
      assertSame(OperationStatus.SUCCESS, status);
      status = priCursor.delete();
      assertSame(OperationStatus.KEYEMPTY, status);
      status = secCursor.getSearchKey(entry(103), key, data, LockMode.DEFAULT);
      assertSame(OperationStatus.NOTFOUND, status);
      status = priCursor.getSearchKey(entry(1), data, LockMode.DEFAULT);
      assertSame(OperationStatus.NOTFOUND, status);

      /* Cursor.put() */
      status = priCursor.put(entry(1), entry(4));
      assertSame(OperationStatus.SUCCESS, status);
      status = secCursor.getSearchKey(entry(104), key, data, LockMode.DEFAULT);
      assertSame(OperationStatus.SUCCESS, status);
      assertDataEquals(entry(1), key);
      assertDataEquals(entry(4), data);

      /* SecondaryCursor.delete() */
      status = secCursor.delete();
      assertSame(OperationStatus.SUCCESS, status);
      status = secCursor.delete();
      assertSame(OperationStatus.KEYEMPTY, status);
      status = secCursor.getCurrent(new DatabaseEntry(), key, data, LockMode.DEFAULT);
      assertSame(OperationStatus.KEYEMPTY, status);
      status = secCursor.getSearchKey(entry(104), key, data, LockMode.DEFAULT);
      assertSame(OperationStatus.NOTFOUND, status);
      status = priCursor.getSearchKey(entry(1), data, LockMode.DEFAULT);
      assertSame(OperationStatus.NOTFOUND, status);

      /*
       * Cursor.putNoDupData() cannot be called since the primary cannot
       * be configured for duplicates.
       */

      /* Primary and secondary are empty now. */
    } finally {
      if (secCursor != null) {
        secCursor.close();
      }
      if (priCursor != null) {
        priCursor.close();
      }
    }

    txnCommit(txn);
    secDb.close();
    priDb.close();
  }
Ejemplo n.º 9
0
  public void testGet() throws DatabaseException {

    SecondaryDatabase secDb = initDb();
    Database priDb = secDb.getPrimaryDatabase();

    DatabaseEntry data = new DatabaseEntry();
    DatabaseEntry key = new DatabaseEntry();
    DatabaseEntry secKey = new DatabaseEntry();
    OperationStatus status;
    Transaction txn = txnBegin();

    /*
     * For parameters that do not require initialization with a non-null
     * data array, we set them to null to make sure this works. [#12121]
     */

    /* Add one record for each key with one data/duplicate. */
    for (int i = 0; i < NUM_RECS; i += 1) {
      status = priDb.put(txn, entry(i), entry(i));
      assertSame(OperationStatus.SUCCESS, status);
    }

    /* SecondaryDatabase.get() */
    for (int i = 0; i < NUM_RECS; i += 1) {

      data.setData(null);
      status = secDb.get(txn, entry(i + KEY_OFFSET), key, data, LockMode.DEFAULT);
      assertSame(OperationStatus.SUCCESS, status);
      assertDataEquals(entry(i), key);
      assertDataEquals(entry(i), data);
    }
    data.setData(null);
    status = secDb.get(txn, entry(NUM_RECS + KEY_OFFSET), key, data, LockMode.DEFAULT);
    assertSame(OperationStatus.NOTFOUND, status);

    /* SecondaryDatabase.getSearchBoth() */
    for (int i = 0; i < NUM_RECS; i += 1) {
      data.setData(null);
      status = secDb.getSearchBoth(txn, entry(i + KEY_OFFSET), entry(i), data, LockMode.DEFAULT);
      assertSame(OperationStatus.SUCCESS, status);
      assertDataEquals(entry(i), data);
    }
    data.setData(null);
    status =
        secDb.getSearchBoth(
            txn, entry(NUM_RECS + KEY_OFFSET), entry(NUM_RECS), data, LockMode.DEFAULT);
    assertSame(OperationStatus.NOTFOUND, status);

    /* Get a cursor txn. */
    txnCommit(txn);
    txn = txnBeginCursor();

    SecondaryCursor cursor = secDb.openSecondaryCursor(txn, null);
    try {
      /* SecondaryCursor.getFirst()/getNext() */
      secKey.setData(null);
      key.setData(null);
      data.setData(null);
      status = cursor.getFirst(secKey, key, data, LockMode.DEFAULT);
      for (int i = 0; i < NUM_RECS; i += 1) {
        assertSame(OperationStatus.SUCCESS, status);
        assertDataEquals(entry(i + KEY_OFFSET), secKey);
        assertDataEquals(entry(i), key);
        assertDataEquals(entry(i), data);
        assertPriLocked(priDb, key);
        secKey.setData(null);
        key.setData(null);
        data.setData(null);
        status = cursor.getNext(secKey, key, data, LockMode.DEFAULT);
      }
      assertSame(OperationStatus.NOTFOUND, status);

      /* SecondaryCursor.getCurrent() (last) */
      secKey.setData(null);
      key.setData(null);
      data.setData(null);
      status = cursor.getCurrent(secKey, key, data, LockMode.DEFAULT);
      assertSame(OperationStatus.SUCCESS, status);
      assertDataEquals(entry(NUM_RECS - 1 + KEY_OFFSET), secKey);
      assertDataEquals(entry(NUM_RECS - 1), key);
      assertDataEquals(entry(NUM_RECS - 1), data);
      assertPriLocked(priDb, key);

      /* SecondaryCursor.getLast()/getPrev() */
      secKey.setData(null);
      key.setData(null);
      data.setData(null);
      status = cursor.getLast(secKey, key, data, LockMode.DEFAULT);
      for (int i = NUM_RECS - 1; i >= 0; i -= 1) {
        assertSame(OperationStatus.SUCCESS, status);
        assertDataEquals(entry(i + KEY_OFFSET), secKey);
        assertDataEquals(entry(i), key);
        assertDataEquals(entry(i), data);
        assertPriLocked(priDb, key);
        secKey.setData(null);
        key.setData(null);
        data.setData(null);
        status = cursor.getPrev(secKey, key, data, LockMode.DEFAULT);
      }
      assertSame(OperationStatus.NOTFOUND, status);

      /* SecondaryCursor.getCurrent() (first) */
      secKey.setData(null);
      key.setData(null);
      data.setData(null);
      status = cursor.getCurrent(secKey, key, data, LockMode.DEFAULT);
      assertSame(OperationStatus.SUCCESS, status);
      assertDataEquals(entry(0 + KEY_OFFSET), secKey);
      assertDataEquals(entry(0), key);
      assertDataEquals(entry(0), data);
      assertPriLocked(priDb, key);

      /* SecondaryCursor.getSearchKey() */
      key.setData(null);
      data.setData(null);
      status = cursor.getSearchKey(entry(KEY_OFFSET - 1), key, data, LockMode.DEFAULT);
      assertSame(OperationStatus.NOTFOUND, status);
      for (int i = 0; i < NUM_RECS; i += 1) {
        key.setData(null);
        data.setData(null);
        status = cursor.getSearchKey(entry(i + KEY_OFFSET), key, data, LockMode.DEFAULT);
        assertSame(OperationStatus.SUCCESS, status);
        assertDataEquals(entry(i), key);
        assertDataEquals(entry(i), data);
        assertPriLocked(priDb, key);
      }
      key.setData(null);
      data.setData(null);
      status = cursor.getSearchKey(entry(NUM_RECS + KEY_OFFSET), key, data, LockMode.DEFAULT);
      assertSame(OperationStatus.NOTFOUND, status);

      /* SecondaryCursor.getSearchBoth() */
      data.setData(null);
      status = cursor.getSearchKey(entry(KEY_OFFSET - 1), entry(0), data, LockMode.DEFAULT);
      assertSame(OperationStatus.NOTFOUND, status);
      for (int i = 0; i < NUM_RECS; i += 1) {
        data.setData(null);
        status = cursor.getSearchBoth(entry(i + KEY_OFFSET), entry(i), data, LockMode.DEFAULT);
        assertSame(OperationStatus.SUCCESS, status);
        assertDataEquals(entry(i), data);
        assertPriLocked(priDb, entry(i));
      }
      data.setData(null);
      status =
          cursor.getSearchBoth(
              entry(NUM_RECS + KEY_OFFSET), entry(NUM_RECS), data, LockMode.DEFAULT);
      assertSame(OperationStatus.NOTFOUND, status);

      /* SecondaryCursor.getSearchKeyRange() */
      key.setData(null);
      data.setData(null);
      status = cursor.getSearchKeyRange(entry(KEY_OFFSET - 1), key, data, LockMode.DEFAULT);
      assertSame(OperationStatus.SUCCESS, status);
      assertDataEquals(entry(0), key);
      assertDataEquals(entry(0), data);
      assertPriLocked(priDb, key);
      for (int i = 0; i < NUM_RECS; i += 1) {
        key.setData(null);
        data.setData(null);
        status = cursor.getSearchKeyRange(entry(i + KEY_OFFSET), key, data, LockMode.DEFAULT);
        assertSame(OperationStatus.SUCCESS, status);
        assertDataEquals(entry(i), key);
        assertDataEquals(entry(i), data);
        assertPriLocked(priDb, key);
      }
      key.setData(null);
      data.setData(null);
      status = cursor.getSearchKeyRange(entry(NUM_RECS + KEY_OFFSET), key, data, LockMode.DEFAULT);
      assertSame(OperationStatus.NOTFOUND, status);

      /* SecondaryCursor.getSearchBothRange() */
      data.setData(null);
      status = cursor.getSearchBothRange(entry(1 + KEY_OFFSET), entry(1), data, LockMode.DEFAULT);
      assertSame(OperationStatus.SUCCESS, status);
      assertDataEquals(entry(1), data);
      assertPriLocked(priDb, entry(1));
      for (int i = 0; i < NUM_RECS; i += 1) {
        data.setData(null);
        status = cursor.getSearchBothRange(entry(i + KEY_OFFSET), entry(i), data, LockMode.DEFAULT);
        assertSame(OperationStatus.SUCCESS, status);
        assertDataEquals(entry(i), data);
        assertPriLocked(priDb, entry(i));
      }
      data.setData(null);
      status =
          cursor.getSearchBothRange(
              entry(NUM_RECS + KEY_OFFSET), entry(NUM_RECS), data, LockMode.DEFAULT);
      assertSame(OperationStatus.NOTFOUND, status);

      /* Add one duplicate for each key. */
      Cursor priCursor = priDb.openCursor(txn, null);
      try {
        for (int i = 0; i < NUM_RECS; i += 1) {
          status = priCursor.put(entry(i + KEY_OFFSET), entry(i));
          assertSame(OperationStatus.SUCCESS, status);
        }
      } finally {
        priCursor.close();
      }

      /* SecondaryCursor.getNextDup() */
      secKey.setData(null);
      key.setData(null);
      data.setData(null);
      status = cursor.getFirst(secKey, key, data, LockMode.DEFAULT);
      for (int i = 0; i < NUM_RECS; i += 1) {
        assertSame(OperationStatus.SUCCESS, status);
        assertDataEquals(entry(i + KEY_OFFSET), secKey);
        assertDataEquals(entry(i), key);
        assertDataEquals(entry(i), data);
        assertPriLocked(priDb, key, data);
        secKey.setData(null);
        key.setData(null);
        data.setData(null);
        status = cursor.getNextDup(secKey, key, data, LockMode.DEFAULT);
        assertSame(OperationStatus.SUCCESS, status);
        assertDataEquals(entry(i + KEY_OFFSET), secKey);
        assertDataEquals(entry(i + KEY_OFFSET), key);
        assertDataEquals(entry(i), data);
        assertPriLocked(priDb, key, data);
        secKey.setData(null);
        key.setData(null);
        data.setData(null);
        status = cursor.getNextDup(secKey, key, data, LockMode.DEFAULT);
        assertSame(OperationStatus.NOTFOUND, status);
        secKey.setData(null);
        key.setData(null);
        data.setData(null);
        status = cursor.getNext(secKey, key, data, LockMode.DEFAULT);
      }
      assertSame(OperationStatus.NOTFOUND, status);

      /* SecondaryCursor.getNextNoDup() */
      secKey.setData(null);
      key.setData(null);
      data.setData(null);
      status = cursor.getFirst(secKey, key, data, LockMode.DEFAULT);
      for (int i = 0; i < NUM_RECS; i += 1) {
        assertSame(OperationStatus.SUCCESS, status);
        assertDataEquals(entry(i + KEY_OFFSET), secKey);
        assertDataEquals(entry(i), key);
        assertDataEquals(entry(i), data);
        assertPriLocked(priDb, key, data);
        secKey.setData(null);
        key.setData(null);
        data.setData(null);
        status = cursor.getNextNoDup(secKey, key, data, LockMode.DEFAULT);
      }
      assertSame(OperationStatus.NOTFOUND, status);

      /* SecondaryCursor.getPrevDup() */
      secKey.setData(null);
      key.setData(null);
      data.setData(null);
      status = cursor.getLast(secKey, key, data, LockMode.DEFAULT);
      for (int i = NUM_RECS - 1; i >= 0; i -= 1) {
        assertSame(OperationStatus.SUCCESS, status);
        assertDataEquals(entry(i + KEY_OFFSET), secKey);
        assertDataEquals(entry(i + KEY_OFFSET), key);
        assertDataEquals(entry(i), data);
        assertPriLocked(priDb, key, data);
        secKey.setData(null);
        key.setData(null);
        data.setData(null);
        status = cursor.getPrevDup(secKey, key, data, LockMode.DEFAULT);
        assertSame(OperationStatus.SUCCESS, status);
        assertDataEquals(entry(i + KEY_OFFSET), secKey);
        assertDataEquals(entry(i), key);
        assertDataEquals(entry(i), data);
        assertPriLocked(priDb, key, data);
        secKey.setData(null);
        key.setData(null);
        data.setData(null);
        status = cursor.getPrevDup(secKey, key, data, LockMode.DEFAULT);
        assertSame(OperationStatus.NOTFOUND, status);
        secKey.setData(null);
        key.setData(null);
        data.setData(null);
        status = cursor.getPrev(secKey, key, data, LockMode.DEFAULT);
      }
      assertSame(OperationStatus.NOTFOUND, status);

      /* SecondaryCursor.getPrevNoDup() */
      secKey.setData(null);
      key.setData(null);
      data.setData(null);
      status = cursor.getLast(secKey, key, data, LockMode.DEFAULT);
      for (int i = NUM_RECS - 1; i >= 0; i -= 1) {
        assertSame(OperationStatus.SUCCESS, status);
        assertDataEquals(entry(i + KEY_OFFSET), secKey);
        assertDataEquals(entry(i + KEY_OFFSET), key);
        assertDataEquals(entry(i), data);
        assertPriLocked(priDb, key, data);
        secKey.setData(null);
        key.setData(null);
        data.setData(null);
        status = cursor.getPrevNoDup(secKey, key, data, LockMode.DEFAULT);
      }
      assertSame(OperationStatus.NOTFOUND, status);
    } finally {
      cursor.close();
    }

    txnCommit(txn);
    secDb.close();
    priDb.close();
  }
Ejemplo n.º 10
0
  /**
   * Test that an exception is thrown when a cursor is used in the wrong state. No put or get is
   * allowed in the closed state, and certain gets and puts are not allowed in the uninitialized
   * state.
   */
  public void testCursorState() throws DatabaseException {

    SecondaryDatabase secDb = initDb();
    Database priDb = secDb.getPrimaryDatabase();
    Transaction txn = txnBegin();

    DatabaseEntry key = entry(0);
    DatabaseEntry data = entry(0);
    DatabaseEntry secKey = entry(KEY_OFFSET);
    DatabaseEntry found = new DatabaseEntry();
    DatabaseEntry found2 = new DatabaseEntry();

    assertEquals(OperationStatus.SUCCESS, priDb.put(txn, key, data));

    txnCommit(txn);
    txn = txnBeginCursor();
    Cursor cursor = priDb.openCursor(txn, null);
    SecondaryCursor secCursor = secDb.openSecondaryCursor(txn, null);

    /* Check the uninitialized state for certain operations. */

    try {
      cursor.count();
      fail();
    } catch (DatabaseException expected) {
    }
    try {
      cursor.delete();
      fail();
    } catch (DatabaseException expected) {
    }
    try {
      cursor.putCurrent(data);
      fail();
    } catch (DatabaseException expected) {
    }
    try {
      cursor.getCurrent(key, data, null);
      fail();
    } catch (DatabaseException expected) {
    }
    try {
      cursor.getNextDup(found, found2, null);
      fail();
    } catch (DatabaseException expected) {
    }
    try {
      cursor.getPrevDup(found, found2, null);
      fail();
    } catch (DatabaseException expected) {
    }

    try {
      secCursor.count();
      fail();
    } catch (DatabaseException expected) {
    }
    try {
      secCursor.delete();
      fail();
    } catch (DatabaseException expected) {
    }
    try {
      secCursor.getCurrent(key, data, null);
      fail();
    } catch (DatabaseException expected) {
    }
    try {
      secCursor.getNextDup(found, found2, null);
      fail();
    } catch (DatabaseException expected) {
    }
    try {
      secCursor.getPrevDup(found, found2, null);
      fail();
    } catch (DatabaseException expected) {
    }

    /* Initialize, then close, then check all operations. */

    assertEquals(OperationStatus.SUCCESS, cursor.getSearchKey(key, found, null));
    assertEquals(OperationStatus.SUCCESS, secCursor.getSearchKey(secKey, found, null));
    secCursor.close();
    cursor.close();

    try {
      cursor.close();
      fail();
    } catch (DatabaseException expected) {
    }
    try {
      cursor.count();
      fail();
    } catch (DatabaseException expected) {
    }
    try {
      cursor.delete();
      fail();
    } catch (DatabaseException expected) {
    }
    try {
      cursor.put(key, data);
      fail();
    } catch (DatabaseException expected) {
    }
    try {
      cursor.putNoOverwrite(key, data);
      fail();
    } catch (DatabaseException expected) {
    }
    try {
      cursor.putNoDupData(key, data);
      fail();
    } catch (DatabaseException expected) {
    }
    try {
      cursor.putCurrent(data);
      fail();
    } catch (DatabaseException expected) {
    }
    try {
      cursor.getCurrent(key, data, null);
      fail();
    } catch (DatabaseException expected) {
    }
    try {
      cursor.getSearchKey(key, found, null);
      fail();
    } catch (DatabaseException expected) {
    }
    try {
      cursor.getSearchBoth(key, data, null);
      fail();
    } catch (DatabaseException expected) {
    }
    try {
      cursor.getSearchKeyRange(key, found, null);
      fail();
    } catch (DatabaseException expected) {
    }
    try {
      cursor.getSearchBothRange(key, data, null);
      fail();
    } catch (DatabaseException expected) {
    }
    try {
      cursor.getFirst(found, found2, null);
      fail();
    } catch (DatabaseException expected) {
    }
    try {
      cursor.getNext(found, found2, null);
      fail();
    } catch (DatabaseException expected) {
    }
    try {
      cursor.getPrev(found, found2, null);
      fail();
    } catch (DatabaseException expected) {
    }
    try {
      cursor.getNextDup(found, found2, null);
      fail();
    } catch (DatabaseException expected) {
    }
    try {
      cursor.getPrevDup(found, found2, null);
      fail();
    } catch (DatabaseException expected) {
    }
    try {
      cursor.getNextNoDup(found, found2, null);
      fail();
    } catch (DatabaseException expected) {
    }
    try {
      cursor.getPrevNoDup(found, found2, null);
      fail();
    } catch (DatabaseException expected) {
    }
    try {
      cursor.getLast(found, found2, null);
      fail();
    } catch (DatabaseException expected) {
    }

    try {
      secCursor.close();
      fail();
    } catch (DatabaseException expected) {
    }
    try {
      secCursor.count();
      fail();
    } catch (DatabaseException expected) {
    }
    try {
      secCursor.delete();
      fail();
    } catch (DatabaseException expected) {
    }
    try {
      secCursor.getCurrent(key, data, null);
      fail();
    } catch (DatabaseException expected) {
    }
    try {
      secCursor.getSearchKey(secKey, found, null);
      fail();
    } catch (DatabaseException expected) {
    }
    try {
      secCursor.getSearchKeyRange(secKey, found, null);
      fail();
    } catch (DatabaseException expected) {
    }
    try {
      secCursor.getFirst(found, found2, null);
      fail();
    } catch (DatabaseException expected) {
    }
    try {
      secCursor.getNext(found, found2, null);
      fail();
    } catch (DatabaseException expected) {
    }
    try {
      secCursor.getPrev(found, found2, null);
      fail();
    } catch (DatabaseException expected) {
    }
    try {
      secCursor.getNextDup(found, found2, null);
      fail();
    } catch (DatabaseException expected) {
    }
    try {
      secCursor.getPrevDup(found, found2, null);
      fail();
    } catch (DatabaseException expected) {
    }
    try {
      secCursor.getNextNoDup(found, found2, null);
      fail();
    } catch (DatabaseException expected) {
    }
    try {
      secCursor.getPrevNoDup(found, found2, null);
      fail();
    } catch (DatabaseException expected) {
    }
    try {
      secCursor.getLast(found, found2, null);
      fail();
    } catch (DatabaseException expected) {
    }

    txnCommit(txn);
    secDb.close();
    priDb.close();
    env.close();
    env = null;
  }