import com.googlecode.cqengine.index.navigable.NavigableIndex; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public void createIndex(String fieldName, boolean multiValued) {

    if (!holder.indexed.contains(fieldName)) {
        synchronized (maps) {
            if (!holder.indexed.contains(fieldName)) {
                try {
                    Attribute<Value, String> attribute = getAttribute(fieldName, multiValued);
                    holder.attributes.put(fieldName, attribute);
                    holder.db.addIndex(NavigableIndex.onAttribute(attribute));
                    holder.db.addIndex(RadixTreeIndex.onAttribute(attribute));
                } catch (Throwable e) {
                    context.logger(getClass()).onError(e);
                } finally {
                    holder.indexed.add(fieldName);
                }
            }
        }
    }
}
 

import com.googlecode.cqengine.index.navigable.NavigableIndex; //导入依赖的package包/类
public static void main(String[] args) {
    final int NUM_ITERATIONS = 1000;
    final int[] numObjects = {10000, 10000, 100000};
    final double[] selectivityThreshold = {0.0, 0.5, 1.0};

    IndexedCollection<Car> cars = new ConcurrentIndexedCollection<Car>();
    cars.addAll(CarFactory.createCollectionOfCars(1000000));

    cars.addIndex(NavigableIndex.onAttribute(Car.CAR_ID));
    cars.addIndex(NavigableIndex.onAttribute(Car.COLOR));

    for (int n : numObjects) {
        for (double s : selectivityThreshold) {
            long start = System.currentTimeMillis();
            long count = 0;
            for (int i = 0; i < NUM_ITERATIONS; i++) {
                count = countRetrievedResults(cars, n, s);
            }
            long timeTaken = System.currentTimeMillis() - start;
            System.out.println("Number: " + n + ", selectivity threshold: " + s + ", time taken per iteration: " + (timeTaken / (double)NUM_ITERATIONS) + " (count=" + count + ")");
        }
    }
}
 

import com.googlecode.cqengine.index.navigable.NavigableIndex; //导入依赖的package包/类
public static void main(String[] args) {
    IndexedCollection<Car> cars = new ConcurrentIndexedCollection<Car>();
    cars.addIndex(NavigableIndex.onAttribute(Car.FEATURES));
    cars.addIndex(NavigableIndex.onAttribute(forObjectsMissing(Car.FEATURES)));
    cars.addAll(CarFactory.createCollectionOfCars(100));

    ResultSet<Car> results = cars.retrieve(
            between(Car.CAR_ID, 40, 50),
            queryOptions(
                    orderBy(ascending(missingLast(Car.FEATURES))),
                    applyThresholds(threshold(INDEX_ORDERING_SELECTIVITY, 1.0))
            )
    );
    for (Car car : results) {
        System.out.println(car); // prints cars 40 -> 50, using the index on Car.FEATURES to accelerate ordering
    }
}
 

import com.googlecode.cqengine.index.navigable.NavigableIndex; //导入依赖的package包/类
@Test
public void testInMany() {
    // Create an indexed collection (note: could alternatively use CQEngine.copyFrom() existing collection)...
    IndexedCollection<Car> cars = new ConcurrentIndexedCollection<Car>();

    Attribute<Car, String> NAME = new SimpleNullableAttribute<Car, String>("name") {
        public String getValue(Car car, QueryOptions queryOptions) {
            return car.name;
        }
    };
    cars.addIndex(NavigableIndex.onAttribute(NAME));

    // Add some objects to the collection...
    cars.add(new Car(1, "ford", null, null));
    cars.add(new Car(2, "honda", null, null));
    cars.add(new Car(3, "toyota", null, null));

    Assert.assertEquals(cars.retrieve(in(NAME, "ford", "honda")).size(), 2);
    Assert.assertEquals(cars.retrieve(in(NAME, Arrays.asList("ford", "honda"))).size(), 2);
}
 

import com.googlecode.cqengine.index.navigable.NavigableIndex; //导入依赖的package包/类
@Test
public void testInOne() {
    // Create an indexed collection (note: could alternatively use CQEngine.copyFrom() existing collection)...
    IndexedCollection<Car> cars = new ConcurrentIndexedCollection<Car>();

    Attribute<Car, String> NAME = new SimpleNullableAttribute<Car, String>("name") {
        public String getValue(Car car, QueryOptions queryOptions) {
            return car.name;
        }
    };
    cars.addIndex(NavigableIndex.onAttribute(NAME));

    // Add some objects to the collection...
    cars.add(new Car(1, "ford", null, null));
    cars.add(new Car(2, "honda", null, null));
    cars.add(new Car(3, "toyota", null, null));

    Assert.assertEquals(cars.retrieve(in(NAME, "ford")).size(), 1);
    Assert.assertEquals(cars.retrieve(in(NAME, Collections.singletonList("ford"))).size(), 1);
}
 

import com.googlecode.cqengine.index.navigable.NavigableIndex; //导入依赖的package包/类
@Test
public void testInNone() {
    // Create an indexed collection (note: could alternatively use CQEngine.copyFrom() existing collection)...
    IndexedCollection<Car> cars = new ConcurrentIndexedCollection<Car>();

    Attribute<Car, String> NAME = new SimpleNullableAttribute<Car, String>("name") {
        public String getValue(Car car, QueryOptions queryOptions) {
            return car.name;
        }
    };
    cars.addIndex(NavigableIndex.onAttribute(NAME));

    // Add some objects to the collection...
    cars.add(new Car(1, "ford", null, null));
    cars.add(new Car(2, "honda", null, null));
    cars.add(new Car(3, "toyota", null, null));

    Assert.assertEquals(cars.retrieve(in(NAME)).size(), 0);
    Assert.assertEquals(cars.retrieve(in(NAME, new ArrayList<String>())).size(), 0);
}
 

import com.googlecode.cqengine.index.navigable.NavigableIndex; //导入依赖的package包/类
@Test
public void testMapFunctionality() {
    IndexedCollection<Map> cars = new ConcurrentIndexedCollection<Map>();

    cars.addIndex(HashIndex.onAttribute(COLOR));
    cars.addIndex(NavigableIndex.onAttribute(DOORS));
    cars.addIndex(RadixTreeIndex.onAttribute(MODEL));
    cars.addIndex(ReversedRadixTreeIndex.onAttribute(MODEL));
    cars.addIndex(InvertedRadixTreeIndex.onAttribute(MODEL));
    cars.addIndex(SuffixTreeIndex.onAttribute(MODEL));

    cars.add(buildNewCar(1, "Ford",   "Focus",  Car.Color.BLUE,  5, 9000.50, Collections.<String>emptyList()));
    cars.add(buildNewCar(2, "Ford",   "Fiesta", Car.Color.BLUE,  2, 5000.00, Collections.<String>emptyList()));
    cars.add(buildNewCar(3, "Ford",   "F-150",  Car.Color.RED,   2, 9500.00, Collections.<String>emptyList()));
    cars.add(buildNewCar(4, "Honda",  "Civic",  Car.Color.RED,   5, 5000.00, Collections.<String>emptyList()));
    cars.add(buildNewCar(5, "Toyota", "Prius",  Car.Color.BLACK, 3, 9700.00, Collections.<String>emptyList()));

    // Ford cars...
    assertThat(carIdsIn(cars.retrieve(equal(MANUFACTURER, "Ford"))), is(setOf(1, 2, 3)));

    // 3-door cars...
    assertThat(carIdsIn(cars.retrieve(equal(DOORS, 3))), is(setOf(5)));

    // 2 or 3-door cars...
    assertThat(carIdsIn(cars.retrieve(between(DOORS, 2, 3))), is(setOf(2, 3, 5)));

    // 2 or 5-door cars...
    assertThat(carIdsIn(cars.retrieve(in(DOORS, 2, 5))), is(setOf(1, 2, 3, 4)));

    // Blue Ford cars...
    assertThat(carIdsIn(cars.retrieve(and(equal(COLOR, Car.Color.BLUE),
            equal(MANUFACTURER, "Ford")))), is(setOf(1, 2)));

    // NOT 3-door cars...
    assertThat(carIdsIn(cars.retrieve(not(equal(DOORS, 3)))),
            is(setOf(1, 2, 3, 4)));

    // Cars which have 5 doors and which are not red...
    assertThat(carIdsIn(cars.retrieve(and(equal(DOORS, 5), not(equal(COLOR, Car.Color.RED))))), is(setOf(1)));

    // Cars whose model starts with 'F'...
    assertThat(carIdsIn(cars.retrieve(startsWith(MODEL, "F"))), is(setOf(1, 2, 3)));

    // Cars whose model ends with 's'...
    assertThat(carIdsIn(cars.retrieve(endsWith(MODEL, "s"))), is(setOf(1, 5)));

    // Cars whose model contains 'i'...
    assertThat(carIdsIn(cars.retrieve(contains(MODEL, "i"))), is(setOf(2, 4, 5)));

    // Cars whose model is contained in 'Banana, Focus, Civic, Foobar'...
    assertThat(carIdsIn(cars.retrieve(isContainedIn(MODEL, "Banana, Focus, Civic, Foobar"))), is(setOf(1, 4)));

    // NOT 3-door cars, sorted by doors ascending...
    assertThat(
            carIdsIn(cars.retrieve(not(equal(DOORS, 3)), queryOptions(orderBy(ascending(DOORS), ascending(MODEL))))).toString(),
            is(equalTo(setOf(3, 2, 4, 1).toString()))
    );

    // NOT 3-door cars, sorted by doors ascending then price descending...
    assertThat(
            carIdsIn(
                    cars.retrieve(
                            not(equal(DOORS, 3)),
                            queryOptions(
                                    orderBy(ascending(DOORS),
                                            descending(PRICE))
                            )
                    )
            ),
            is(equalTo(setOf(3, 2, 1, 4)))
    );
}
 

import com.googlecode.cqengine.index.navigable.NavigableIndex; //导入依赖的package包/类
@Override
protected List<IndexCapabilities> getIndexMatrix() {
    return Arrays.asList(
            new IndexCapabilities<Attribute>("Hash",
                                             new IndexFeature[]{IndexFeature.EQ, IndexFeature.IN, IndexFeature.QZ},
                                             attr -> HashIndex.onAttribute(compatibleAttribute(attr))),
            new IndexCapabilities<Attribute>("Unique",
                                             new IndexFeature[]{IndexFeature.UNIQUE, IndexFeature.EQ, IndexFeature.IN},
                                             attr -> UniqueIndex.onAttribute(compatibleAttribute(attr))),
            new IndexCapabilities<Attribute[]>("Compound",
                                               new IndexFeature[]{IndexFeature.COMPOUND, IndexFeature.EQ, IndexFeature.IN, IndexFeature.QZ},
                                               attrs -> {
                                                   Attribute[] attributes = (Attribute[]) Arrays.stream(attrs)
                                                                                                .map(attr -> compatibleAttribute(attr))
                                                                                                .toArray();
                                                   return CompoundIndex.onAttributes(attributes);
                                               }),
            new IndexCapabilities<Attribute>("Navigable",
                                             new IndexFeature[]{IndexFeature.EQ, IndexFeature.IN, IndexFeature.QZ, IndexFeature.LT, IndexFeature.GT, IndexFeature.BT},
                                             attr -> NavigableIndex.onAttribute(compatibleAttribute(attr))),
            new IndexCapabilities<Attribute>("RadixTree",
                                             new IndexFeature[]{IndexFeature.EQ, IndexFeature.IN, IndexFeature.SW},
                                             attr -> RadixTreeIndex.onAttribute(compatibleAttribute(attr))),
            new IndexCapabilities<Attribute>("ReversedRadixTree",
                                             new IndexFeature[]{IndexFeature.EQ, IndexFeature.IN, IndexFeature.EW},
                                             attr -> ReversedRadixTreeIndex.onAttribute(compatibleAttribute(attr))),
            new IndexCapabilities<Attribute>("InvertedRadixTree",
                                             new IndexFeature[]{IndexFeature.EQ, IndexFeature.IN, IndexFeature.CI},
                                             attr -> InvertedRadixTreeIndex.onAttribute(compatibleAttribute(attr))),
            new IndexCapabilities<Attribute>("SuffixTree",
                                             new IndexFeature[]{IndexFeature.EQ, IndexFeature.IN, IndexFeature.EW, IndexFeature.SC},
                                             attr -> SuffixTreeIndex.onAttribute(compatibleAttribute(attr)))
    );

}
 

import com.googlecode.cqengine.index.navigable.NavigableIndex; //导入依赖的package包/类
/**
 *
 * @param attr the attribute against which the
 * index will be built
 * @return an instance of {@link NavigableIndex}
 */
@Override @SuppressWarnings({"unchecked","rawtypes"})
public Index<O> getIndex(Attribute<O,?> attribute) {
    if(Comparable.class.isAssignableFrom(attribute.getAttributeType()))
        return NavigableIndex.onAttribute((Attribute < O, ? extends Comparable>)attribute);
    
    throw new IllegalArgumentException(NavigableIndex.class.getName() 
            + " cannot be applied on " 
            + attribute.getAttributeName() 
            + " because it does not extend " 
            + Comparable.class.getName());
}
 

import com.googlecode.cqengine.index.navigable.NavigableIndex; //导入依赖的package包/类
private void indexCollection(List<Item> list) {
    items.addAll(list);
    items.addIndex(HashIndex.onAttribute(Item.ITEM_ID));
    items.addIndex(HashIndex.onAttribute(Item.ITEM_NAME));
    items.addIndex(SuffixTreeIndex.onAttribute(Item.ITEM_NAME));
    items.addIndex(SuffixTreeIndex.onAttribute(Item.ITEM_DESCRIPTION));
    items.addIndex(NavigableIndex.onAttribute(Item.ITEM_QUANTITY));
}
 

import com.googlecode.cqengine.index.navigable.NavigableIndex; //导入依赖的package包/类
@Override
public void init(Collection<Car> collection) {
    this.collection = collection;
    IndexedCollection<Car> indexedCollection1 = new ConcurrentIndexedCollection<Car>();
    indexedCollection1.addAll(collection);
    this.indexedCollection = indexedCollection1;
    this.indexedCollection.addIndex(NavigableIndex.onAttribute(Car.PRICE));
}
 

import com.googlecode.cqengine.index.navigable.NavigableIndex; //导入依赖的package包/类
@Override
public void init(Collection<Car> collection) {
    this.collection = collection;
    IndexedCollection<Car> indexedCollection1 = new ConcurrentIndexedCollection<Car>();
    indexedCollection1.addAll(collection);
    this.indexedCollection = indexedCollection1;
    this.indexedCollection.addIndex(
            NavigableIndex.withQuantizerOnAttribute(IntegerQuantizer.withCompressionFactor(5), Car.CAR_ID)
    );
}
 

import com.googlecode.cqengine.index.navigable.NavigableIndex; //导入依赖的package包/类
/**
 * Creates an IndexedCollection and adds NavigableIndexes for the given attributes.
 *
 * @param attributes Attributes for which indexes should be added
 * @param <O> Type of objects stored in the collection
 * @return An IndexedCollection configured with indexes on the given attributes.
 */
public static <O> IndexedCollection<O> newAutoIndexedCollection(Iterable<Attribute<O, Comparable>> attributes) {
    IndexedCollection<O> autoIndexedCollection = new ConcurrentIndexedCollection<O>();
    for (Attribute<O, ? extends Comparable> attribute : attributes) {
        // Add a NavigableIndex...
        @SuppressWarnings("unchecked")
        NavigableIndex<? extends Comparable, O> index = NavigableIndex.onAttribute(attribute);
        autoIndexedCollection.addIndex(index);
    }
    return autoIndexedCollection;
}
 

import com.googlecode.cqengine.index.navigable.NavigableIndex; //导入依赖的package包/类
@Test
public void testAddNonDuplicateIndex() throws Exception {
    CollectionQueryEngine<Car> queryEngine = new CollectionQueryEngine<Car>();
    QueryOptions queryOptions = new QueryOptions();
    queryOptions.put(Persistence.class, OnHeapPersistence.withoutPrimaryKey());
    queryEngine.init(emptyObjectStore(), queryOptions);

    queryEngine.addIndex(HashIndex.onAttribute(Car.MANUFACTURER), noQueryOptions());
    queryEngine.addIndex(NavigableIndex.onAttribute(Car.MANUFACTURER), noQueryOptions());
}
 

import com.googlecode.cqengine.index.navigable.NavigableIndex; //导入依赖的package包/类
@Test
public void testWrappingPersistence() {
    Collection<Car> backingCollection = new LinkedHashSet<Car>();
    backingCollection.addAll(CarFactory.createCollectionOfCars(3)); // CarIds 0, 1, 2

    IndexedCollection<Car> indexedCollection = new ConcurrentIndexedCollection<Car>(
            WrappingPersistence.aroundCollection(backingCollection)
    );

    indexedCollection.addIndex(NavigableIndex.onAttribute(Car.CAR_ID));

    ResultSet<Car> results = indexedCollection.retrieve(greaterThan(Car.CAR_ID, 0));

    // Assert that the index will be used...
    assertNotEquals(Integer.MAX_VALUE, results.getRetrievalCost());

    // Assert correct results are returned...
    Set<Integer> expectedCarIds, actualCarIds;
    expectedCarIds = asSet(1, 2);
    actualCarIds = extractCarIds(results, new HashSet<Integer>());
    assertEquals(expectedCarIds, actualCarIds);

    // Add that a new object added to the IndexedCollection...
    indexedCollection.add(CarFactory.createCar(3));

    // Assert the new object was added to the backing collection...
    expectedCarIds = asSet(0, 1, 2, 3);
    actualCarIds = extractCarIds(backingCollection, new HashSet<Integer>());
    assertEquals(expectedCarIds, actualCarIds);
}
 

import com.googlecode.cqengine.index.navigable.NavigableIndex; //导入依赖的package包/类
@Test
public void testSupportsIndex() throws Exception {
    WrappingPersistence<Car, Integer> wrappingPersistence =
            WrappingPersistence.aroundCollectionOnPrimaryKey(new HashSet<Car>(), Car.CAR_ID);

    assertTrue(wrappingPersistence.supportsIndex(NavigableIndex.onAttribute(Car.MANUFACTURER)));
    assertFalse(wrappingPersistence.supportsIndex(DiskIndex.onAttribute(Car.MANUFACTURER)));
}
 

import com.googlecode.cqengine.index.navigable.NavigableIndex; //导入依赖的package包/类
@Test
public void testSupportsIndex() {
    OffHeapPersistence<Car, Integer> persistence = OffHeapPersistence.onPrimaryKey(Car.CAR_ID);

    Index<Car> offHeapIndex = OffHeapIndex.onAttribute(Car.MANUFACTURER);
    Index<Car> diskIndex = DiskIndex.onAttribute(Car.MANUFACTURER);
    Index<Car> navigableIndex = NavigableIndex.onAttribute(Car.MANUFACTURER);

    Assert.assertTrue(persistence.supportsIndex(offHeapIndex));
    Assert.assertFalse(persistence.supportsIndex(diskIndex));
    Assert.assertFalse(persistence.supportsIndex(navigableIndex));
}
 

import com.googlecode.cqengine.index.navigable.NavigableIndex; //导入依赖的package包/类
@Test
public void testSupportsIndex() {
    DiskPersistence<Car, Integer> persistence = DiskPersistence.onPrimaryKey(Car.CAR_ID);

    Index<Car> diskIndex = DiskIndex.onAttribute(Car.MANUFACTURER);
    Index<Car> offHeapIndex = OffHeapIndex.onAttribute(Car.MANUFACTURER);
    Index<Car> navigableIndex = NavigableIndex.onAttribute(Car.MANUFACTURER);

    Assert.assertTrue(persistence.supportsIndex(diskIndex));
    Assert.assertFalse(persistence.supportsIndex(offHeapIndex));
    Assert.assertFalse(persistence.supportsIndex(navigableIndex));
}
 

import com.googlecode.cqengine.index.navigable.NavigableIndex; //导入依赖的package包/类
/**
 * Tests a configuration where the collection is stored off-heap, one index is on-disk, and one index is on-heap.
 */
@Test
public void testCompositePersistence_EndToEnd() {
    OffHeapPersistence<Car, Integer> offHeapPersistence = OffHeapPersistence.onPrimaryKey(Car.CAR_ID);
    DiskPersistence<Car, Integer> diskPersistence = DiskPersistence.onPrimaryKey(Car.CAR_ID);
    IndexedCollection<Car> collection = new ConcurrentIndexedCollection<Car>(CompositePersistence.of(
            offHeapPersistence,
            diskPersistence,
            singletonList(OnHeapPersistence.onPrimaryKey(Car.CAR_ID))
    ));

    collection.addIndex(DiskIndex.onAttribute(Car.MANUFACTURER));
    collection.addIndex(OffHeapIndex.onAttribute(Car.MODEL));
    collection.addIndex(NavigableIndex.onAttribute(Car.PRICE));

    collection.addAll(CarFactory.createCollectionOfCars(1000));

    ResultSet<Car> results = null;
    try {
        results = collection.retrieve(
                and(
                        or(
                                equal(Car.MANUFACTURER, "Ford"),
                                equal(Car.MODEL, "Avensis")
                        ),
                        lessThan(Car.PRICE, 6000.0)
                )
        );
        Assert.assertEquals(300, results.size());

        Assert.assertTrue(offHeapPersistence.getBytesUsed() > 4096); // example: 163840
        Assert.assertTrue(diskPersistence.getBytesUsed() > 4096); // example: 30720
    }
    finally {
        CloseableRequestResources.closeQuietly(results);
        collection.clear();
        offHeapPersistence.close();
        diskPersistence.getFile().delete();
    }
}
 

import com.googlecode.cqengine.index.navigable.NavigableIndex; //导入依赖的package包/类
@Test
public void testGetterMethods() {
    PartialIndex partialIndex = PartialNavigableIndex.onAttributeWithFilterQuery(Car.MANUFACTURER, between(Car.CAR_ID, 2, 5));
    assertEquals(Car.MANUFACTURER, partialIndex.getAttribute());
    assertEquals(between(Car.CAR_ID, 2, 5), partialIndex.getFilterQuery());
    assertFalse(partialIndex.isQuantized());
    assertTrue(partialIndex.getBackingIndex() instanceof NavigableIndex);
    assertTrue(partialIndex.getEffectiveIndex() == partialIndex);
    assertTrue(partialIndex.getBackingIndex().getEffectiveIndex() == partialIndex);
}