001: /*
002:
003: Derby - Class org.apache.derby.impl.sql.execute.GenericQualifier
004:
005: Licensed to the Apache Software Foundation (ASF) under one or more
006: contributor license agreements. See the NOTICE file distributed with
007: this work for additional information regarding copyright ownership.
008: The ASF licenses this file to you under the Apache License, Version 2.0
009: (the "License"); you may not use this file except in compliance with
010: the License. You may obtain a copy of the License at
011:
012: http://www.apache.org/licenses/LICENSE-2.0
013:
014: Unless required by applicable law or agreed to in writing, software
015: distributed under the License is distributed on an "AS IS" BASIS,
016: WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
017: See the License for the specific language governing permissions and
018: limitations under the License.
019:
020: */
021:
022: package org.apache.derby.impl.sql.execute;
023:
024: import org.apache.derby.iapi.sql.Activation;
025:
026: import org.apache.derby.iapi.error.StandardException;
027:
028: import org.apache.derby.iapi.store.access.Qualifier;
029:
030: import org.apache.derby.iapi.types.DataValueDescriptor;
031:
032: import org.apache.derby.iapi.services.loader.GeneratedMethod;
033:
034: import org.apache.derby.iapi.services.sanity.SanityManager;
035:
036: /**
037: * This is the implementation for Qualifier. It is used for generated scans.
038: *
039: * @author Jeff Lichtman
040: */
041:
042: public class GenericQualifier implements Qualifier {
043: private int columnId;
044: private int operator;
045: private GeneratedMethod orderableGetter;
046: private Activation activation;
047: private boolean orderedNulls;
048: private boolean unknownRV;
049: private boolean negateCompareResult;
050: protected int variantType;
051:
052: private DataValueDescriptor orderableCache = null;
053:
054: public GenericQualifier(int columnId, int operator,
055: GeneratedMethod orderableGetter, Activation activation,
056: boolean orderedNulls, boolean unknownRV,
057: boolean negateCompareResult, int variantType) {
058: this .columnId = columnId;
059: this .operator = operator;
060: this .orderableGetter = orderableGetter;
061: this .activation = activation;
062: this .orderedNulls = orderedNulls;
063: this .unknownRV = unknownRV;
064: this .negateCompareResult = negateCompareResult;
065: this .variantType = variantType;
066: }
067:
068: /*
069: * Qualifier interface
070: */
071:
072: /**
073: * @see Qualifier#getColumnId
074: */
075: public int getColumnId() {
076: return columnId;
077: }
078:
079: /**
080: * @see Qualifier#getOrderable
081: *
082: * @exception StandardException Thrown on error
083: */
084: public DataValueDescriptor getOrderable() throws StandardException {
085: if (variantType != VARIANT) {
086: if (orderableCache == null) {
087: orderableCache = (DataValueDescriptor) (orderableGetter
088: .invoke(activation));
089: }
090: return orderableCache;
091: }
092: return (DataValueDescriptor) (orderableGetter
093: .invoke(activation));
094: }
095:
096: /** Get the operator to use in the comparison.
097: *
098: * @see Qualifier#getOperator
099: **/
100: public int getOperator() {
101: return operator;
102: }
103:
104: /** Should the result from the compare operation be negated? If true
105: * then only rows which fail the compare operation will qualify.
106: *
107: * @see Qualifier#negateCompareResult
108: **/
109: public boolean negateCompareResult() {
110: return negateCompareResult;
111: }
112:
113: /** Get the getOrderedNulls argument to use in the comparison.
114: *
115: * @see Qualifier#getOrderedNulls
116: **/
117: public boolean getOrderedNulls() {
118: return orderedNulls;
119: }
120:
121: /** Get the getOrderedNulls argument to use in the comparison.
122: *
123: * @see Qualifier#getUnknownRV
124: **/
125: public boolean getUnknownRV() {
126: return unknownRV;
127: }
128:
129: /** Clear the DataValueDescriptor cache, if one exists.
130: * (The DataValueDescriptor can be 1 of 3 types:
131: * o VARIANT - cannot be cached as its value can
132: * vary within a scan
133: * o SCAN_INVARIANT - can be cached within a scan as its
134: * value will not change within a scan
135: * o QUERY_INVARIANT- can be cached across the life of the query
136: * as its value will never change
137: * o CONSTANT - never changes
138: *
139: * @see Qualifier#getUnknownRV
140: */
141: public void clearOrderableCache() {
142: if ((variantType == SCAN_INVARIANT) || (variantType == VARIANT)) {
143: orderableCache = null;
144: }
145: }
146:
147: /**
148: * This method reinitializes all the state of
149: * the Qualifier. It is used to distinguish between
150: * resetting something that is query invariant
151: * and something that is constant over every
152: * execution of a query. Basically, clearOrderableCache()
153: * will only clear out its cache if it is a VARIANT
154: * or SCAN_INVARIANT value. However, each time a
155: * query is executed, the QUERY_INVARIANT qualifiers need
156: * to be reset.
157: */
158: public void reinitialize() {
159: if (variantType != CONSTANT) {
160: orderableCache = null;
161: }
162: }
163:
164: public String toString() {
165: if (SanityManager.DEBUG) {
166: return "columnId: " + columnId + "\noperator: " + operator
167: + "\norderedNulls: " + orderedNulls
168: + "\nunknownRV: " + unknownRV
169: + "\nnegateCompareResult: " + negateCompareResult;
170: } else {
171: return "";
172: }
173: }
174: }
|