|
1 package com.daffodilwoods.daffodildb.server.sql99.utils;
2
3 import java.util.*;
4
5 import com.daffodilwoods.daffodildb.server.serversystem.*;
6 import com.daffodilwoods.daffodildb.server.sql99.common.*;
7 import com.daffodilwoods.daffodildb.server.sql99.dql.common.*;
8 import com.daffodilwoods.daffodildb.server.sql99.dql.plan.order.*;
9 import com.daffodilwoods.daffodildb.utils.comparator.*;
10 import com.daffodilwoods.database.general.*;
11 import com.daffodilwoods.database.resource.*;
12 import com.daffodilwoods.database.sqlinitiator.*;
13 import com.daffodilwoods.database.utility.*;
14 import com.daffodilwoods.daffodildb.utils.field.FieldBase;
15 import com.daffodilwoods.daffodildb.utils.FieldUtility;
16
17 public class SelectOrder implements _OrderWithTableInformation, TypeConstants, TableExpressionConstants {
18
19 private ColumnDetails[] columns;
20 private boolean isSolvableByIndex;
21 private boolean sameOrReverse;
22 private boolean[] orderSpecification;
23 private SuperComparator[] baseLevelComparators;
24 private boolean adjustedOrder;
25 public SuperComparator orderComparator;
26 public SuperComparator byteComparator;
27
28 public SelectOrder(ColumnDetails[] columns0) throws DException {
29 columns = columns0;
30 orderSpecification = new boolean[columns0.length];
31 Arrays.fill(orderSpecification, true);
32
33 }
34
35 public SelectOrder(ColumnDetails[] columns0, boolean[] orderSpecification0) throws DException {
36 columns = columns0;
37 orderSpecification = orderSpecification0;
38 if (columns.length != orderSpecification.length) {
39 throw new DException("DSE3548", null);
40 }
41 }
42
43 public SelectOrder(ColumnDetails[] columns0, boolean[] orderSpecification0, boolean adjustedOrder0) throws DException {
44 this(columns0, orderSpecification0);
45 adjustedOrder = adjustedOrder0;
46 }
47
48 public SelectOrder(ColumnDetails[] columns0, boolean[] orderSpecification0, SuperComparator orderComparator0) throws DException {
49 columns = columns0;
50 orderSpecification = orderSpecification0;
51 orderComparator = orderComparator0;
52 if (columns.length != orderSpecification.length) {
53 throw new DException("DSE3548", null);
54 }
55 }
56
57 public SelectOrder(ColumnDetails[] columns0, boolean[] orderSpecification0, SuperComparator orderComparator0, boolean adjustedOrder0) throws DException {
58 this(columns0, orderSpecification0, orderComparator0);
59 adjustedOrder = adjustedOrder0;
60 }
61
62 public String  [] getColumns() throws DException {
63 int length = columns.length;
64 ArrayList result = new ArrayList();
65 for (int i = 0; i < length; i++) {
66 result.add(columns[i].getColumn());
67 }
68 return (String []) result.toArray(new String [result.size()]);
69 }
70
71 public int[] getColumnIndexes() throws DException {
72 return new int[columns.length];
73 }
74
75 public boolean[] getOrderOfColumns() throws DException {
76 return orderSpecification;
77 }
78
79 public Object getOrderValues(_VariableValues value) throws DException {
80 ArrayList aList = new ArrayList();
81 for (int i = 0; i < columns.length; i++) {
82 Object oo = null; if (columns[i].getType() == REFERENCE || (columns[i].getUnderLyingReference())) {
84 oo = value.getColumnValues(columns[i]);
85 } else {
86 oo = columns[i].run(value);
87 }
88 if (oo instanceof Object []) {
89 aList.addAll(Arrays.asList( (Object []) oo));
90 } else {
91 aList.add(oo);
92 }
93 }
94
95 Object [] array = aList.toArray(new Object [aList.size()]);
96 return array.length == 1 ? array[0] : array;
97 }
98
99 public ColumnDetails[] getColumnDetails() throws DException {
100 return columns;
101 }
102
103 public ColumnDetails[] getKeyColumnDetails() throws DException {
104 return columns;
105 }
106
107 public _Order[] getBaseLevelOrders() throws DException {
108 return new _Order[] {this};
109 }
110
111 public SuperComparator[] getBaseLevelComparator() throws DException {
112 throw new UnsupportedOperationException ("Method getBaseLevelComparator not supported");
113 }
114
115
116 public boolean isAdjustedOrder() throws DException {
117 return adjustedOrder;
118 }
119
120 public void setAdjustedOrder() throws DException {
121 adjustedOrder = true;
122 }
123
124 public SuperComparator getComparator() throws DException {
125 return orderComparator == null ? GeneralPurposeStaticClass.getOrderComparator(columns, orderSpecification) : orderComparator;
126 }
127
128 public SuperComparator getComparatorForBufferRange() throws DException {
129 byteComparator = byteComparator ==
130 null ? GeneralPurposeStaticClass.getOrderComparatorForBufferRange(columns,orderSpecification) : byteComparator;
131 return byteComparator;
132 }
133
134
135
142 public _OrderPlan getOrderPlan(_ServerSession serverSession) throws DException {
143 OrderPlan orderPlan = new OrderPlan();
144
145 switch (getTypeOfOrder()) {
146 case GROUPBYORDERPLAN:
147 orderPlan.setGroupByOrderPlan(this);
148 return orderPlan;
149 case JOINORDERPLAN:
150 orderPlan.setJoinOrderPlan(this);
151 return orderPlan;
152 case QUERYLEVELORDERPLAN :
153 orderPlan.setQueryLevelOrderPlans(this);
154 return orderPlan;
155 default:
156 if (checkForJoinLevelOrder(serverSession)) {
157 orderPlan.setJoinOrderPlan(this);
158 return orderPlan;
159 }
160 }
161
162 _SingleTableOrderPlan[] singleTableOrderPlan = OrderPlanMerger.getSingleTableOrderPlans(this);
163 orderPlan.setSingleTableOrderPlans(singleTableOrderPlan);
164 return orderPlan;
165 }
166
167
173 public int getType(ColumnDetails columnDetail) throws DException {
174 switch (columnDetail.getType()) {
175 case GROUPING:
176 return GROUPBYORDERPLAN;
177 case CONSTANT:
178 return JOINORDERPLAN;
179 case SCALARSUBQUERY:
180 return QUERYLEVELORDERPLAN;
181 case FUNCTIONAL:
182 case SCALARFUNCTION:
183 case CASEEXPRESSION:
184 case USERFUNCTION :
185
186 return getFunctionalColumnType(columnDetail.getExistingColumnDetails());
187 case REFERENCE:
188 return SINGLETABLEORDERPLAN;
189 default:
190 throw new DException("DSE3519", new Object [] {new Integer (columnDetail.getType())}); }
192 }
193
194 private int getFunctionalColumnType(ColumnDetails[] columns) throws DException {
195 int plantoreturn = -1;
196 for (int i = 0; i < columns.length; i++) {
197 switch (columns[i].getType()) {
198 case GROUPING:
199 return GROUPBYORDERPLAN;
200 case FUNCTIONAL:
201 case SCALARFUNCTION:
202 case CASEEXPRESSION:
203 case USERFUNCTION :
204 plantoreturn = getFunctionalColumnType(columns[i].getExistingColumnDetails());
205 }
206 }
207
208 return plantoreturn != -1 ? plantoreturn : QUERYLEVELORDERPLAN ;
209 }
210
211 private boolean checkForJoinLevelOrder(_ServerSession serverSession) throws DException {
212 boolean f1 = checkForMixedTableOrder(columns);
213 boolean f2 = checkForPrimaryColumns(columns, serverSession);
214 return (f1 || !f2);
215 }
216
217
224 private boolean checkForMixedTableOrder(ColumnDetails[] cd) throws DException {
225 int len = cd.length;
226 if (len > 2) {
227 for (int i = 0; i < len - 2; i++) {
228 TableDetails table1 = cd[i].getTableDetails();
229 TableDetails nextTable = cd[i + 1].getTableDetails();
230 if (table1 != nextTable) { for (int j = i + 2; j < len; j++) {
232 TableDetails table2 = cd[j].getTableDetails();
233 if (table1 == table2) {
234 return true;
235 }
236 }
237 }
238 }
239 }
240 return false;
241 }
242
243
264 public boolean checkForPrimaryColumns(ColumnDetails[] cd, Object session) throws DException {
265 int len = cd.length;
266 ArrayList checkTableList = new ArrayList(5);
267 boolean flag = false;
268 boolean duplicate = true;
269 TableDetails tableName = null;
270 for (int i = 0; i < cd.length; i++) {
271 if (cd[i].getType() == REFERENCE) {
272 int tableType = cd[i].getTable().getTableType();
273 TableDetails tableIdentifier = cd[i].getTableDetails();
274 if (tableType != TypeConstants.VIEW) {
275 if (i > 0 && flag) {
276 return false;
277 }
278 } else {
279 flag = true;
280 tableName = tableName == null ? tableIdentifier : tableName;
281 duplicate = tableName == tableIdentifier;
282 if (!duplicate) {
283 return false;
284 }
285 }
286 if (!checkTableList.contains(tableIdentifier)) {
287 checkTableList.add(tableIdentifier);
288 }
289 } else {
290 return false;
291 }
292 }
293 int size = checkTableList.size();
294 if (size == 1) {
295 return true;
296 }
297 for (int i = 0; i < size - 1; i++) {
298 String [] pks = ( (_ServerSession) session).getUniqueInformation( ( (TableDetails) checkTableList.get(i)).getQualifiedIdentifier());
299 if (pks == null) {
300 return false;
301 }
302 String [] columns = getColumnsForOneTable( ( (TableDetails) checkTableList.get(i)).getQualifiedIdentifier(), cd);
303 boolean bb = checkForPrimaryColumn(pks, columns);
304 if (!bb) {
305 return false;
306 }
307 }
308 return true;
309 }
310
311 private boolean checkForPrimaryColumn(String [] pks, String [] columns) throws DException {
312 if (columns.length < pks.length) {
313 return false;
314 }
315 for (int i = 0; i < pks.length; i++) {
316 int j = 0;
317 for (; j < columns.length; j++) {
318 if ( (pks[i].equalsIgnoreCase(columns[j]))) {
319 break;
320 }
321 }
322 if (j == columns.length) {
323 return false;
324 }
325 }
326 return true;
327 }
328
329 private String [] getColumnsForOneTable(QualifiedIdentifier table, ColumnDetails[] cd) throws DException {
330 ArrayList aList = new ArrayList();
331 for (int i = 0; i < cd.length; i++) {
332 if (cd[i] != null && cd[i].getTable().getQualifiedIdentifier() == table) {
333 aList.add(cd[i].getColumn());
334 }
335 }
336 return (String []) aList.toArray(new String [aList.size()]);
337 }
338
339 private int search(String [] str1, String c) {
340 int length = str1.length;
341 for (int i = 0; i < length; i++) {
342 if (str1[i].equals(c)) {
343 return i;
344 }
345 }
346 return -1;
347 }
348
349 private int getTypeOfOrder() throws DException {
350 int type = -1;
351 for (int i = 0, length = columns.length; i < length; i++) {
352
353 int temp = getType(columns[i]);
354 if (type < temp) {
355 type = temp;
356 }
357 }
358 return type;
359 }
360
361 public void setSolvableByIndex(boolean orderSolvableByIndex0) throws DException {
362 isSolvableByIndex = orderSolvableByIndex0;
363 }
364
365 public boolean isSolvableByIndex() throws DException {
366 return isSolvableByIndex;
367 }
368
369 public String toString() {
370 try {
371 StringBuffer buffer = new StringBuffer ();
372 buffer.append("SELECT_ORDER");
373 buffer.append("[");
374 for (int i = 0; i < columns.length; i++) {
375 buffer.append(columns[i].getColumn() + "," + columns[i].getTable() + "," + orderSpecification[i] + ";");
376 }
377 buffer.append("]");
378 return buffer.toString().trim();
379 } catch (DException ex) {
380 return null;
381 }
382 }
383
384 public _Reference[] getReferences(TableDetails[] tableDetails) throws DException {
385 ArrayList aList = new ArrayList(columns.length);
386 getReferences(columns, tableDetails, aList);
387 return aList.isEmpty() ? null : (_Reference[]) aList.toArray(new _Reference[0]);
388 }
389
390 private void getReferences(ColumnDetails[] columns, TableDetails[] tableDetails, ArrayList aList) throws DException {
391 for (int i = 0; i < columns.length; i++) {
392 _Reference[] ref = columns[i].getReferences(tableDetails);
393 if (ref != null) {
394 aList.addAll(Arrays.asList(ref));
395 }
396 }
397
398 }
399
400 private void handleConstantOuterColumn(ColumnDetails cd, ArrayList aList) throws DException {
401 if (cd.getType() == CONSTANT && cd.getUnderLyingReference()) {
402 aList.add(cd);
403 }
404 }
405
406 private boolean matchTD(ColumnDetails cd, TableDetails[] td) throws DException {
407 if (cd.getTable() == null) {
408 return true;
409 }
410 for (int i = 0; i < td.length; i++) {
411 if (cd.getTable() == td[i]) {
412 return true;
413 }
414 }
415 return false;
416 }
417
418 public void releaseResource() throws DException {
419 orderComparator = null;
420 }
421
422 public void setIndexIsSameOrReverse(boolean flag) {
423 sameOrReverse = flag;
424 }
425
426 public boolean isSameOrReverse() {
427 return sameOrReverse;
428 }
429 }
430 |
Popular Tags |
Java API By Example, From Geeks To Geeks.