From 39fce59a840b723eb013bc79285687986592b2da Mon Sep 17 00:00:00 2001 From: "Brian S. O'Neill" Date: Sun, 3 Sep 2006 06:14:41 +0000 Subject: More work on query engine. --- .../com/amazon/carbonado/qe/AbstractQuery.java | 4 +- .../amazon/carbonado/qe/AbstractQueryExecutor.java | 2 +- .../carbonado/qe/DelegatedQueryExecutor.java | 2 +- .../java/com/amazon/carbonado/qe/EmptyQuery.java | 1 + .../amazon/carbonado/qe/FilteredQueryExecutor.java | 4 +- .../carbonado/qe/FullScanIndexedQueryExecutor.java | 10 +- .../amazon/carbonado/qe/FullScanQueryExecutor.java | 6 +- .../amazon/carbonado/qe/IndexedQueryExecutor.java | 28 +- .../amazon/carbonado/qe/IterableQueryExecutor.java | 18 +- .../amazon/carbonado/qe/JoinedQueryExecutor.java | 4 +- .../com/amazon/carbonado/qe/KeyQueryExecutor.java | 6 +- .../com/amazon/carbonado/qe/QueryExecutor.java | 2 +- .../amazon/carbonado/qe/SortedQueryExecutor.java | 4 +- .../com/amazon/carbonado/qe/StandardQuery.java | 404 +++++++++++++++++++++ .../amazon/carbonado/qe/UnionQueryExecutor.java | 4 +- 15 files changed, 459 insertions(+), 40 deletions(-) create mode 100644 src/main/java/com/amazon/carbonado/qe/StandardQuery.java (limited to 'src/main/java/com/amazon/carbonado/qe') diff --git a/src/main/java/com/amazon/carbonado/qe/AbstractQuery.java b/src/main/java/com/amazon/carbonado/qe/AbstractQuery.java index 4549151..eb2e977 100644 --- a/src/main/java/com/amazon/carbonado/qe/AbstractQuery.java +++ b/src/main/java/com/amazon/carbonado/qe/AbstractQuery.java @@ -44,8 +44,10 @@ import com.amazon.carbonado.util.Appender; * @author Brian S O'Neill */ public abstract class AbstractQuery implements Query, Appender { + // FIXME: remove this protected static final String[] EMPTY_ORDERINGS = {}; + // FIXME: remove this protected static String[] extractOrderingNames(OrderedProperty[] orderings) { String[] orderingStrings; if (orderings == null || orderings.length == 0) { @@ -58,8 +60,6 @@ public abstract class AbstractQuery implements Query, App return orderingStrings; } - // Note: Since constructor takes no parameters, this class is called - // Abstract instead of Base. protected AbstractQuery() { } diff --git a/src/main/java/com/amazon/carbonado/qe/AbstractQueryExecutor.java b/src/main/java/com/amazon/carbonado/qe/AbstractQueryExecutor.java index 01b4c57..dc67fc1 100644 --- a/src/main/java/com/amazon/carbonado/qe/AbstractQueryExecutor.java +++ b/src/main/java/com/amazon/carbonado/qe/AbstractQueryExecutor.java @@ -40,7 +40,7 @@ public abstract class AbstractQueryExecutor implements Query * Counts results by opening a cursor and skipping entries. */ public long count(FilterValues values) throws FetchException { - Cursor cursor = openCursor(values); + Cursor cursor = fetch(values); try { long count = cursor.skipNext(Integer.MAX_VALUE); if (count == Integer.MAX_VALUE) { diff --git a/src/main/java/com/amazon/carbonado/qe/DelegatedQueryExecutor.java b/src/main/java/com/amazon/carbonado/qe/DelegatedQueryExecutor.java index 8bde825..9c950e0 100644 --- a/src/main/java/com/amazon/carbonado/qe/DelegatedQueryExecutor.java +++ b/src/main/java/com/amazon/carbonado/qe/DelegatedQueryExecutor.java @@ -83,7 +83,7 @@ public class DelegatedQueryExecutor implements QueryExecutor return mStorage.getStorableType(); } - public Cursor openCursor(FilterValues values) throws FetchException { + public Cursor fetch(FilterValues values) throws FetchException { return applyFilterValues(values).fetch(); } diff --git a/src/main/java/com/amazon/carbonado/qe/EmptyQuery.java b/src/main/java/com/amazon/carbonado/qe/EmptyQuery.java index 60b027f..ba18531 100644 --- a/src/main/java/com/amazon/carbonado/qe/EmptyQuery.java +++ b/src/main/java/com/amazon/carbonado/qe/EmptyQuery.java @@ -50,6 +50,7 @@ public final class EmptyQuery extends AbstractQuery { * @param storage required storage object * @param orderings optional order-by properties */ + // FIXME: remove this public EmptyQuery(Storage storage, OrderedProperty[] orderings) { if (storage == null) { throw new IllegalArgumentException(); diff --git a/src/main/java/com/amazon/carbonado/qe/FilteredQueryExecutor.java b/src/main/java/com/amazon/carbonado/qe/FilteredQueryExecutor.java index 4da38d9..d2c45aa 100644 --- a/src/main/java/com/amazon/carbonado/qe/FilteredQueryExecutor.java +++ b/src/main/java/com/amazon/carbonado/qe/FilteredQueryExecutor.java @@ -62,8 +62,8 @@ public class FilteredQueryExecutor extends AbstractQueryExec mFilter = filter.initialFilterValues().getFilter(); } - public Cursor openCursor(FilterValues values) throws FetchException { - return FilteredCursor.applyFilter(mFilter, values, mExecutor.openCursor(values)); + public Cursor fetch(FilterValues values) throws FetchException { + return FilteredCursor.applyFilter(mFilter, values, mExecutor.fetch(values)); } /** diff --git a/src/main/java/com/amazon/carbonado/qe/FullScanIndexedQueryExecutor.java b/src/main/java/com/amazon/carbonado/qe/FullScanIndexedQueryExecutor.java index 33cd1c2..3ac0169 100644 --- a/src/main/java/com/amazon/carbonado/qe/FullScanIndexedQueryExecutor.java +++ b/src/main/java/com/amazon/carbonado/qe/FullScanIndexedQueryExecutor.java @@ -62,8 +62,8 @@ public abstract class FullScanIndexedQueryExecutor } @Override - public Cursor openCursor(FilterValues values) throws FetchException { - return openCursor(mIndex); + public Cursor fetch(FilterValues values) throws FetchException { + return fetch(mIndex); } /** @@ -74,8 +74,8 @@ public abstract class FullScanIndexedQueryExecutor return Collections.unmodifiableList(Arrays.asList(mIndex.getOrderedProperties())); } - protected Cursor openCursor() throws FetchException { - return openCursor(mIndex); + protected Cursor fetch() throws FetchException { + return fetch(mIndex); } /** @@ -83,5 +83,5 @@ public abstract class FullScanIndexedQueryExecutor * * @param index index to open, which may be a primary key index */ - protected abstract Cursor openCursor(StorableIndex index) throws FetchException; + protected abstract Cursor fetch(StorableIndex index) throws FetchException; } diff --git a/src/main/java/com/amazon/carbonado/qe/FullScanQueryExecutor.java b/src/main/java/com/amazon/carbonado/qe/FullScanQueryExecutor.java index e5072ce..1e2ad16 100644 --- a/src/main/java/com/amazon/carbonado/qe/FullScanQueryExecutor.java +++ b/src/main/java/com/amazon/carbonado/qe/FullScanQueryExecutor.java @@ -58,8 +58,8 @@ public abstract class FullScanQueryExecutor extends Abstract return Filter.getOpenFilter(mType); } - public Cursor openCursor(FilterValues values) throws FetchException { - return openCursor(); + public Cursor fetch(FilterValues values) throws FetchException { + return fetch(); } /** @@ -82,5 +82,5 @@ public abstract class FullScanQueryExecutor extends Abstract /** * Return a new Cursor instance. */ - protected abstract Cursor openCursor() throws FetchException; + protected abstract Cursor fetch() throws FetchException; } diff --git a/src/main/java/com/amazon/carbonado/qe/IndexedQueryExecutor.java b/src/main/java/com/amazon/carbonado/qe/IndexedQueryExecutor.java index 7249164..28bd7e4 100644 --- a/src/main/java/com/amazon/carbonado/qe/IndexedQueryExecutor.java +++ b/src/main/java/com/amazon/carbonado/qe/IndexedQueryExecutor.java @@ -90,7 +90,7 @@ public abstract class IndexedQueryExecutor extends AbstractQ return mIndex.getStorableType(); } - public Cursor openCursor(FilterValues values) throws FetchException { + public Cursor fetch(FilterValues values) throws FetchException { Object[] identityValues = null; Object rangeStartValue = null; Object rangeEndValue = null; @@ -147,11 +147,11 @@ public abstract class IndexedQueryExecutor extends AbstractQ } } - return openCursor(mIndex, identityValues, - rangeStartBoundary, rangeStartValue, - rangeEndBoundary, rangeEndValue, - mReverseRange, - mReverseOrder); + return fetch(mIndex, identityValues, + rangeStartBoundary, rangeStartValue, + rangeEndBoundary, rangeEndValue, + mReverseRange, + mReverseOrder); } public Filter getFilter() { @@ -254,13 +254,13 @@ public abstract class IndexedQueryExecutor extends AbstractQ * @param reverseOrder when true, iteration should be reversed from its * natural order */ - protected abstract Cursor openCursor(StorableIndex index, - Object[] identityValues, - BoundaryType rangeStartBoundary, - Object rangeStartValue, - BoundaryType rangeEndBoundary, - Object rangeEndValue, - boolean reverseRange, - boolean reverseOrder) + protected abstract Cursor fetch(StorableIndex index, + Object[] identityValues, + BoundaryType rangeStartBoundary, + Object rangeStartValue, + BoundaryType rangeEndBoundary, + Object rangeEndValue, + boolean reverseRange, + boolean reverseOrder) throws FetchException; } diff --git a/src/main/java/com/amazon/carbonado/qe/IterableQueryExecutor.java b/src/main/java/com/amazon/carbonado/qe/IterableQueryExecutor.java index 7788fba..b80066e 100644 --- a/src/main/java/com/amazon/carbonado/qe/IterableQueryExecutor.java +++ b/src/main/java/com/amazon/carbonado/qe/IterableQueryExecutor.java @@ -18,6 +18,8 @@ package com.amazon.carbonado.qe; +import java.util.concurrent.locks.Lock; + import com.amazon.carbonado.Cursor; import com.amazon.carbonado.Storable; @@ -31,6 +33,7 @@ import com.amazon.carbonado.cursor.IteratorCursor; */ public class IterableQueryExecutor extends FullScanQueryExecutor { private final Iterable mIterable; + private final Lock mLock; /** * @param type type of Storable @@ -38,11 +41,22 @@ public class IterableQueryExecutor extends FullScanQueryExec * @throws IllegalArgumentException if type is null */ public IterableQueryExecutor(Class type, Iterable iterable) { + this(type, iterable, null); + } + + /** + * @param type type of Storable + * @param iterable collection to iterate over, or null for empty cursor + * @param lock optional lock to hold while cursor is open + * @throws IllegalArgumentException if type is null + */ + public IterableQueryExecutor(Class type, Iterable iterable, Lock lock) { super(type); mIterable = iterable; + mLock = lock; } - protected Cursor openCursor() { - return new IteratorCursor(mIterable); + protected Cursor fetch() { + return new IteratorCursor(mIterable, mLock); } } diff --git a/src/main/java/com/amazon/carbonado/qe/JoinedQueryExecutor.java b/src/main/java/com/amazon/carbonado/qe/JoinedQueryExecutor.java index 4d8f48d..b5dc0c9 100644 --- a/src/main/java/com/amazon/carbonado/qe/JoinedQueryExecutor.java +++ b/src/main/java/com/amazon/carbonado/qe/JoinedQueryExecutor.java @@ -141,8 +141,8 @@ public class JoinedQueryExecutor return mBFilter; } - public Cursor openCursor(FilterValues values) throws FetchException { - return mFactory.join(mAExecutor.openCursor(transferValues(values))); + public Cursor fetch(FilterValues values) throws FetchException { + return mFactory.join(mAExecutor.fetch(transferValues(values))); } public List> getOrdering() { diff --git a/src/main/java/com/amazon/carbonado/qe/KeyQueryExecutor.java b/src/main/java/com/amazon/carbonado/qe/KeyQueryExecutor.java index e2d692d..fe07ed6 100644 --- a/src/main/java/com/amazon/carbonado/qe/KeyQueryExecutor.java +++ b/src/main/java/com/amazon/carbonado/qe/KeyQueryExecutor.java @@ -67,8 +67,8 @@ public abstract class KeyQueryExecutor extends AbstractQuery return mIndex.getStorableType(); } - public Cursor openCursor(FilterValues values) throws FetchException { - return openCursor(mIndex, values.getValuesFor(mKeyFilter)); + public Cursor fetch(FilterValues values) throws FetchException { + return fetch(mIndex, values.getValuesFor(mKeyFilter)); } public Filter getFilter() { @@ -106,6 +106,6 @@ public abstract class KeyQueryExecutor extends AbstractQuery * @param index index to open, which may be a primary key index * @param keyValues list of exactly matching values to apply to index */ - protected abstract Cursor openCursor(StorableIndex index, Object[] keyValues) + protected abstract Cursor fetch(StorableIndex index, Object[] keyValues) throws FetchException; } diff --git a/src/main/java/com/amazon/carbonado/qe/QueryExecutor.java b/src/main/java/com/amazon/carbonado/qe/QueryExecutor.java index 6861b2c..024c31c 100644 --- a/src/main/java/com/amazon/carbonado/qe/QueryExecutor.java +++ b/src/main/java/com/amazon/carbonado/qe/QueryExecutor.java @@ -46,7 +46,7 @@ public interface QueryExecutor { /** * Returns a new cursor using the given filter values. */ - Cursor openCursor(FilterValues values) throws FetchException; + Cursor fetch(FilterValues values) throws FetchException; /** * Counts the query results using the given filter values. diff --git a/src/main/java/com/amazon/carbonado/qe/SortedQueryExecutor.java b/src/main/java/com/amazon/carbonado/qe/SortedQueryExecutor.java index 5c5258a..822cde8 100644 --- a/src/main/java/com/amazon/carbonado/qe/SortedQueryExecutor.java +++ b/src/main/java/com/amazon/carbonado/qe/SortedQueryExecutor.java @@ -89,8 +89,8 @@ public abstract class SortedQueryExecutor extends AbstractQu mRemainderOrderings = remainderOrderings; } - public Cursor openCursor(FilterValues values) throws FetchException { - Cursor cursor = mExecutor.openCursor(values); + public Cursor fetch(FilterValues values) throws FetchException { + Cursor cursor = mExecutor.fetch(values); SortBuffer buffer = createSortBuffer(); return new SortedCursor(cursor, buffer, mHandledComparator, mFinisherComparator); } diff --git a/src/main/java/com/amazon/carbonado/qe/StandardQuery.java b/src/main/java/com/amazon/carbonado/qe/StandardQuery.java new file mode 100644 index 0000000..7152e55 --- /dev/null +++ b/src/main/java/com/amazon/carbonado/qe/StandardQuery.java @@ -0,0 +1,404 @@ +/* + * Copyright 2006 Amazon Technologies, Inc. or its affiliates. + * Amazon, Amazon.com and Carbonado are trademarks or registered trademarks + * of Amazon Technologies, Inc. or its affiliates. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.amazon.carbonado.qe; + +import java.io.IOException; + +import org.cojen.util.BeanPropertyAccessor; + +import com.amazon.carbonado.Cursor; +import com.amazon.carbonado.FetchException; +import com.amazon.carbonado.IsolationLevel; +import com.amazon.carbonado.PersistException; +import com.amazon.carbonado.PersistMultipleException; +import com.amazon.carbonado.Storage; +import com.amazon.carbonado.Storable; +import com.amazon.carbonado.Transaction; +import com.amazon.carbonado.Query; + +import com.amazon.carbonado.filter.ClosedFilter; +import com.amazon.carbonado.filter.Filter; +import com.amazon.carbonado.filter.FilterValues; +import com.amazon.carbonado.filter.OpenFilter; +import com.amazon.carbonado.filter.RelOp; + +import com.amazon.carbonado.info.OrderedProperty; + +import com.amazon.carbonado.util.Appender; + +/** + * Abstract query implementation which uses a {@link QueryExecutor}. + * + * @author Brian S O'Neill + */ +public abstract class StandardQuery extends AbstractQuery + implements Appender +{ + // Values for this query, which may be null. + private final FilterValues mValues; + // Properties that this query is ordered by. + private final String[] mOrderings; + + private volatile QueryExecutor mExecutor; + + /** + * @param values optional values object, defaults to open filter if null + * @param orderings optional order-by properties + */ + // FIXME: remove this + protected StandardQuery(FilterValues values, OrderedProperty... orderings) { + this(values, extractOrderingNames(orderings)); + } + + /** + * @param values optional values object, defaults to open filter if null + * @param orderings optional order-by properties, not cloned, which may be + * prefixed with '+' or '-' + */ + protected StandardQuery(FilterValues values, String... orderings) { + mValues = values; + mOrderings = orderings == null ? EMPTY_ORDERINGS : orderings; + } + + public Class getStorableType() { + return getStorage().getStorableType(); + } + + public Filter getFilter() { + FilterValues values = mValues; + if (values != null) { + return values.getFilter(); + } + return Filter.getOpenFilter(getStorage().getStorableType()); + } + + public FilterValues getFilterValues() { + return mValues; + } + + public int getBlankParameterCount() { + return mValues == null ? 0 : mValues.getBlankParameterCount(); + } + + public Query with(int value) { + return newInstance(requireValues().with(value)); + } + + public Query with(long value) { + return newInstance(requireValues().with(value)); + } + + public Query with(float value) { + return newInstance(requireValues().with(value)); + } + + public Query with(double value) { + return newInstance(requireValues().with(value)); + } + + public Query with(boolean value) { + return newInstance(requireValues().with(value)); + } + + public Query with(char value) { + return newInstance(requireValues().with(value)); + } + + public Query with(byte value) { + return newInstance(requireValues().with(value)); + } + + public Query with(short value) { + return newInstance(requireValues().with(value)); + } + + public Query with(Object value) { + return newInstance(requireValues().with(value)); + } + + public Query withValues(Object... values) { + if (values == null || values.length == 0) { + return this; + } + return newInstance(requireValues().withValues(values)); + } + + public Query and(Filter filter) throws FetchException { + FilterValues values = mValues; + Query newQuery; + if (values == null) { + newQuery = getStorage().query(filter); + } else { + newQuery = getStorage().query(values.getFilter().and(filter)); + newQuery = newQuery.withValues(values.getValues()); + } + return mOrderings.length == 0 ? newQuery : newQuery.orderBy(mOrderings); + } + + public Query or(Filter filter) throws FetchException { + FilterValues values = mValues; + if (values == null) { + throw new IllegalStateException("Query is already guaranteed to fetch everything"); + } + Query newQuery = getStorage().query(values.getFilter().or(filter)); + newQuery = newQuery.withValues(values.getValues()); + return mOrderings.length == 0 ? newQuery : newQuery.orderBy(mOrderings); + } + + public Query not() throws FetchException { + FilterValues values = mValues; + if (values == null) { + return new EmptyQuery(getStorage(), mOrderings); + } + Query newQuery = getStorage().query(values.getFilter().not()); + newQuery = newQuery.withValues(values.getSuppliedValues()); + return mOrderings.length == 0 ? newQuery : newQuery.orderBy(mOrderings); + } + + public Query orderBy(String property) throws FetchException { + StandardQuery query = newInstance(mValues, property); + // Get executor to ensure order property is correct. + query.executor(); + return query; + } + + public Query orderBy(String... properties) throws FetchException { + StandardQuery query = newInstance(mValues, properties); + // Get executor to ensure order properties are correct. + query.executor(); + return query; + } + + public Cursor fetch() throws FetchException { + return executor().fetch(mValues); + } + + public Cursor fetchAfter(S start) throws FetchException { + String[] orderings; + if (start == null || (orderings = mOrderings).length == 0) { + return fetch(); + } + + Class storableType = getStorage().getStorableType(); + Filter orderFilter = Filter.getClosedFilter(storableType); + Filter lastSubFilter = Filter.getOpenFilter(storableType); + BeanPropertyAccessor accessor = BeanPropertyAccessor.forClass(storableType); + + Object[] values = new Object[orderings.length]; + + for (int i=0;;) { + String propertyName = orderings[i]; + RelOp operator = RelOp.GT; + char c = propertyName.charAt(0); + if (c == '-') { + propertyName = propertyName.substring(1); + operator = RelOp.LT; + } else if (c == '+') { + propertyName = propertyName.substring(1); + } + + values[i] = accessor.getPropertyValue(start, propertyName); + + orderFilter = orderFilter.or(lastSubFilter.and(propertyName, operator)); + + if (++i >= orderings.length) { + break; + } + + lastSubFilter = lastSubFilter.and(propertyName, RelOp.EQ); + } + + Query newQuery = this.and(orderFilter); + + for (int i=0; i cursor = fetch(); + boolean result; + try { + if (cursor.hasNext()) { + S obj = cursor.next(); + if (cursor.hasNext()) { + throw new PersistMultipleException(toString()); + } + result = obj.tryDelete(); + } else { + return false; + } + } finally { + cursor.close(); + } + if (txn != null) { + txn.commit(); + } + return result; + } catch (FetchException e) { + throw e.toPersistException(); + } finally { + if (txn != null) { + txn.exit(); + } + } + } + + public void deleteAll() throws PersistException { + Transaction txn = enterTransactionForDelete(IsolationLevel.READ_COMMITTED); + try { + Cursor cursor = fetch(); + try { + while (cursor.hasNext()) { + cursor.next().tryDelete(); + } + } finally { + cursor.close(); + } + if (txn != null) { + txn.commit(); + } + } catch (FetchException e) { + throw e.toPersistException(); + } finally { + if (txn != null) { + txn.exit(); + } + } + } + + public long count() throws FetchException { + return executor().count(mValues); + } + + public boolean printNative(Appendable app, int indentLevel) throws IOException { + return executor().printNative(app, indentLevel, mValues); + } + + public boolean printPlan(Appendable app, int indentLevel) throws IOException { + return executor().printPlan(app, indentLevel, mValues); + } + + @Override + public int hashCode() { + int hash = getStorage().hashCode() * 31; + if (mValues != null) { + hash += mValues.hashCode(); + } + return hash; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof StandardQuery) { + StandardQuery other = (StandardQuery) obj; + return getStorage().equals(other.getStorage()) && + (mValues == null ? (other.mValues == null) : (mValues.equals(other.mValues))); + } + return false; + } + + public void appendTo(Appendable app) throws IOException { + app.append("Query {type="); + app.append(getStorableType().getName()); + app.append(", filter="); + Filter filter = getFilter(); + if (filter instanceof OpenFilter || filter instanceof ClosedFilter) { + filter.appendTo(app); + } else { + app.append('"'); + filter.appendTo(app, mValues); + app.append('"'); + } + + if (mOrderings != null && mOrderings.length > 0) { + app.append(", orderBy=["); + for (int i=0; i 0) { + app.append(", "); + } + app.append(mOrderings[i]); + } + app.append(']'); + } + + app.append('}'); + } + + private FilterValues requireValues() { + FilterValues values = mValues; + if (values == null) { + throw new IllegalStateException("Query doesn't have any parameters"); + } + return values; + } + + /** + * Return the Storage object that the query is operating on. + */ + protected abstract Storage getStorage(); + + /** + * Enter a transaction as needed by the standard delete operation, or null + * if transactions are not supported. + * + * @param level minimum desired isolation level + */ + protected abstract Transaction enterTransactionForDelete(IsolationLevel level); + + /** + * Return a new or cached executor. + * + * @param values optional values object, defaults to open filter if null + * @param orderings optional order-by properties, which may be prefixed + * with '+' or '-' + */ + protected abstract QueryExecutor getExecutor(FilterValues values, String... orderings); + + /** + * Return a new or cached instance of StandardQuery implementation, using + * new filter values. The Filter in the FilterValues is the same as was + * passed in the constructor. + * + * @param values optional values object, defaults to open filter if null + * @param orderings order-by properties, never null + */ + protected abstract StandardQuery newInstance(FilterValues values, String... orderings); + + private StandardQuery newInstance(FilterValues values) { + return newInstance(values, mOrderings); + } + + private QueryExecutor executor() { + QueryExecutor executor = mExecutor; + if (executor == null) { + mExecutor = executor = getExecutor(mValues, mOrderings); + } + return executor; + } +} diff --git a/src/main/java/com/amazon/carbonado/qe/UnionQueryExecutor.java b/src/main/java/com/amazon/carbonado/qe/UnionQueryExecutor.java index cc3d366..39e6157 100644 --- a/src/main/java/com/amazon/carbonado/qe/UnionQueryExecutor.java +++ b/src/main/java/com/amazon/carbonado/qe/UnionQueryExecutor.java @@ -83,10 +83,10 @@ public class UnionQueryExecutor extends AbstractQueryExecuto mOrderComparator = SortedCursor.createComparator(totalOrderings); } - public Cursor openCursor(FilterValues values) throws FetchException { + public Cursor fetch(FilterValues values) throws FetchException { Cursor cursor = null; for (QueryExecutor executor : mExecutors) { - Cursor subCursor = executor.openCursor(values); + Cursor subCursor = executor.fetch(values); cursor = (cursor == null) ? subCursor : new UnionCursor(cursor, subCursor, mOrderComparator); } -- cgit v1.2.3