diff options
Diffstat (limited to 'src/main')
5 files changed, 72 insertions, 120 deletions
diff --git a/src/main/java/com/amazon/carbonado/repo/indexed/IndexAnalysis.java b/src/main/java/com/amazon/carbonado/repo/indexed/IndexAnalysis.java index 241f297..5175488 100644 --- a/src/main/java/com/amazon/carbonado/repo/indexed/IndexAnalysis.java +++ b/src/main/java/com/amazon/carbonado/repo/indexed/IndexAnalysis.java @@ -51,6 +51,8 @@ import com.amazon.carbonado.info.StorableProperty; import com.amazon.carbonado.qe.FilteringScore;
import com.amazon.carbonado.qe.StorableIndexSet;
+import com.amazon.carbonado.synthetic.SyntheticStorableReferenceAccess;
+
/**
* Builds various sets of indexes for a Storable type.
*
@@ -275,11 +277,12 @@ class IndexAnalysis<S extends Storable> { ManagedIndex<S>[] managedIndexes = new ManagedIndex[managedIndexSet.size()];
int i = 0;
for (StorableIndex<S> index : managedIndexSet) {
- IndexEntryGenerator<S> builder = IndexEntryGenerator.getInstance(index);
- Class<? extends Storable> indexEntryClass = builder.getIndexEntryClass();
+ SyntheticStorableReferenceAccess<S> accessor =
+ IndexEntryGenerator.getIndexAccess(index);
+ Class<? extends Storable> indexEntryClass = accessor.getReferenceClass();
Storage<?> indexEntryStorage = repository.getIndexEntryStorageFor(indexEntryClass);
ManagedIndex managedIndex = new ManagedIndex<S>
- (repository, masterStorage, index, builder, indexEntryStorage);
+ (repository, masterStorage, index, accessor, indexEntryStorage);
allIndexInfoMap.put(index, managedIndex);
managedIndexes[i++] = managedIndex;
diff --git a/src/main/java/com/amazon/carbonado/repo/indexed/IndexEntryGenerator.java b/src/main/java/com/amazon/carbonado/repo/indexed/IndexEntryGenerator.java index 7fb80dc..19bfa8c 100644 --- a/src/main/java/com/amazon/carbonado/repo/indexed/IndexEntryGenerator.java +++ b/src/main/java/com/amazon/carbonado/repo/indexed/IndexEntryGenerator.java @@ -41,138 +41,83 @@ import com.amazon.carbonado.synthetic.SyntheticStorableReferenceBuilder; */
class IndexEntryGenerator <S extends Storable> {
- // cache for generators
- private static Map<StorableIndex, Reference<IndexEntryGenerator>> cCache =
- new WeakHashMap<StorableIndex, Reference<IndexEntryGenerator>>();
-
+ // cache for access classes
+ private static Map<StorableIndex, Reference<SyntheticStorableReferenceAccess>> cCache =
+ new WeakHashMap<StorableIndex, Reference<SyntheticStorableReferenceAccess>>();
/**
- * Returns a new or cached generator instance. The caching of generators is
- * soft, so if no references remain to a given instance it may be garbage
- * collected. A subsequent call will return a newly created instance.
+ * Returns a new or cached index access instance. The caching of accessors
+ * is soft, so if no references remain to a given instance it may be
+ * garbage collected. A subsequent call will return a newly created
+ * instance.
*
- * <p>In addition to generating an index entry storable, this class
+ * <p>In addition to generating an index entry storable, the accessor
* contains methods to operate on it. Care must be taken to ensure that the
- * index entry instances are of the same type that the generator expects.
- * Since the generator may be garbage collected freely of the generated
+ * index entry instances are of the same type that the accessor expects.
+ * Since the accessor may be garbage collected freely of the generated
* index entry class, it is possible for index entries to be passed to a
- * generator instance that does not understand it. For example:
+ * accessor instance that does not understand it. For example:
*
* <pre>
* StorableIndex index = ...
- * Class indexEntryClass = IndexEntryGenerator.getInstance(index).getIndexEntryClass();
+ * Class indexEntryClass = IndexEntryGenerator.getIndexAccess(index).getReferenceClass();
* ...
* garbage collection
* ...
* Storable indexEntry = instance of indexEntryClass
* // Might fail because generator instance is new
- * IndexEntryGenerator.getInstance(index).setAllProperties(indexEntry, source);
+ * IndexEntryGenerator.getIndexAccess(index).copyFromMaster(indexEntry, master);
* </pre>
*
- * The above code can be fixed by saving a local reference to the generator:
+ * The above code can be fixed by saving a local reference to the accessor:
*
* <pre>
* StorableIndex index = ...
- * IndexEntryGenerator generator = IndexEntryGenerator.getInstance(index);
- * Class indexEntryClass = generator.getIndexEntryClass();
+ * SyntheticStorableReferenceAccess access = IndexEntryGenerator.getIndexAccess(index);
+ * Class indexEntryClass = access.getReferenceClass();
* ...
* Storable indexEntry = instance of indexEntryClass
- * generator.setAllProperties(indexEntry, source);
+ * access.copyFromMaster(indexEntry, master);
* </pre>
*
* @throws SupportException if any non-primary key property doesn't have a
* public read method.
*/
- public static <S extends Storable> IndexEntryGenerator<S>
- getInstance(StorableIndex<S> index) throws SupportException
+ public static <S extends Storable>
+ SyntheticStorableReferenceAccess<S> getIndexAccess(StorableIndex<S> index)
+ throws SupportException
{
- synchronized(cCache) {
- IndexEntryGenerator<S> generator;
- Reference<IndexEntryGenerator> ref = cCache.get(index);
+ synchronized (cCache) {
+ SyntheticStorableReferenceAccess<S> access;
+ Reference<SyntheticStorableReferenceAccess> ref = cCache.get(index);
if (ref != null) {
- generator = ref.get();
- if (generator != null) {
- return generator;
+ access = ref.get();
+ if (access != null) {
+ return access;
}
}
- generator = new IndexEntryGenerator<S>(index);
- cCache.put(index, new SoftReference<IndexEntryGenerator>(generator));
- return generator;
- }
- }
-
- private SyntheticStorableReferenceAccess<S> mIndexAccess;
- /**
- * Convenience class for gluing new "builder" style synthetics to the traditional
- * generator style.
- * @param index Generator style index specification
- */
- public IndexEntryGenerator(StorableIndex<S> index) throws SupportException {
- // Need to try to find the base type. This is an awkward way to do it,
- // but we have nothing better available to us
- Class<S> type = index.getProperty(0).getEnclosingType();
+ // Need to try to find the base type. This is an awkward way to do
+ // it, but we have nothing better available to us
+ Class<S> type = index.getProperty(0).getEnclosingType();
- SyntheticStorableReferenceBuilder<S> builder =
- new SyntheticStorableReferenceBuilder<S>(type, index.isUnique());
-
- for (int i=0; i<index.getPropertyCount(); i++) {
- StorableProperty source = index.getProperty(i);
- builder.addKeyProperty(source.getName(), index.getPropertyDirection(i));
- }
+ SyntheticStorableReferenceBuilder<S> builder =
+ new SyntheticStorableReferenceBuilder<S>(type, index.isUnique());
- builder.build();
-
- mIndexAccess = builder.getReferenceAccess();
- }
-
- /**
- * Returns generated index entry class, which is abstract.
- *
- * @return class of index entry, which is a custom Storable
- */
- public Class<? extends Storable> getIndexEntryClass() {
- return mIndexAccess.getReferenceClass();
- }
+ for (int i=0; i<index.getPropertyCount(); i++) {
+ StorableProperty<S> source = index.getProperty(i);
+ builder.addKeyProperty(source.getName(), index.getPropertyDirection(i));
+ }
- /**
- * Sets all the primary key properties of the given master, using the
- * applicable properties of the given index entry.
- *
- * @param indexEntry source of property values
- * @param master master whose primary key properties will be set
- */
- public void copyToMasterPrimaryKey(Storable indexEntry, S master) {
- mIndexAccess.copyToMasterPrimaryKey(indexEntry, master);
- }
+ builder.build();
+ access = builder.getReferenceAccess();
- /**
- * Sets all the properties of the given index entry, using the applicable
- * properties of the given master.
- *
- * @param indexEntry index entry whose properties will be set
- * @param master source of property values
- */
- public void copyFromMaster(Storable indexEntry, S master) {
- mIndexAccess.copyFromMaster(indexEntry, master);
- }
+ cCache.put(index, new SoftReference<SyntheticStorableReferenceAccess>(access));
- /**
- * Returns true if the properties of the given index entry match those
- * contained in the master. This will always return true after a call to
- * setAllProperties.
- *
- * @param indexEntry index entry whose properties will be tested
- * @param master source of property values
- */
- public boolean isConsistent(Storable indexEntry, S master) {
- return mIndexAccess.isConsistent(indexEntry, master);
+ return access;
+ }
}
- /**
- * Returns a comparator for ordering index entries.
- */
- public Comparator<? extends Storable> getComparator() {
- return mIndexAccess.getComparator();
+ private IndexEntryGenerator() {
}
}
diff --git a/src/main/java/com/amazon/carbonado/repo/indexed/IndexedCursor.java b/src/main/java/com/amazon/carbonado/repo/indexed/IndexedCursor.java index 79895c4..de105cc 100644 --- a/src/main/java/com/amazon/carbonado/repo/indexed/IndexedCursor.java +++ b/src/main/java/com/amazon/carbonado/repo/indexed/IndexedCursor.java @@ -34,6 +34,8 @@ import com.amazon.carbonado.cursor.AbstractCursor; import com.amazon.carbonado.spi.RepairExecutor;
+import com.amazon.carbonado.synthetic.SyntheticStorableReferenceAccess;
+
/**
* Wraps another cursor which contains index entries and extracts master
* objects from them.
@@ -43,16 +45,16 @@ import com.amazon.carbonado.spi.RepairExecutor; class IndexedCursor<S extends Storable> extends AbstractCursor<S> {
private final Cursor<? extends Storable> mCursor;
private final IndexedStorage<S> mStorage;
- private final IndexEntryGenerator<S> mGenerator;
+ private final SyntheticStorableReferenceAccess<S> mAccessor;
private S mNext;
IndexedCursor(Cursor<? extends Storable> indexEntryCursor,
IndexedStorage<S> storage,
- IndexEntryGenerator<S> indexEntryGenerator) {
+ SyntheticStorableReferenceAccess<S> indexAccessor) {
mCursor = indexEntryCursor;
mStorage = storage;
- mGenerator = indexEntryGenerator;
+ mAccessor = indexAccessor;
}
public void close() throws FetchException {
@@ -68,13 +70,13 @@ class IndexedCursor<S extends Storable> extends AbstractCursor<S> { final Storable indexEntry = mCursor.next();
S master = mStorage.mMasterStorage.prepare();
- mGenerator.copyToMasterPrimaryKey(indexEntry, master);
+ mAccessor.copyToMasterPrimaryKey(indexEntry, master);
if (!master.tryLoad()) {
LogFactory.getLog(getClass()).warn
("Master is missing for index entry: " + indexEntry);
} else {
- if (mGenerator.isConsistent(indexEntry, master)) {
+ if (mAccessor.isConsistent(indexEntry, master)) {
mNext = master;
return true;
}
@@ -85,9 +87,9 @@ class IndexedCursor<S extends Storable> extends AbstractCursor<S> { try {
final IndexedRepository repo = mStorage.mRepository;
final Storage<?> indexEntryStorage =
- repo.getIndexEntryStorageFor(mGenerator.getIndexEntryClass());
+ repo.getIndexEntryStorageFor(mAccessor.getReferenceClass());
Storable newIndexEntry = indexEntryStorage.prepare();
- mGenerator.copyFromMaster(newIndexEntry, master);
+ mAccessor.copyFromMaster(newIndexEntry, master);
if (newIndexEntry.tryLoad()) {
// Good, the correct index entry exists. We'll see
@@ -108,11 +110,11 @@ class IndexedCursor<S extends Storable> extends AbstractCursor<S> { try {
// Reload master and verify inconsistency.
S master = mStorage.mMasterStorage.prepare();
- mGenerator.copyToMasterPrimaryKey(indexEntry, master);
+ mAccessor.copyToMasterPrimaryKey(indexEntry, master);
if (master.tryLoad()) {
Storable newIndexEntry = indexEntryStorage.prepare();
- mGenerator.copyFromMaster(newIndexEntry, master);
+ mAccessor.copyFromMaster(newIndexEntry, master);
newIndexEntry.tryInsert();
diff --git a/src/main/java/com/amazon/carbonado/repo/indexed/IndexedStorage.java b/src/main/java/com/amazon/carbonado/repo/indexed/IndexedStorage.java index 1abb064..b4440c9 100644 --- a/src/main/java/com/amazon/carbonado/repo/indexed/IndexedStorage.java +++ b/src/main/java/com/amazon/carbonado/repo/indexed/IndexedStorage.java @@ -356,7 +356,7 @@ class IndexedStorage<S extends Storable> implements Storage<S>, StorageAccess<S> }
Class<? extends Storable> indexEntryClass =
- IndexEntryGenerator.getInstance(index).getIndexEntryClass();
+ IndexEntryGenerator.getIndexAccess(index).getReferenceClass();
Storage<?> indexEntryStorage;
try {
diff --git a/src/main/java/com/amazon/carbonado/repo/indexed/ManagedIndex.java b/src/main/java/com/amazon/carbonado/repo/indexed/ManagedIndex.java index 2d0617e..8219ac1 100644 --- a/src/main/java/com/amazon/carbonado/repo/indexed/ManagedIndex.java +++ b/src/main/java/com/amazon/carbonado/repo/indexed/ManagedIndex.java @@ -52,6 +52,8 @@ import com.amazon.carbonado.cursor.MergeSortBuffer; import com.amazon.carbonado.spi.RepairExecutor;
+import com.amazon.carbonado.synthetic.SyntheticStorableReferenceAccess;
+
import com.amazon.carbonado.util.Throttle;
/**
@@ -85,7 +87,7 @@ class ManagedIndex<S extends Storable> implements IndexEntryAccessor<S> { private final IndexedRepository mRepository;
private final Storage<S> mMasterStorage;
private final StorableIndex mIndex;
- private final IndexEntryGenerator<S> mGenerator;
+ private final SyntheticStorableReferenceAccess<S> mAccessor;
private final Storage<?> mIndexEntryStorage;
private Query<?> mSingleMatchQuery;
@@ -93,14 +95,14 @@ class ManagedIndex<S extends Storable> implements IndexEntryAccessor<S> { ManagedIndex(IndexedRepository repository,
Storage<S> masterStorage,
StorableIndex<S> index,
- IndexEntryGenerator<S> generator,
+ SyntheticStorableReferenceAccess<S> accessor,
Storage<?> indexEntryStorage)
throws SupportException
{
mRepository = repository;
mMasterStorage = masterStorage;
mIndex = index;
- mGenerator = generator;
+ mAccessor = accessor;
mIndexEntryStorage = indexEntryStorage;
}
@@ -145,17 +147,17 @@ class ManagedIndex<S extends Storable> implements IndexEntryAccessor<S> { // Required by IndexEntryAccessor interface.
public void copyToMasterPrimaryKey(Storable indexEntry, S master) {
- mGenerator.copyToMasterPrimaryKey(indexEntry, master);
+ mAccessor.copyToMasterPrimaryKey(indexEntry, master);
}
// Required by IndexEntryAccessor interface.
public void copyFromMaster(Storable indexEntry, S master) {
- mGenerator.copyFromMaster(indexEntry, master);
+ mAccessor.copyFromMaster(indexEntry, master);
}
// Required by IndexEntryAccessor interface.
public boolean isConsistent(Storable indexEntry, S master) {
- return mGenerator.isConsistent(indexEntry, master);
+ return mAccessor.isConsistent(indexEntry, master);
}
// Required by IndexEntryAccessor interface.
@@ -165,7 +167,7 @@ class ManagedIndex<S extends Storable> implements IndexEntryAccessor<S> { // Required by IndexEntryAccessor interface.
public Comparator<? extends Storable> getComparator() {
- return mGenerator.getComparator();
+ return mAccessor.getComparator();
}
Cursor<S> fetchOne(IndexedStorage storage, Object[] identityValues)
@@ -188,7 +190,7 @@ class ManagedIndex<S extends Storable> implements IndexEntryAccessor<S> { Cursor<S> fetchFromIndexEntryQuery(IndexedStorage storage, Query<?> indexEntryQuery)
throws FetchException
{
- return new IndexedCursor<S>(indexEntryQuery.fetch(), storage, mGenerator);
+ return new IndexedCursor<S>(indexEntryQuery.fetch(), storage, mAccessor);
}
@Override
@@ -534,7 +536,7 @@ class ManagedIndex<S extends Storable> implements IndexEntryAccessor<S> { private Storable makeIndexEntry(S userStorable) throws PersistException {
try {
Storable indexEntry = mIndexEntryStorage.prepare();
- mGenerator.copyFromMaster(indexEntry, userStorable);
+ mAccessor.copyFromMaster(indexEntry, userStorable);
return indexEntry;
} catch (UndeclaredThrowableException e) {
Throwable cause = e.getCause();
@@ -561,7 +563,7 @@ class ManagedIndex<S extends Storable> implements IndexEntryAccessor<S> { // If index entry already exists, then index might be corrupt.
{
Storable freshEntry = mIndexEntryStorage.prepare();
- mGenerator.copyFromMaster(freshEntry, userStorable);
+ mAccessor.copyFromMaster(freshEntry, userStorable);
indexEntry.copyVersionProperty(freshEntry);
if (freshEntry.equals(indexEntry)) {
// Existing entry is exactly what we expect. Return false
@@ -591,7 +593,7 @@ class ManagedIndex<S extends Storable> implements IndexEntryAccessor<S> { }
Storable freshEntry = mIndexEntryStorage.prepare();
- mGenerator.copyFromMaster(freshEntry, freshUserStorable);
+ mAccessor.copyFromMaster(freshEntry, freshUserStorable);
// Blow it away entry and re-insert. Don't simply update
// the entry, since record version number may prevent
|