import com.sleepycat.persist.SecondaryIndex; //导入依赖的package包/类
@Override
void readObjects(EntityStore store, boolean doUpdate)
    throws DatabaseException {

    PrimaryIndex<Integer,RenamedEntity2_NewEntityName_WithRenamer>
        index = store.getPrimaryIndex
            (Integer.class,
             RenamedEntity2_NewEntityName_WithRenamer.class);
    RenamedEntity2_NewEntityName_WithRenamer obj = index.get(key);
    TestCase.assertNotNull(obj);
    TestCase.assertEquals(99, obj.key);
    TestCase.assertEquals(88, obj.skey);

    SecondaryIndex<Integer,Integer,
                   RenamedEntity2_NewEntityName_WithRenamer>
        sindex = store.getSecondaryIndex(index, Integer.class, "skey");
    obj = sindex.get(88);
    TestCase.assertNotNull(obj);
    TestCase.assertEquals(99, obj.key);
    TestCase.assertEquals(88, obj.skey);

    if (doUpdate) {
        index.put(obj);
    }
}
 

import com.sleepycat.persist.SecondaryIndex; //导入依赖的package包/类
/**
 * When opening an X_TO_MANY secondary that has a persistent key class, the
 * key class was not recognized as being persistent if it was never before
 * referenced when getSecondaryIndex was called.  This was a bug in JE
 * 3.0.12, reported on OTN.  [#15103]
 */
public void testToManyKeyClass()
    throws DatabaseException {

    open();

    PrimaryIndex<Integer,ToManyKeyEntity> priIndex =
        store.getPrimaryIndex(Integer.class, ToManyKeyEntity.class);
    SecondaryIndex<ToManyKey,Integer,ToManyKeyEntity> secIndex =
        store.getSecondaryIndex(priIndex, ToManyKey.class, "key2");

    priIndex.put(new ToManyKeyEntity());
    secIndex.get(new ToManyKey());

    close();
}
 

import com.sleepycat.persist.SecondaryIndex; //导入依赖的package包/类
/**
 * Test a fix for a bug where opening a TO_MANY secondary index would fail
 * fail with "IllegalArgumentException: Wrong secondary key class: ..."
 * when the store was opened read-only.  [#15156]
 */
public void testToManyReadOnly()
    throws DatabaseException {

    open();
    PrimaryIndex<Integer,ToManyKeyEntity> priIndex =
        store.getPrimaryIndex(Integer.class, ToManyKeyEntity.class);
    priIndex.put(new ToManyKeyEntity());
    close();

    openReadOnly();
    priIndex = store.getPrimaryIndex(Integer.class, ToManyKeyEntity.class);
    SecondaryIndex<ToManyKey,Integer,ToManyKeyEntity> secIndex =
        store.getSecondaryIndex(priIndex, ToManyKey.class, "key2");
    secIndex.get(new ToManyKey());
    close();
}
 

import com.sleepycat.persist.SecondaryIndex; //导入依赖的package包/类
/**
 * Do a "AND" join on a single primary database, similar to the SQL:
 * <blockquote><pre>
 * SELECT * FROM table WHERE col1 = key1 AND col2 = key2;
 * </pre></blockquote>
 *
 * @param pk
 * @param sk1
 * @param key1
 * @param sk2
 * @param key2
 * @return
 * @throws DatabaseException
 */
public <PK, SK1, SK2, E> ForwardCursor<E>
    doTwoConditionsJoin(PrimaryIndex<PK, E> pk,
                        SecondaryIndex<SK1, PK, E> sk1,
                        SK1 key1,
                        SecondaryIndex<SK2, PK, E> sk2,
                        SK2 key2)
    throws DatabaseException {

    assert (pk != null);
    assert (sk1 != null);
    assert (sk2 != null);

    EntityJoin<PK, E> join = new EntityJoin<PK, E>(pk);
    join.addCondition(sk1, key1);
    join.addCondition(sk2, key2);

    return join.entities();
}
 

import com.sleepycat.persist.SecondaryIndex; //导入依赖的package包/类
/**
 * Do a "AND" join on a single primary database, similar to the SQL:
 * <blockquote><pre>
 * SELECT * FROM table WHERE col1 = key1 AND col2 = key2 AND col3 = key3;
 * </pre></blockquote>
 */
public <PK, SK1, SK2, SK3, E> ForwardCursor<E> query(PrimaryIndex<PK, E> pk,
                        SecondaryIndex<SK1, PK, E> sk1, SK1 key1,
                        SecondaryIndex<SK2, PK, E> sk2, SK2 key2,
                        SecondaryIndex<SK3, PK, E> sk3, SK3 key3) {
    return join(pk).join(sk1, key1).join(sk2, key2).join(sk3, key3).entities();
}
 

import com.sleepycat.persist.SecondaryIndex; //导入依赖的package包/类
/**
 * @see EntityStore#getSubclassIndex(PrimaryIndex, Class, Class, String)
 */
public <SK, PK, E1, E2 extends E1> SecondaryIndex<SK, PK, E2>
    getSubclassIndex(PrimaryIndex<PK, E1> primaryIndex,
                     Class<E2> entitySubclass, Class<SK> keyClass,
                     String keyName) throws DatabaseException {
    return delegate().getSubclassIndex(primaryIndex, entitySubclass, keyClass, keyName);
}
 

import com.sleepycat.persist.SecondaryIndex; //导入依赖的package包/类
/**
 * @see BerkeleyStore#query(com.sleepycat.persist.EntityIndex, String)
 */
public <SK> List<E> findPrefix(String keyName, String prefix) {
    SecondaryIndex<SK, PK, E> secondaryIndex = getRegisterSK(keyName);
    Class<SK> classSK = secondaryIndex.getKeyClass();
    checkArgument(String.class == classSK, "The secondary index class type must be java.lang.String.class, but is %s", classSK);
    
    @SuppressWarnings("unchecked") SecondaryIndex<String, PK, E> idx = (SecondaryIndex<String, PK, E>) secondaryIndex;
    return all(store.query(idx, checkNotNull(prefix)));
}
 

import com.sleepycat.persist.SecondaryIndex; //导入依赖的package包/类
/**
 * Returns the items with given field and key list, one key returns one item
 */
public <SK> List<E> gets(String keyName, List<SK> keys) {
    SecondaryIndex<SK, PK, E> indexSK = getRegisterSK(keyName);
    E item = null; List<E> items = Lists.newArrayListWithCapacity(checkNotNull(keys).size());
    
    for (SK sk : keys) {
        if (null == (item = one(indexSK.subIndex(sk).entities()))) {
            log.warn(String.format("The Field %s's key: %s is none exists.", keyName, sk));
        } else {
            items.add(item);
        }
    }
    
    return items;
}
 

import com.sleepycat.persist.SecondaryIndex; //导入依赖的package包/类
/**
 * Opens the secondary index for a given entity class and secondary key
 * name.
 */
public SecondaryIndex<Object,Object,RawObject>
    getSecondaryIndex(String entityClass, String keyName)
    throws DatabaseException {

    return store.getSecondaryIndex
        (getPrimaryIndex(entityClass), RawObject.class, entityClass,
         Object.class, null, keyName);
}
 

import com.sleepycat.persist.SecondaryIndex; //导入依赖的package包/类
private void checkSecondary(SecondaryIndex<Integer,Integer,MyEntity> index,
                            SecondaryIndex<Object,Object,RawObject>
                            indexRaw,
                            SortedMap<Integer,SortedSet<Integer>> expected)
    throws DatabaseException {

    checkIndex(index, expected, keyGetter, entityGetter);
    checkIndex(index.keysIndex(), expected, keyGetter, keyGetter);

    checkIndex(indexRaw, expected, rawKeyGetter, rawEntityGetter);
    checkIndex(indexRaw.keysIndex(), expected, rawKeyGetter, rawKeyGetter);

    SortedMap<Integer,SortedSet<Integer>> expectedSubIndex =
        new TreeMap<Integer,SortedSet<Integer>>();

    for (Integer secKey : expected.keySet()) {
        expectedSubIndex.clear();
        for (Integer priKey : expected.get(secKey)) {
            SortedSet<Integer> values = new TreeSet<Integer>();
            values.add(priKey);
            expectedSubIndex.put(priKey, values);
        }
        checkIndex(index.subIndex(secKey),
                   expectedSubIndex,
                   keyGetter,
                   entityGetter);
        checkIndex(indexRaw.subIndex(secKey),
                   expectedSubIndex,
                   rawKeyGetter,
                   rawEntityGetter);
    }
}
 

import com.sleepycat.persist.SecondaryIndex; //导入依赖的package包/类
public void testCursorCount()
    throws DatabaseException {

    open();

    PrimaryIndex<Integer,MyEntity> priIndex =
        store.getPrimaryIndex(Integer.class, MyEntity.class);

    SecondaryIndex<Integer,Integer,MyEntity> secIndex =
        store.getSecondaryIndex(priIndex, Integer.class, "secKey");

    Transaction txn = txnBeginCursor();

    MyEntity e = new MyEntity();
    e.priKey = 1;
    e.secKey = 1;
    priIndex.put(txn, e);

    EntityCursor<MyEntity> cursor = secIndex.entities(txn, null);
    cursor.next();
    assertEquals(1, cursor.count());
    cursor.close();

    e.priKey = 2;
    priIndex.put(txn, e);
    cursor = secIndex.entities(txn, null);
    cursor.next();
    assertEquals(2, cursor.count());
    cursor.close();

    txnCommit(txn);
    close();
}
 

import com.sleepycat.persist.SecondaryIndex; //导入依赖的package包/类
public void testCursorCount() 
    throws DatabaseException {

    open();

    PrimaryIndex<Integer,MyEntity> priIndex =
        store.getPrimaryIndex(Integer.class, MyEntity.class);

    SecondaryIndex<Integer,Integer,MyEntity> secIndex =
        store.getSecondaryIndex(priIndex, Integer.class, "secKey");

    Transaction txn = txnBeginCursor();

    MyEntity e = new MyEntity();
    e.priKey = 1;
    e.secKey = 1;
    priIndex.put(txn, e);

    EntityCursor<MyEntity> cursor = secIndex.entities(txn, null);
    cursor.next();
    assertEquals(1, cursor.count());
    cursor.close();

    e.priKey = 2;
    priIndex.put(txn, e);
    cursor = secIndex.entities(txn, null);
    cursor.next();
    assertEquals(2, cursor.count());
    cursor.close();

    txnCommit(txn);
    close();
}
 

import com.sleepycat.persist.SecondaryIndex; //导入依赖的package包/类
/**
 * Opens the secondary index for a given entity class and secondary key
 * name.
 *
 * @throws DatabaseException the base class for all BDB exceptions.
 */
public SecondaryIndex<Object, Object, RawObject>
    getSecondaryIndex(String entityClass, String keyName)
    throws DatabaseException {

    return store.getSecondaryIndex
        (getPrimaryIndex(entityClass), RawObject.class, entityClass,
         Object.class, null, keyName);
}
 

import com.sleepycat.persist.SecondaryIndex; //导入依赖的package包/类
public <SK> EntityJoinQuery<PK, E> join(SecondaryIndex<SK, PK, E> index, SK key) {
    if (null != index && null != key) {
        addCondition(index, key);
    }
    return this;
}
 

import com.sleepycat.persist.SecondaryIndex; //导入依赖的package包/类
/**
 * @see EntityStore#getSecondaryIndex(PrimaryIndex, Class, String)
 */
public <SK, PK, E> SecondaryIndex<SK, PK, E> getSecondaryIndex(
        PrimaryIndex<PK, E> primaryIndex, Class<SK> keyClass, String keyName) throws DatabaseException {
    return delegate().getSecondaryIndex(primaryIndex, keyClass, keyName);
}
 

import com.sleepycat.persist.SecondaryIndex; //导入依赖的package包/类
/**
 * @see BerkeleyStore#getSecondaryIndex(PrimaryIndex, Class, String)
 */
public <SK> SecondaryIndex<SK, PK, E> getSK(Class<SK> keyClass, String keyName) {
    return store.getSecondaryIndex(getPK(), checkNotNull(keyClass), checkNotNull(keyName));
}
 

import com.sleepycat.persist.SecondaryIndex; //导入依赖的package包/类
/**
 * @see BerkeleyStore#getSecondaryIndex(PrimaryIndex, Class, String)
 */
public <SK> SecondaryIndex<SK, PK, E> registerSK(Class<SK> keyClass, String keyName) {
    SecondaryIndex<SK, PK, E> secondaryIdx = getSK(keyClass, keyName);
    secondaryIndexs.put(keyName, secondaryIdx);
    return secondaryIdx;
}
 

import com.sleepycat.persist.SecondaryIndex; //导入依赖的package包/类
/**
 * 
 */
public <SK> SecondaryIndex<SK, PK, E> getRegisterSK(String keyName) {
    @SuppressWarnings("unchecked") SecondaryIndex<SK, PK, E> secondaryIdx = 
            (SecondaryIndex<SK, PK, E>) secondaryIndexs.get(checkNotNull(keyName));
    return checkNotNull(secondaryIdx, "The secondary index key name: %s has not register, use registerSK first.", keyName);
}
 

import com.sleepycat.persist.SecondaryIndex; //导入依赖的package包/类
public SecondaryIndex<String, Long, PostalCode> getPostalCodeProvince() {
    return postalCodeProvince;
}
 

import com.sleepycat.persist.SecondaryIndex; //导入依赖的package包/类
public SecondaryIndex<String, Long, PostalCode> getPostalCodeMunicipality() {
    return postalCodeMunicipality;
}