KickJava   Java API By Example, From Geeks To Geeks.

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


1 package com.daffodilwoods.daffodildb.server.sql99.fulltext.dql.condition;
2
3 import com.daffodilwoods.database.resource.DException;
4 import com.daffodilwoods.daffodildb.server.sql99.dql.iterator._Iterator;
5 import com.daffodilwoods.daffodildb.server.sql99.fulltext.dml._FullTextIndexInformation;
6 import com.daffodilwoods.daffodildb.server.datasystem.interfaces._IndexTable;
7 import com.daffodilwoods.daffodildb.server.datasystem.indexsystem._IndexInformation;
8 import com.daffodilwoods.database.sqlinitiator._Order;
9 import com.daffodilwoods.daffodildb.server.sql99.dql.iterator.set.UnionAllIterator;
10 import com.daffodilwoods.daffodildb.server.sql99.fulltext.dql.iterator.Rank1FTIterator;
11 import com.daffodilwoods.daffodildb.server.sql99.fulltext.dql.iterator.Rank2FTIterator;
12 import com.daffodilwoods.daffodildb.server.sql99.fulltext.dql.iterator.Rank3FTIterator;
13 import com.daffodilwoods.daffodildb.server.sql99.utils._Reference;
14 import com.daffodilwoods.daffodildb.server.sql99.common.GeneralPurposeStaticClass;
15 import com.daffodilwoods.daffodildb.server.sql99.common.Datatypes;
16 import com.daffodilwoods.daffodildb.utils.GetByteComparator;
17 import com.daffodilwoods.daffodildb.utils.comparator.SuperComparator;
18 import com.daffodilwoods.daffodildb.utils.field.FieldBase;
19 import com.daffodilwoods.daffodildb.server.sql99.fulltext.dql.iterator.AllKeyWordsIterator;
20
21 /**
22  * AndWords represents plan which is generated when search pattern is combination of
23  * two search pattern combined with AND Logical Operator.search pattern can be
24  * single word or AndWords.It provides functionality to get resultset on execution
25  * of plan.plan generated will be optimized.
26  * optimized plan:-plan is optimized if it will provide resultset based on
27  * Rank iterator.According to Rank Iterator ResultSet gives record in following
28  * Order:-
29  * resultset first gives those record which contain all search pattern + same sequence +zero gap
30  * then after that gives those record which contain all search pattern + same sequence + gap greater then zero
31  * then after that gives those record which contain all search pattern + different in sequence.
32  * <p>Title: </p>
33  * <p>Description: </p>
34  * <p>Copyright: Copyright (c) 2003</p>
35  * <p>Company: </p>
36  * @author not attributable
37  * @version 1.0
38  */

39
40 public class AndWords implements _Word{
41    /**
42     * array of search pattern,which is to be searched.
43     */

44    WordRepresentation[] words;
45    /**
46     * columnName against which search pattern is searched
47     */

48    String JavaDoc columnName;
49
50    private _Order order;
51
52    public AndWords(WordRepresentation[] words0) {
53       words = words0;
54    }
55    /**
56     * this method is used to get type of plan which is required by plan merger
57     * to merged two plan either with Logically AND and OR Operator.
58     * @return type of plan
59     * @throws DException
60     */

61    public int getType() throws DException{
62       return PredicateConstant.andWords;
63    }
64    /**
65     * It is required to get columnName of searched column against which search
66     * pattern is searched.
67     * @return columnName
68     * @throws DException
69     */

70    public String JavaDoc getColumn() throws DException{
71       return columnName = words[0].getColumn();
72    }
73    /**
74     * It is used to set columnName of searched column against which search
75     * pattern is searched.
76     * @param colName
77     * @throws DException
78     */

79    public void setColumn(String JavaDoc colName) throws DException{
80       for(int i =0;i<words.length;i++){
81          words[i].setColumn(colName);
82       }
83    }
84
85    public WordRepresentation[] getWord(){
86       return words;
87    }
88    /**
89     * It allows user to obtain resultset of this plan. Resultset is used for
90     * navigating records.AndWord plan generates resultset which is union of 3
91     * resultsets:-
92     * 1. Resultset contains All Search pattern + sameSequence + Zero gap
93     * 2. Resultsetcontains Allserach + sameSequence + gap>0
94     * 3. AllKeywords + different Sequence but not same sequence.
95     * In this way Resultset provides record in optimized way.
96     * @param session
97     * @return _Iterator
98     * @throws DException
99     */

100    public _Iterator execute(Object JavaDoc session)throws DException{
101       int length = words.length;
102       _Iterator tokenIterator[] = new _Iterator[length];
103       _Iterator locationIterator[] = new _Iterator[length];
104       _Reference fpkReference[] = new _Reference[length];
105       FieldBase[] KeyWords = new FieldBase[length];
106       for (int i = 0; i < length; i++) {
107          tokenIterator[i] = words[i].getTokenIterator(session);
108          locationIterator[i] = words[i].getLocationIterator(session);
109          fpkReference[i] = words[i].getFpkReference();
110          KeyWords[i] = (FieldBase)words[i].getKeyWords();
111       }
112       _Iterator rank1 = new Rank1FTIterator(tokenIterator,locationIterator,fpkReference,KeyWords);
113       _Iterator rank2 = new Rank2FTIterator(tokenIterator,locationIterator,fpkReference,KeyWords);
114       _Iterator rank3 = new Rank3FTIterator(tokenIterator,locationIterator,fpkReference,KeyWords);
115       return getUnionIterator(rank1, rank2, rank3);
116    }
117    /**
118     * This method allows to get union of three ResultSet.First ResultSet provides
119     * those record which contains all search pattern with difference between
120     * search pattern is 1 and also in same sequence.second Resultset provides those
121     * record which contains all search pattern with difference between search pattern
122     * is greater than 0 and also in same sequence. Third Resultset provides those record
123     * which contains all search pattern but in different sequence.
124     * @param rank1
125     * @param rank2
126     * @param rank3
127     * @return _Iterator
128     * @throws DException
129     */

130    private _Iterator getUnionIterator(_Iterator rank1,_Iterator rank2,_Iterator rank3) throws DException{
131       int[] appropriateDataType = new int[]{Datatypes.LONGSIZE};
132       _Reference[] leftReferences = new _Reference[]{GeneralPurposeStaticClass.getColumnDetails("documentId")};
133       _Reference[] rightReferences = new _Reference[]{GeneralPurposeStaticClass.getColumnDetails("documentId")};
134       _Reference[] orderLeftColumnDetails = new _Reference[]{GeneralPurposeStaticClass.getColumnDetails("documentId")};
135       _Reference[] orderRightColumnDetails = new _Reference[]{GeneralPurposeStaticClass.getColumnDetails("documentId")};
136       UnionAllIterator iter = new UnionAllIterator(rank1,rank2,leftReferences,rightReferences,appropriateDataType,appropriateDataType,orderLeftColumnDetails,orderRightColumnDetails);
137       _Reference[] leftReferences1 = new _Reference[]{GeneralPurposeStaticClass.getColumnDetails("documentId")};
138       _Reference[] rightReferences1 = new _Reference[]{GeneralPurposeStaticClass.getColumnDetails("documentId")};
139       _Reference[] orderLeftColumnDetails1 = new _Reference[]{GeneralPurposeStaticClass.getColumnDetails("documentId")};
140       _Reference[] orderRightColumnDetails1 = new _Reference[]{GeneralPurposeStaticClass.getColumnDetails("documentId")};
141       return new UnionAllIterator(iter,rank3,leftReferences1,rightReferences1,appropriateDataType,appropriateDataType,orderLeftColumnDetails1,orderRightColumnDetails1);
142    }
143
144
145    public double getCost() throws DException {
146       return 0.0;
147    }
148    public double getCost(Object JavaDoc session) throws DException {
149       return 0.0;
150    }
151    public double getEstimatedRow() throws DException {
152       return 1;
153    }
154    public void setOrder(_Order order) throws DException {
155       this.order = order;
156    }
157    public _Order getOrder() throws DException {
158       return order;
159    }
160    /**
161     * This method is required to get resultset on each search pattern which is
162     * to be searched. ResultSet of each search pattern provides desired documents
163     * in which that search pattern is present.
164     * @param session
165     * @return _Iterator[]
166     * @throws DException
167     */

168    private _Iterator[] getTokenIterator(Object JavaDoc session) throws DException {
169       int length = words.length;
170       _Iterator tokenIterator[] = new _Iterator[length];
171       FieldBase[] KeyWords = new FieldBase[length];
172       for(int i = 0;i<length;i++){
173          tokenIterator[i] = words[i].getTokenIterator(session);
174       }
175       return tokenIterator;
176    }
177    /**
178     * Returns the single words.
179     * @param session
180     * @return FieldBase
181     * @throws DException
182     */

183    private FieldBase[] getKeyWords(Object JavaDoc session)throws DException {
184       int length = words.length;
185       FieldBase[] KeyWords = new FieldBase[length];
186       for(int i = 0;i<length;i++){
187         KeyWords[i] = (FieldBase)words[i].getKeyWords();
188       }
189       return KeyWords;
190    }
191
192    /**
193     * This method is needed when sorted resultset is required on documentid.
194     * It is different from execute method.It returns documents in sorted order
195     * whereas execute method returns documents based on the rank algorithm in
196     * which case resultset is not sorted on documentid.
197     * @param indexTable
198     * @return _Iterator
199     * @throws DException
200     */

201
202    public _Iterator executeForSortedResult(Object JavaDoc indexTable) throws DException{
203       _Iterator tokenIterator[] = getTokenIterator(indexTable);
204       FieldBase keyWord[] = getKeyWords(indexTable);
205       AllKeyWordsIterator iter = new AllKeyWordsIterator(tokenIterator,keyWord);
206       return iter;
207    }
208
209 }
210
Popular Tags