001: /*
002:
003: Derby - Class org.apache.derby.impl.sql.execute.GenericScanQualifier
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.services.sanity.SanityManager;
025:
026: import org.apache.derby.iapi.error.StandardException;
027:
028: import org.apache.derby.iapi.sql.execute.ScanQualifier;
029:
030: import org.apache.derby.iapi.store.access.Qualifier;
031:
032: import org.apache.derby.iapi.types.DataValueDescriptor;
033:
034: /**
035: * This is the implementation for ScanQualifier. It is used for system and user
036: * scans.
037: *
038: * @version 0.1
039: * @author Jerry Brenner
040: */
041:
042: public class GenericScanQualifier implements ScanQualifier {
043:
044: private int columnId = -1;
045: private DataValueDescriptor orderable = null;
046: private int operator = -1;
047: private boolean negateCR = false;
048: private boolean orderedNulls = false;
049: private boolean unknownRV = false;
050:
051: private boolean properInit = false;
052:
053: public GenericScanQualifier() {
054: }
055:
056: /*
057: * Qualifier interface
058: */
059:
060: /**
061: * @see Qualifier#getColumnId
062: */
063: public int getColumnId() {
064: if (SanityManager.DEBUG)
065: SanityManager.ASSERT(properInit,
066: "properInit is expected to be true");
067: return columnId;
068: }
069:
070: /**
071: * @see Qualifier#getOrderable
072: */
073: public DataValueDescriptor getOrderable() {
074: if (SanityManager.DEBUG)
075: SanityManager.ASSERT(properInit,
076: "properInit is expected to be true");
077: return orderable;
078: }
079:
080: /** Get the operator to use in the comparison.
081: *
082: * @see Qualifier#getOperator
083: **/
084: public int getOperator() {
085: if (SanityManager.DEBUG)
086: SanityManager.ASSERT(properInit,
087: "properInit is expected to be true");
088: return operator;
089: }
090:
091: /** Should the result from the compare operation be negated? If true
092: * then only rows which fail the compare operation will qualify.
093: *
094: * @see Qualifier#negateCompareResult
095: **/
096: public boolean negateCompareResult() {
097: if (SanityManager.DEBUG)
098: SanityManager.ASSERT(properInit,
099: "properInit is expected to be true");
100: return negateCR;
101: }
102:
103: /** Get the getOrderedNulls argument to use in the comparison.
104: *
105: * @see Qualifier#getOrderedNulls
106: **/
107: public boolean getOrderedNulls() {
108: if (SanityManager.DEBUG)
109: SanityManager.ASSERT(properInit,
110: "properInit is expected to be true");
111: return orderedNulls;
112: }
113:
114: /** Get the getOrderedNulls argument to use in the comparison.
115: *
116: * @see Qualifier#getUnknownRV
117: **/
118: public boolean getUnknownRV() {
119: if (SanityManager.DEBUG)
120: SanityManager.ASSERT(properInit,
121: "properInit is expected to be true");
122: return unknownRV;
123: }
124:
125: /** Clear the DataValueDescriptor cache, if one exists.
126: * (The DataValueDescriptor can be 1 of 3 types:
127: * o VARIANT - cannot be cached as its value can
128: * vary within a scan
129: * o SCAN_INVARIANT - can be cached within a scan as its
130: * value will not change within a scan
131: * o QUERY_INVARIANT- can be cached across the life of the query
132: * as its value will never change
133: * o CONSTANT - immutable
134: *
135: * @see Qualifier#getUnknownRV
136: */
137: public void clearOrderableCache() {
138: // No Orderable caching in ScanQualifiers
139: }
140:
141: /**
142: * This method reinitializes all the state of
143: * the Qualifier. It is used to distinguish between
144: * resetting something that is query invariant
145: * and something that is constant over every
146: * execution of a query. Basically, clearOrderableCache()
147: * will only clear out its cache if it is a VARIANT
148: * or SCAN_INVARIANT value. However, each time a
149: * query is executed, the QUERY_INVARIANT qualifiers need
150: * to be reset.
151: */
152: public void reinitialize() {
153: }
154:
155: /*
156: * ScanQualifier interface
157: */
158:
159: /**
160: * @see ScanQualifier#setQualifier
161: */
162: public void setQualifier(int columnId,
163: DataValueDescriptor orderable, int operator,
164: boolean negateCR, boolean orderedNulls, boolean unknownRV) {
165: this .columnId = columnId;
166: this .orderable = orderable;
167: this .operator = operator;
168: this .negateCR = negateCR;
169: this .orderedNulls = orderedNulls;
170: this .unknownRV = unknownRV;
171: properInit = true;
172: }
173: }
|