KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > daffodilwoods > daffodildb > server > sql99 > fulltext > dql > condition > PredicateMerger


1 package com.daffodilwoods.daffodildb.server.sql99.fulltext.dql.condition;
2
3 import com.daffodilwoods.database.resource.DException;
4 import java.util.ArrayList JavaDoc;
5 import java.util.Arrays JavaDoc;
6 import com.daffodilwoods.daffodildb.utils.field.FieldBase;
7
8 /** PredicateMerger Provides functionality of merging of two plan. Plan are
9  * merged either with AND or OR logical operator.
10  * <p>Title: </p>
11  * <p>Description: </p>
12  * <p>Copyright: Copyright (c) 2003</p>
13  * <p>Company: </p>
14  * @author not attributable
15  * @version 1.0
16  */
17
18 public class PredicateMerger {
19
20   /**
21    * It is required to merge plan with AND logical operator.
22    * plan are merges on basis of their type.
23    * Algorithm of this method are placed:- \\server\company\Backend\Daffodil DB\ServerDesign\FullTextSearch\Documents\and.doc
24    * @param leftPredicate
25    * @param rightPredicate
26    * @return resultantMergedPredicate
27    * @throws DException
28    */
29   public static _FullTextPredicate mergePredicateWithAnd(_FullTextPredicate
30       leftPredicate, _FullTextPredicate rightPredicate) throws DException {
31     int type1 = leftPredicate.getType();
32     int type2 = rightPredicate.getType();
33     switch (type1) {
34       case PredicateConstant.singleWord:
35         WordRepresentation[] leftWords = ( (_Word) leftPredicate).getWord();
36         switch (type2) {
37           case PredicateConstant.singleWord:
38           case PredicateConstant.andWords:
39             WordRepresentation[] rightWords = ( (_Word) rightPredicate).getWord();
40             return new AndWords(getResultantArray(leftWords, rightWords));
41           case PredicateConstant.phrase:
42             return new AllKeyWordSortedPredicate(leftPredicate, rightPredicate);
43           case PredicateConstant.allKeyWordSortedPredicate:
44           case PredicateConstant.anyKeyWordSortedPredicate:
45           case PredicateConstant.andFullTextPredicate:
46           case PredicateConstant.orFullTextPredicate:
47
48             return new AndFullTextPredicate(leftPredicate, rightPredicate);
49           case PredicateConstant.orWords:
50             return new AllKeyWordSortedPredicate(leftPredicate, rightPredicate);
51           case PredicateConstant.notFullTextPredicate:
52             return new OptimizedNotPredicate( (_Word) leftPredicate,
53                                              rightPredicate);
54           case PredicateConstant.optimizedNotPredicate:
55             OptimizedNotPredicate onp = (OptimizedNotPredicate) rightPredicate;
56             _Word w = onp.getWord();
57             onp.setWord( (_Word) PredicateMerger.mergePredicateWithAnd(
58                 leftPredicate, w));
59             return onp;
60         }
61         break;
62       case PredicateConstant.andWords:
63         WordRepresentation[] leftAndWords = ( (_Word) leftPredicate).getWord();
64         switch (type2) {
65           case PredicateConstant.singleWord:
66           case PredicateConstant.andWords:
67             WordRepresentation[] rightWords = ( (_Word) rightPredicate).getWord();
68             return new AndWords(getResultantArray(leftAndWords, rightWords));
69           case PredicateConstant.phrase:
70           case PredicateConstant.orWords:
71           case PredicateConstant.orFullTextPredicate:
72           case PredicateConstant.andFullTextPredicate:
73           case PredicateConstant.notFullTextPredicate:
74           case PredicateConstant.optimizedNotPredicate:
75           case PredicateConstant.allKeyWordSortedPredicate:
76           case PredicateConstant.anyKeyWordSortedPredicate:
77             return new AllKeyWordSortedPredicate(leftPredicate, rightPredicate);
78         }
79         break;
80       case PredicateConstant.phrase:
81         switch (type2) {
82           case PredicateConstant.singleWord:
83           case PredicateConstant.phrase:
84             return new AllKeyWordSortedPredicate(leftPredicate, rightPredicate);
85           case PredicateConstant.notFullTextPredicate:
86           case PredicateConstant.optimizedNotPredicate:
87           case PredicateConstant.andFullTextPredicate:
88           case PredicateConstant.orFullTextPredicate:
89           case PredicateConstant.allKeyWordSortedPredicate:
90           case PredicateConstant.anyKeyWordSortedPredicate:
91             return new AndFullTextPredicate(leftPredicate, rightPredicate);
92           case PredicateConstant.orWords:
93           case PredicateConstant.andWords:
94
95             return new AllKeyWordSortedPredicate(leftPredicate, rightPredicate);
96         }
97         break;
98       case PredicateConstant.orWords:
99         switch (type2) {
100           case PredicateConstant.singleWord:
101           case PredicateConstant.phrase:
102           case PredicateConstant.notFullTextPredicate:
103           case PredicateConstant.optimizedNotPredicate:
104           case PredicateConstant.orWords:
105           case PredicateConstant.andWords:
106           case PredicateConstant.andFullTextPredicate:
107           case PredicateConstant.orFullTextPredicate:
108           case PredicateConstant.allKeyWordSortedPredicate:
109           case PredicateConstant.anyKeyWordSortedPredicate:
110             return new AllKeyWordSortedPredicate(leftPredicate, rightPredicate);
111         }
112         break;
113       case PredicateConstant.andFullTextPredicate:
114       case PredicateConstant.orFullTextPredicate:
115         switch (type2) {
116           case PredicateConstant.singleWord:
117           case PredicateConstant.andFullTextPredicate:
118           case PredicateConstant.notFullTextPredicate:
119           case PredicateConstant.optimizedNotPredicate:
120           case PredicateConstant.allKeyWordSortedPredicate:
121           case PredicateConstant.anyKeyWordSortedPredicate:
122             return new AndFullTextPredicate(leftPredicate, rightPredicate);
123           case PredicateConstant.andWords:
124           case PredicateConstant.phrase:
125           case PredicateConstant.orWords:
126             return new AllKeyWordSortedPredicate(leftPredicate, rightPredicate);
127
128         }
129       case PredicateConstant.notFullTextPredicate:
130         switch (type2) {
131           case PredicateConstant.singleWord:
132           case PredicateConstant.andWords:
133             return new OptimizedNotPredicate( (_Word) rightPredicate,
134                                              leftPredicate); //do this becuase in OptimizedNotPredicate constructor take(_Word,_Fulltextpredicate)
135 case PredicateConstant.orWords:
136             return new AllKeyWordSortedPredicate(leftPredicate, rightPredicate);
137           case PredicateConstant.phrase:
138             return new AllKeyWordSortedPredicate(leftPredicate, rightPredicate);
139           case PredicateConstant.notFullTextPredicate:
140           case PredicateConstant.optimizedNotPredicate:
141           case PredicateConstant.andFullTextPredicate:
142           case PredicateConstant.orFullTextPredicate:
143           case PredicateConstant.allKeyWordSortedPredicate:
144           case PredicateConstant.anyKeyWordSortedPredicate:
145             return new AndFullTextPredicate(leftPredicate, rightPredicate);
146         }
147
148       case PredicateConstant.optimizedNotPredicate:
149         switch (type2) {
150           case PredicateConstant.singleWord:
151           case PredicateConstant.andWords:
152             OptimizedNotPredicate onp = (OptimizedNotPredicate) leftPredicate;
153             _Word w = onp.getWord();
154             onp.setWord( (_Word) PredicateMerger.mergePredicateWithAnd(w,
155                 rightPredicate));
156             return onp;
157           case PredicateConstant.orWords:
158             return new AllKeyWordSortedPredicate(leftPredicate, rightPredicate);
159           case PredicateConstant.phrase:
160             return new AllKeyWordSortedPredicate(leftPredicate, rightPredicate);
161           case PredicateConstant.andFullTextPredicate:
162           case PredicateConstant.orFullTextPredicate:
163           case PredicateConstant.notFullTextPredicate:
164           case PredicateConstant.optimizedNotPredicate:
165           case PredicateConstant.allKeyWordSortedPredicate:
166           case PredicateConstant.anyKeyWordSortedPredicate:
167             return new AndFullTextPredicate(leftPredicate, rightPredicate);
168         }
169       case PredicateConstant.allKeyWordSortedPredicate:
170         switch (type2) {
171           case PredicateConstant.allKeyWordSortedPredicate:
172           case PredicateConstant.orFullTextPredicate:
173             return new AndFullTextPredicate(leftPredicate, rightPredicate);
174         }
175     }
176     throw new DException("DSE0",
177                          new Object JavaDoc[] {"IN Predicate Merger Invalid Case"}); //To be Asked
178 }
179
180   /**
181    * It is required to merge left and right Plan in conjunction with OR operator.
182    * Plan are merges on the basis of their types.
183    * Algorithm of this method are placed:- \\server\company\Backend\Daffodil DB\ServerDesign\FullTextSearch\Documents\OR.doc
184    * @param leftPredicate
185    * @param rightPredicate
186    * @return _fullTextPredicate
187    * @throws DException
188    */
189
190   public static _FullTextPredicate mergePredicateWithOr(_FullTextPredicate
191       leftPredicate, _FullTextPredicate rightPredicate) throws DException {
192     int type1 = leftPredicate.getType();
193     int type2 = rightPredicate.getType();
194     switch (type1) {
195       case PredicateConstant.singleWord:
196         WordRepresentation[] leftWords = ( (_Word) leftPredicate).getWord();
197         switch (type2) {
198           case PredicateConstant.singleWord:
199           case PredicateConstant.orWords:
200             WordRepresentation[] rightWords = ( (_Word) rightPredicate).getWord();
201             return new OrWords(getResultantArray(leftWords, rightWords));
202           case PredicateConstant.andWords:
203             return new AnyKeyWordSortedPredicate(leftPredicate, rightPredicate);
204           case PredicateConstant.phrase:
205           case PredicateConstant.andFullTextPredicate:
206           case PredicateConstant.orFullTextPredicate:
207           case PredicateConstant.notFullTextPredicate:
208           case PredicateConstant.optimizedNotPredicate:
209           case PredicateConstant.anyKeyWordSortedPredicate:
210           case PredicateConstant.allKeyWordSortedPredicate:
211             return new OrFullTextpredicate(leftPredicate, rightPredicate);
212         }
213         break;
214       case PredicateConstant.orWords:
215         WordRepresentation[] leftOrWords = ( (_Word) leftPredicate).getWord();
216         switch (type2) {
217           case PredicateConstant.singleWord:
218           case PredicateConstant.orWords:
219             WordRepresentation[] rightWords = ( (_Word) rightPredicate).getWord();
220             return new OrWords(getResultantArray(leftOrWords, rightWords));
221           case PredicateConstant.phrase:
222           case PredicateConstant.andWords:
223           case PredicateConstant.andFullTextPredicate:
224           case PredicateConstant.orFullTextPredicate:
225           case PredicateConstant.notFullTextPredicate:
226           case PredicateConstant.optimizedNotPredicate:
227           case PredicateConstant.allKeyWordSortedPredicate:
228           case PredicateConstant.anyKeyWordSortedPredicate:
229             return new AnyKeyWordSortedPredicate(leftPredicate, rightPredicate);
230         }
231         break;
232       case PredicateConstant.andWords:
233         switch (type2) {
234           case PredicateConstant.singleWord:
235           case PredicateConstant.orWords:
236           case PredicateConstant.phrase:
237           case PredicateConstant.andWords:
238           case PredicateConstant.notFullTextPredicate:
239           case PredicateConstant.optimizedNotPredicate:
240           case PredicateConstant.andFullTextPredicate:
241           case PredicateConstant.allKeyWordSortedPredicate:
242           case PredicateConstant.anyKeyWordSortedPredicate:
243           case PredicateConstant.orFullTextPredicate:
244             return new AnyKeyWordSortedPredicate(leftPredicate, rightPredicate);
245         }
246         break;
247       case PredicateConstant.phrase:
248       case PredicateConstant.notFullTextPredicate:
249       case PredicateConstant.optimizedNotPredicate:
250       case PredicateConstant.andFullTextPredicate:
251       case PredicateConstant.orFullTextPredicate:
252       case PredicateConstant.allKeyWordSortedPredicate:
253         switch (type2) {
254           case PredicateConstant.singleWord:
255           case PredicateConstant.orFullTextPredicate:
256           case PredicateConstant.phrase:
257           case PredicateConstant.andFullTextPredicate:
258           case PredicateConstant.notFullTextPredicate:
259           case PredicateConstant.optimizedNotPredicate:
260           case PredicateConstant.allKeyWordSortedPredicate:
261           case PredicateConstant.anyKeyWordSortedPredicate:
262             return new OrFullTextpredicate(leftPredicate, rightPredicate);
263           case PredicateConstant.andWords:
264           case PredicateConstant.orWords:
265             return new AnyKeyWordSortedPredicate(leftPredicate, rightPredicate);
266         }
267               case PredicateConstant.anyKeyWordSortedPredicate:
268                 switch(type2){
269                             case PredicateConstant.singleWord:
270                               return new OrFullTextpredicate(leftPredicate, rightPredicate);
271                 }
272         break;
273     }
274     throw new DException("DSE0",
275                          new Object JavaDoc[] {"IN Predicate Merger Invalid Case"}); //To be asked
276
277   }
278
279   /**
280    * It is required to merge two arrays into third one.which does not contains
281    * duplicate element.
282    * @param leftWords
283    * @param rightWords
284    * @return resultant merged Array
285    * @throws DException
286    */
287   private static WordRepresentation[] getResultantArray(WordRepresentation[]
288       leftWord, WordRepresentation[] rightWord) throws DException {
289     ArrayList JavaDoc resultantWords = new ArrayList JavaDoc();
290     resultantWords.addAll(Arrays.asList(leftWord));
291     for (int j = 0; j < rightWord.length; j++) {
292       if (!resultantWords.contains(rightWord[j])) {
293         resultantWords.add(rightWord[j]);
294       }
295     }
296     return (WordRepresentation[]) resultantWords.toArray(new WordRepresentation[
297         resultantWords.size()]);
298   }
299
300 }
301
Popular Tags