|
1 package com.daffodilwoods.daffodildb.server.sql99.common;
2
3 import java.math.*;
4 import java.sql.*;
5 import java.text.*;
6 import java.util.*;
7 import java.util.Date  ;
8
9 import com.daffodilwoods.daffodildb.server.datasystem.indexsystem.*;
10 import com.daffodilwoods.daffodildb.server.datasystem.interfaces.*;
11 import com.daffodilwoods.daffodildb.server.serversystem.*;
12 import com.daffodilwoods.daffodildb.server.sessionsystem.*;
13 import com.daffodilwoods.daffodildb.server.sql99.dql.execution.*;
14 import com.daffodilwoods.daffodildb.server.sql99.dql.iterator.*;
15 import com.daffodilwoods.daffodildb.server.sql99.dql.iterator.condition.*;
16 import com.daffodilwoods.daffodildb.server.sql99.dql.iterator.order.*;
17 import com.daffodilwoods.daffodildb.server.sql99.dql.plan.*;
18 import com.daffodilwoods.daffodildb.server.sql99.dql.plan.condition.*;
19 import com.daffodilwoods.daffodildb.server.sql99.dql.plan.table.*;
20 import com.daffodilwoods.daffodildb.server.sql99.expression.*;
21 import com.daffodilwoods.daffodildb.server.sql99.expression.
22 booleanvalueexpression.*;
23 import com.daffodilwoods.daffodildb.server.sql99.expression.expressionprimary.*;
24 import com.daffodilwoods.daffodildb.server.sql99.token.*;
25 import com.daffodilwoods.daffodildb.server.sql99.utils.*;
26 import com.daffodilwoods.daffodildb.server.sql99.utils.parser.*;
27 import com.daffodilwoods.daffodildb.utils.*;
28 import com.daffodilwoods.daffodildb.utils.byteconverter.*;
29 import com.daffodilwoods.daffodildb.utils.comparator.*;
30 import com.daffodilwoods.daffodildb.utils.field.*;
31 import com.daffodilwoods.database.general.*;
32 import com.daffodilwoods.database.resource.*;
33 import com.daffodilwoods.database.sqlinitiator.*;
34 import com.daffodilwoods.database.utility.*;
35 import java.util.Calendar ;
36 import java.util.GregorianCalendar ;
37 import com.daffodilwoods.daffodildb.utils.DTimeStamp;
38 import java.sql.Timestamp ;
39 import com.daffodilwoods.daffodildb.server.sql99.dql.iterator.table.DistinctIterator;
40 import com.daffodilwoods.daffodildb.server.sql99.dql.iterator.table.SingleTableIterator;
41
42 public class GeneralPurposeStaticClass
43 implements TypeConstants, Datatypes {
44
45 public static _KeyColumnInformation[] getKeyColumnInformations(_Iterator
46 leftIterator, _Iterator rightIterator) throws DException {
47
48 _KeyColumnInformation[] leftKeyColumns = leftIterator.
49 getKeyColumnInformations();
50 _KeyColumnInformation[] rightKeyColumns = rightIterator.
51 getKeyColumnInformations();
52 int leftLength = leftKeyColumns.length;
53 int rightLength = rightKeyColumns.length;
54 _KeyColumnInformation[] newKeyColumns = new _KeyColumnInformation[
55 leftLength + rightLength];
56 System.arraycopy(leftKeyColumns, 0, newKeyColumns, 0, leftLength);
57 System.arraycopy(rightKeyColumns, 0, newKeyColumns, leftLength, rightLength);
58 return newKeyColumns;
59
60 }
61
62
63 public static _Reference[] getUnderLyingReferencesOnly(_Reference[]
64 references, TableDetails[] tDetails) throws DException {
65 if (references != null) {
66 ArrayList arr = new ArrayList(5);
67
68 for (int i = 0; i < references.length; i++) {
69 if (references[i].getReferenceType() == SimpleConstants.COLUMNDETAIL) {
70 TableDetails refTD = ( (ColumnDetails) references[i]).getTable();
71 for (int j = 0; j < tDetails.length; j++) {
72 if (refTD != null &&
73 refTD.getQualifiedTableName().equalsIgnoreCase(tDetails[j].
74 getQualifiedTableName()))
75
76 arr.add(references[i]);
77 }
78 }
79 }
80 return arr.isEmpty() ? null : (_Reference[]) arr.toArray(new _Reference[0]);
81 }
82 return null;
83 }
84
85 public static Object [] getUniqueColumnReference(_Iterator leftIterator,
86 _Iterator rightIterator) throws
87 DException {
88 int[] leftArray = ( (int[]) leftIterator.getUniqueColumnReference()[0]);
89 int[] rightArray = ( (int[]) rightIterator.getUniqueColumnReference()[0]);
90 int leftLength = leftArray.length;
91 int rightLength = rightArray.length;
92 int[] newArray = new int[leftLength + rightLength];
93 System.arraycopy(leftArray, 0, newArray, 0, leftLength);
94 System.arraycopy(rightArray, 0, newArray, leftLength, rightLength);
95 return new Object [] {
96 newArray};
97
98 }
99
100 public static boolean seek(Object indexKey, _Iterator leftIterator,
101 _Iterator rightIterator) throws DException {
102
103 return leftIterator.seek(indexKey) && rightIterator.seek(indexKey);
104
105 }
106
107 public static _Reference[] changeReferences(Object [] array) throws DException {
108
109 if (array == null) {
110 return null;
111 }
112 int length = array.length;
113 _Reference[] reference = new _Reference[length];
114 for (int i = 0; i < length; ++i) {
115 reference[i] = (_Reference) array[i];
116 }
117 return reference;
118
119 }
120
121 public static int[] getSelectedIndexes(_Reference[] references,
122 _Reference[] localReferences) throws
123 DException {
124 int length = references.length;
125 int[] indexes = new int[length];
126 for (int i = 0; i < length; i++) {
127 indexes[i] = getSelectedColumnIndex(references[i], localReferences);
128 }
129 return indexes;
130 }
131
132 private static int getIndex(_Reference references,
133 _Reference[] localReferences) throws DException {
134 for (int j = 0, length1 = localReferences.length; j < length1; ++j) {
135 if (references.getQualifiedColumnName().equalsIgnoreCase(localReferences[
136 j].getQualifiedColumnName())) {
137 return j;
138 }
139 }
140 throw new DException("DSE3571", new Object [] {references.getColumn()});
141 }
142
143 public static int[] getIndexes(ColumnDetails[] columnDetails1) throws
144 DException {
145
146 int length = columnDetails1.length;
147 int[] indexes = new int[length];
148 for (int i = 0; i < length; ++i) {
149 indexes[i] = i;
150 }
151 return indexes;
152
153 }
154
155 public static int getSelectedColumnIndex(_Reference reference,
156 _Reference[] leftColumnReferences) throws
157 DException {
158 int index = 0;
159 try {
160 index = ( (ColumnDetails) reference).getUnionSelectedColumnIndex();
161 }
162 catch (DException ex) {
163 int j = 0, length1 = leftColumnReferences.length;
164 for (; j < length1; ++j) {
165 if ( ( (ColumnDetails) reference).isSame(leftColumnReferences[j])) {
166 index = j;
167 break;
168 }
169 }
170 if (j == length1) {
171 return -1;
172 }
173 ( (ColumnDetails) reference).setUnionSelectedColumn(index);
174 }
175 return index;
176 }
177
178 public static _Reference[] getReferencesToIndex(int[] indexes,
179 _Reference[] columnReferences) throws
180 DException {
181
182 int length = indexes.length;
183 _Reference[] newReferences = new _Reference[length];
184 for (int i = 0; i < length; ++i) {
185 newReferences[i] = columnReferences[indexes[i]];
186 }
187 return newReferences;
188
189 }
190
191
192 public static Object [] getJointValues(Object thisObject, Object [] values,
193 int length) {
194 if (length < 0) {
195 return values;
196 }
197 if (values != null) {
198 Object toRet[] = new Object [values.length + length];
199 System.arraycopy(values, 0, toRet, 0, values.length);
200 for (int i = values.length; i < toRet.length; i++) {
201 toRet[i] = thisObject;
202 }
203 return toRet;
204 }
205 else {
206 Object toRet[] = new Object [length];
207 Arrays.fill(toRet, thisObject);
208 return toRet;
209 }
210 }
211
212
222 public static _Reference[] getJointReferences(_Reference[] info1,
223 _Reference[] info2) throws
224 DException {
225 if (info2 == null) {
226 return info1;
227 }
228 if (info1 == null) {
229 return info2;
230 }
231 _Reference[] result = new _Reference[info1.length + info2.length];
232 System.arraycopy(info1, 0, result, 0, info1.length);
233 System.arraycopy(info2, 0, result, info1.length, info2.length);
234 return result;
235 }
236
237 public static Object [][] getMappingOfTableBVE(Object [][] mappingLeft,
238 Object [][] mappingRight) throws
239 DException {
240 if (mappingLeft == null && mappingRight == null) {
241 return null;
242 }
243 if (mappingRight == null) {
244 return mappingLeft;
245 }
246 if (mappingLeft == null) {
247 return mappingRight;
248 }
249 int lengthLeft = mappingLeft.length;
250 int lengthRight = mappingRight.length;
251 Object [][] newMapping = new Object [lengthLeft + lengthRight][3];
252 System.arraycopy(mappingLeft, 0, newMapping, 0, lengthLeft);
253 System.arraycopy(mappingRight, 0, newMapping, lengthLeft, lengthRight);
254 return newMapping;
255 }
256
257 public static boolean compareArrays(String [] source, String [] target) throws
258 DException {
259 int length = source.length, i = 0;
260 if (length != target.length) {
261 return false;
262 }
263 for (; i < length; i++) {
264 if (!source[i].equalsIgnoreCase(target[i])) {
265 return false;
266 }
267 }
268 return true;
269 }
270
271 public static _Order getJoinOrdered(_Order order1, _Order order2) throws
272 DException {
273 if (order1 == null) {
274 return order2;
275 }
276 if (order2 == null) {
277 return order1;
278 }
279
280 ColumnDetails[] colunmDetails1 = order1.getColumnDetails();
281 ColumnDetails[] colunmDetails2 = order2.getColumnDetails();
282 ColumnDetails[] columnDetails = new ColumnDetails[colunmDetails1.length +
283 colunmDetails2.length];
284 System.arraycopy(colunmDetails1, 0, columnDetails, 0, colunmDetails1.length);
285 System.arraycopy(colunmDetails2, 0, columnDetails, colunmDetails1.length,
286 colunmDetails2.length);
287 boolean[] orderSpec1 = order1.getOrderOfColumns();
288 boolean[] orderSpec2 = order2.getOrderOfColumns();
289 boolean[] orderSpec = new boolean[orderSpec1.length + orderSpec2.length];
290 System.arraycopy(orderSpec1, 0, orderSpec, 0, orderSpec1.length);
291 System.arraycopy(orderSpec2, 0, orderSpec, orderSpec1.length,
292 orderSpec2.length);
293 SuperComparator comp = ( (SelectOrder) order1).orderComparator != null ?
294 ( (SelectOrder) order1).orderComparator :
295 ( (SelectOrder) order2).orderComparator;
296 return new SelectOrder(columnDetails, orderSpec, comp);
297 }
298
299 public static TableDetails[] getJointTableDetails(TableDetails[] info1,
300 TableDetails[] info2) throws DException {
301
302 if (info2 == null) {
303 return info1;
304 }
305 if (info1 == null) {
306 return info2;
307 }
308 TableDetails[] result = new TableDetails[info1.length + info2.length];
309 System.arraycopy(info1, 0, result, 0, info1.length);
310 System.arraycopy(info2, 0, result, info1.length, info2.length);
311 return result;
312
313 }
314
315 public static int getColumnCount(TableDetails[] tableDetails) throws
316 DException {
317 int columnCount = 0;
318 for (int i = 0, length = tableDetails.length; i < length; i++) {
319 columnCount += tableDetails[i].cc.getColumnCount();
320 }
321 return columnCount;
322 }
323
324 public static Object getColumnValuesFromBoth(_Iterator leftIterator,
325 _Iterator rightIterator,
326 _Reference references) throws
327 DException {
328 try {
329 return leftIterator.getColumnValues(references);
330 }
331 catch (DException ex) {
332 return rightIterator.getColumnValues(references);
333 }
334 }
335
336 public static FieldBase getFieldValuesFromBoth(_Iterator leftIterator,
337 _Iterator rightIterator,
338 _Reference references) throws
339 DException {
340 try {
341 return leftIterator.field(references);
342 }
343 catch (DException ex) {
344 return rightIterator.field(references);
345 }
346 }
347
348 public static Object getColumnValuesFromQualified(_Iterator leftIterator,
349 _Iterator rightIterator, _Reference references, boolean flag) throws
350 DException {
351 try {
352 return leftIterator.getColumnValues(references);
353 }
354 catch (DException ex) {
355 if (flag) {
356 return new FieldLiteral(FieldUtility.NULLBUFFERRANGE,
357 ( (ColumnDetails) references).getDatatype());
358 }
359 return rightIterator.getColumnValues(references);
360 }
361 }
362
363 public static FieldBase getFieldFromQualified(_Iterator leftIterator,
364 _Iterator rightIterator,
365 _Reference references,
366 boolean flag) throws DException {
367 try {
368 return leftIterator.field(references);
369 }
370 catch (DException ex) {
371 if (flag) {
372 return new FieldLiteral(FieldUtility.NULLBUFFERRANGE,
373 ( (ColumnDetails) references).getDatatype());
374 }
375 return rightIterator.field(references);
376 }
377 }
378
379 public static ColumnDetails getCountCD() throws DException {
380 SNONRESERVEDWORD136444255Sleftparen653880241Sasterisk_344623246Srightparen_1874859514
381 res = new SNONRESERVEDWORD136444255Sleftparen653880241Sasterisk_344623246Srightparen_1874859514();
382 res._SNONRESERVEDWORD1364442553 = new SNONRESERVEDWORD136444255();
383 res._SNONRESERVEDWORD1364442553._SNONRESERVEDWORD1364442550 = "COUNT";
384
385 res._Sasterisk_3446232461 = new Sasterisk_344623246();
386 res._Sasterisk_3446232461._Sasterisk_3446232460 = "*";
387
388 res._Sleftparen6538802412 = new Sleftparen653880241();
389 res._Sleftparen6538802412._Sleftparen6538802410 = "(";
390
391 res._Srightparen_18748595140 = new Srightparen_1874859514();
392 res._Srightparen_18748595140._Srightparen_18748595140 = ")";
393 return res.getColumnDetails()[0];
394 }
395
396 public static ColumnDetails getAggregateCD(valueexpression ve,
397 String functionalType,
398 String quantifier) throws
399 DException {
400 generalsetfunction res = new generalsetfunction();
401 res._setfunctiontype4 = new setfunctiontype();
402 SNONRESERVEDWORD136444255 reserved = new SNONRESERVEDWORD136444255();
403 reserved._SNONRESERVEDWORD1364442550 = functionalType;
404 res._setfunctiontype4._setfunctiontype0 = reserved;
405
406 res._Sleftparen6538802413 = new Sleftparen653880241();
407 res._Sleftparen6538802413._Sleftparen6538802410 = "(";
408
409 SRESERVEDWORD1206543922 reserved1 = new SRESERVEDWORD1206543922();
410 reserved1._SRESERVEDWORD12065439220 = quantifier;
411 res._Optsetquantifier2 = reserved1;
412
413 res._valueexpression1 = ve;
414
415 res._Srightparen_18748595140 = new Srightparen_1874859514();
416 res._Srightparen_18748595140._Srightparen_18748595140 = ")";
417 return res.getColumnDetails()[0];
418 }
419
420 public static int[] getLeftandRightKeyCount(_Iterator leftIterator,
421 _Iterator rightIterator,
422 Object [][] tableAndKeyCount,
423 Object [][] tableDetailsCCMapping) throws
424 DException {
425 ArrayList leftSideKeyCountMapping = new ArrayList();
426 ArrayList rightSideKeyCountMapping = new ArrayList();
427 int[] counts = new int[2];
428 for (int i = 0, length = tableAndKeyCount.length; i < length; i++) {
429 TableDetails table = (TableDetails) tableAndKeyCount[i][0];
430 if (searchInMapping(table, tableDetailsCCMapping) == SimpleConstants.LEFT) {
431 counts[0] += tableAndKeyCount[i][1].hashCode();
432 leftSideKeyCountMapping.add(tableAndKeyCount[i]);
433 }
434 else {
435 counts[1] += tableAndKeyCount[i][1].hashCode();
436 rightSideKeyCountMapping.add(tableAndKeyCount[i]);
437 }
438 }
439 if (!leftSideKeyCountMapping.isEmpty()) {
440 leftIterator.setKeyCount( (Object [][]) leftSideKeyCountMapping.toArray(new
441 Object [leftSideKeyCountMapping.size()][2]));
442 }
443 if (!rightSideKeyCountMapping.isEmpty()) {
444 rightIterator.setKeyCount( (Object [][]) rightSideKeyCountMapping.toArray(new
445 Object [rightSideKeyCountMapping.size()][2]));
446 }
447 return counts;
448 }
449
450
463
464 private static int searchInMapping(TableDetails table,
465 Object [][] tableDetailsMapping) throws
466 DException {
467 for (int i = 0; i < tableDetailsMapping.length; i++) {
468 if (tableDetailsMapping[i][0] == table) {
469 return ( (Integer ) tableDetailsMapping[i][1]).intValue();
470 }
471 }
472 return -1;
473 }
474
475 public static _Iterator getTemporaryIndexIterator(_Iterator
476 underLyingIterator, _TablePlan underLyingPLan,
477 _ServerSession serverSession, _Order order) throws DException {
478 TableDetails[] tables = underLyingPLan.getTableDetails();
479
480 _Order tempOrder = GeneralPurposeStaticClass.getJoinOrdered(order,
481 underLyingIterator.getDefaultOrder());
482
483 _Reference[] tempRef = tempOrder.getReferences(tables);
484
485 _VariableValues vv = new VariableValues(tempRef, serverSession);
486 vv.setIterator(underLyingIterator);
487 if(underLyingPLan.getRowCount(serverSession)<=2000 && (underLyingIterator instanceof SingleTableIterator))
488 return new MemoryIndexIterator(underLyingIterator,new ExpressionOrderValues(tempOrder, vv));
489 CbCUsffWbmvfIboemfs tempHandler = new TempIndexHandler(underLyingIterator);
490 return serverSession.getIndexedIterator(underLyingIterator, new ExpressionOrderValues(tempOrder, vv),tempHandler); }
492
493 public static _Iterator getTemporaryIndexIterator(_Iterator
494 underLyingIterator, _TablePlan underLyingPLan,
495 _ServerSession serverSession, _Order order, _Order defaultOrder) throws
496 DException {
497 TableDetails[] tables = underLyingPLan.getTableDetails();
498 _Order tempOrder = GeneralPurposeStaticClass.getJoinOrdered(order,
499 defaultOrder);
500 _Reference[] tempRef = tempOrder.getReferences(tables);
501 _VariableValues vv = new VariableValues(tempRef, serverSession);
502
503 vv.setIterator(underLyingIterator);
504 if(underLyingPLan.getRowCount(serverSession)<=2000 && (underLyingIterator instanceof SingleTableIterator))
505 return new MemoryIndexIterator(underLyingIterator,new ExpressionOrderValues(tempOrder, vv));
506 CbCUsffWbmvfIboemfs tempHandler = new TempIndexHandler(underLyingIterator);
507
508 return serverSession.getIndexedIterator(underLyingIterator,
509 new
510 ExpressionOrderValues(tempOrder, vv),
511 tempHandler);
512 }
513
514 public static _Iterator getTemporaryIndexIterator(_Iterator
515 underLyingIterator, _TablePlan underLyingPLan,
516 _ServerSession serverSession, _Order order,
517 _KeyColumnInformation[] keyColumns) throws DException {
518 TableDetails[] tables = underLyingPLan.getTableDetails();
519
520
521 _Order tempOrder = getJoinOrdered(order, underLyingIterator.getDefaultOrder());
522 _Reference[] tempRef = tempOrder.getReferences(tables);
523
524 _VariableValues vv = new VariableValues(tempRef, serverSession);
525 vv.setIterator(underLyingIterator);
526 CbCUsffWbmvfIboemfs tempHandler = new TempIndexHandler(underLyingIterator);
527 TemporaryIndexIterator tempIndexIterator = (TemporaryIndexIterator)
528 serverSession.getIndexedIterator(underLyingIterator,new ExpressionOrderValues(tempOrder, vv), tempHandler); return new TemporaryIndexWrapperIterator(tempIndexIterator,
530 underLyingIterator);
531 }
532
533 public static _KeyColumnInformation[] getKeyColumns(_Order order) throws
534 DException {
535 boolean[] orders = order.getOrderOfColumns();
536 ColumnDetails[] columnDetails = order.getKeyColumnDetails();
537 int len = columnDetails.length;
538 _KeyColumnInformation[] keyColumnInformation = new _KeyColumnInformation[
539 len];
540 for (int i = 0; i < len; i++) {
541 keyColumnInformation[i] = new TableKeyColumnInformation(columnDetails[i],
542 orders[i]);
543 keyColumnInformation[i].setTableDetails(columnDetails[i].getTableDetails());
544 }
545 return keyColumnInformation;
546 }
547
548 public static void printProperties(_Iterator iterator, _TablePlan tablePLan,
549 Object rowMapping,
550 _KeyColumnInformation[] keyColumns,
551 ColumnDetails[] columns) throws DException {
552 if (iterator != null) {
553 }
554 if (tablePLan != null) {
555 }
556 if (rowMapping != null) {
557 }
558 if (keyColumns != null) {
559 for (int i = 0; i < keyColumns.length; i++) {
560 }
561 }
562 if (columns != null) {
563 for (int i = 0; i < columns.length; i++) {
564 TableDetails t = columns[i].getTable();
565 }
566 }
567 }
568
569
579 public static ColumnDetails[] getColumnDetailsAccToIndexes(int[] indexes,
580 ColumnDetails[] columns) throws DException {
581 ColumnDetails[] derivedColumnDetails = new ColumnDetails[indexes.length];
582 for (int i = 0, length = indexes.length; i < length; ++i) {
583 derivedColumnDetails[i] = columns[indexes[i]]; }
585 return derivedColumnDetails;
586 }
587
588 public static Object [] getColumnIndexesAndBooleanOrderOfOrderby(_Order order,
589 ColumnDetails[] columnDetails1) throws DException {
590 ColumnDetails[] orderColumnDetails = order.getKeyColumnDetails();
591 boolean[] orderSpecification = order.getOrderOfColumns();
592 int length = columnDetails1.length;
594 boolean[] adjustedOrderSpecification = new boolean[orderColumnDetails.
595 length];
596 int[] adjustedOrderIndexes = new int[orderColumnDetails.length];
597
598 int index = 0;
599 for (int i = 0, length1 = orderColumnDetails.length; i < length1; ++i) {
600 String columnName = orderColumnDetails[i].getColumn();
601 if (index < length1) {
602 for (int j = 0; j < length; ++j) {
603 if (isSameTableDetails(orderColumnDetails[i].getTable(),
604 columnDetails1[j].getTable()) &&
605 columnName.trim().equalsIgnoreCase(columnDetails1[j].getColumn().
606 trim())) {
607 adjustedOrderIndexes[index] = j; adjustedOrderSpecification[index] = orderSpecification[i]; }
610 }
611 index++;
612 }
613 }
614 if (index == 0) {
615 return null;
616 }
617 return new Object [] {
618 adjustedOrderIndexes, adjustedOrderSpecification};
619 }
620
621
639 public static Object [] getColumnIndexesAndBooleanOrderOfAdjustedOrder(_Order
640 order, ColumnDetails[] columnDetails1, boolean isDistinct) throws
641 DException {
642 ColumnDetails[] orderColumnDetails = order.getKeyColumnDetails();
643 boolean[] orderSpecification = order.getOrderOfColumns();
644 int length = columnDetails1.length; int noOfRepetiton = 0;
646 ArrayList list = new ArrayList();
647
648 for (int i = 0; i < orderColumnDetails.length; i++) {
649 String a = orderColumnDetails[i].getAppropriateColumn();
650 if (list.contains(a))
651 noOfRepetiton++;
652 else
653 list.add(a);
654 }
655
656 boolean[] adjustedOrderSpecification = new boolean[noOfRepetiton + length];
657 int[] adjustedOrderIndexes = new int[noOfRepetiton + length];
658
659 int index = 0;
660 for (int i = 0, length1 = orderColumnDetails.length; i < length1; ++i) {
661 String columnName = orderColumnDetails[i].getColumn();
662 boolean matchCheck = false;
663 for (int j = 0; j < length; ++j) {
664 if (orderColumnDetails[i].getTable() == columnDetails1[j].getTable() &&
665 columnName.trim().equalsIgnoreCase(columnDetails1[j].getColumn().
666 trim()) &&
667 !columnName.trim().equalsIgnoreCase("null") &&
668 !columnDetails1[j].getColumn().trim().equalsIgnoreCase("null")) {
669 adjustedOrderIndexes[index] = j; adjustedOrderSpecification[index++] = orderSpecification[i]; matchCheck = true;
672
673 }
674 }
675
683
684 if (isDistinct) {
685 if (!matchCheck) {
686 return null;
687 }
688 }
689 }
690 if (index == 0) {
691 return null;
692 }
693
694 int toLength = index;
695 for (int i = 0; i < length; ++i) {
696 boolean matched = false;
697 for (int j = 0; j < toLength; ++j) {
698 if (i == adjustedOrderIndexes[j]) {
699 matched = true;
700 break;
701 }
702 }
703 if(!matched) {
704 adjustedOrderIndexes[index] = i;
705 adjustedOrderSpecification[index++] = true;
706 }
707 }
708 return new Object [] {
709 adjustedOrderIndexes, adjustedOrderSpecification};
710 }
711
712 public static TableDetails[] getTableDetailsOfRefernceType(ColumnDetails[]
713 columnDetails, ArrayList aList) throws DException {
714 for (int i = 0; i < columnDetails.length; i++) {
715 int type = columnDetails[i].getType();
716 if (type == SCALARFUNCTION || type == CASEEXPRESSION ||
717 type == FUNCTIONAL) {
718 ColumnDetails[] childColumnDetails = columnDetails[i].
719 getChildColumnDetails();
720 getTableDetailsOfRefernceType(childColumnDetails, aList);
721 }
722 if (columnDetails[i].getType() == REFERENCE) {
723 TableDetails table = columnDetails[i].getTableDetails();
724 if (!aList.contains(table)) {
725 aList.add(table);
726 }
727 }
728 }
729 return (TableDetails[]) aList.toArray(new TableDetails[aList.size()]);
730 }
731
732 public static _Iterator getNonIndexedFilterIterator(_ServerSession
733 serverSession, booleanvalueexpression nonIndexedCondition,
734 TableDetails[] tableDetails, _Iterator underLyingIterator) throws
735 DException {
736 _VariableValues variableValues = getNewVariableValues(nonIndexedCondition,
737 tableDetails, serverSession);
738 return getNonIndexedIterator(variableValues, underLyingIterator,
739 nonIndexedCondition);
740 }
741
742 public static _Iterator getNonIndexedFilterIteratorForConditionExecute(Object
743 indexTable, booleanvalueexpression nonIndexedCondition,
744 TableDetails[] tableDetails, _Iterator underLyingIterator) throws
745 DException {
746 _VariableValues variableValues = getNewVariableValuesForConditionExecute(
747 nonIndexedCondition, tableDetails, indexTable);
748 return getNonIndexedIterator(variableValues, underLyingIterator,
749 nonIndexedCondition);
750 }
751
752 private static _Iterator getNonIndexedIterator(_VariableValues variableValues,
753 _Iterator underLyingIterator,
754 booleanvalueexpression
755 nonIndexedCondition) throws
756 DException {
757 variableValues.setIterator(underLyingIterator);
758 ConditionVariableValue conditionVariableValue = new ConditionVariableValue(
759 variableValues, nonIndexedCondition);
760 NonIndexedFilterIterator nifi = new NonIndexedFilterIterator(
761 underLyingIterator, conditionVariableValue);
762 return nifi;
763 }
764
765 private static _Reference[] getSimpleReferences(_Reference[] references) throws
766 DException {
767 int length = references.length;
768 ArrayList aList = new ArrayList(length);
769 for (int i = 0; i < length; i++) {
770 if (references[i].getReferenceType() != SimpleConstants.SUBQUERY) {
771 aList.add(references[i]); }
773 }
774 return (_Reference[]) aList.toArray(new _Reference[aList.size()]);
775 }
776
777 private static Object [][] getSubQueryIteratorMapping(_Reference[] references,
778 _ServerSession serverSession) throws DException {
779 int length = references.length;
780 ArrayList aList = new ArrayList(length);
781 for (int i = 0; i < length; i++) {
782 if (references[i].getReferenceType() == SimpleConstants.SUBQUERY) {
783 _Iterator iter = ( (subquery) references[i]).getSelectIterator(
784 serverSession);
785 aList.add(new Object [] {references[i], iter}); }
787 }
788 Object [][] obj = (Object [][]) aList.toArray(new Object [aList.size()][2]);
789 return obj;
790 }
791
792 private static boolean checkForSubQuery(_Reference[] references) throws
793 DException {
794 if (references != null) {
795 int length = references.length;
796 for (int i = 0; i < length; i++) {
797 if (references[i].getReferenceType() == SimpleConstants.SUBQUERY) {
798 return true;
799 }
800 }
801 }
802 return false;
803 }
804
805 private static _VariableValues getNewVariableValuesForConditionExecute(
806 booleanvalueexpression condition, TableDetails[] tableDetails,
807 Object indexTable) throws DException {
808 _Reference[] references = condition.getReferences(tableDetails);
809 _VariableValues variableValues = null;
810 _ServerSession serverSession = indexTable instanceof _SessionGetter ?
811 ( (_SessionGetter) indexTable).getServerSession() : null;
812 if (checkForSubQuery(references)) {
813 Object [][] subQueryIteratorMapping = getSubQueryIteratorMapping(
814 references, serverSession);
815 references = getSimpleReferences(references);
816 variableValues = new SubQueryVariableValues(references,
817 subQueryIteratorMapping,
818 serverSession);
819 }
820 else {
821 variableValues = new VariableValues(references, serverSession);
822 }
823 return variableValues;
824 }
825
826 public static _VariableValues getNewVariableValues(booleanvalueexpression
827 condition, TableDetails[] tableDetails, _ServerSession serverSession) throws
828 DException {
829 _Reference[] references = condition.getReferences(tableDetails);
830 return getVariableValues(references, serverSession);
831 }
832
833 public static _VariableValues getVariableValues(_Reference[] references,
834 _ServerSession serverSession) throws
835 DException {
836 _VariableValues variableValues = null;
837 if (checkForSubQuery(references)) {
838 Object [][] subQueryIteratorMapping = getSubQueryIteratorMapping(
839 references, serverSession);
840 references = getSimpleReferences(references);
841 variableValues = new SubQueryVariableValues(references,
842 subQueryIteratorMapping,
843 serverSession);
844 }
845 else {
846 variableValues = new VariableValues(references, serverSession);
847 }
848 return variableValues;
849 }
850
851 public static ParameterInfo[] changeIntoParameterInfo(Object [] array) throws
852 DException {
853
854 if (array == null) {
855 return null;
856 }
857 int length = array.length;
858 ParameterInfo[] parameterInfo = new ParameterInfo[length];
859 for (int i = 0; i < length; ++i) {
860 parameterInfo[i] = (ParameterInfo) array[i];
861 }
862 return parameterInfo;
863
864 }
865
866 public static FieldBase[] changeIntoFieldBase(Object [] array) throws
867 DException {
868
869 if (array == null) {
870 return null;
871 }
872
873 int length = array.length;
874 FieldBase[] fieldBase = new FieldBase[length];
875 for (int i = 0; i < length; ++i) {
876 fieldBase[i] = (FieldBase) array[i];
877 }
878 return fieldBase;
879
880 }
881
882 public static SuperComparator getOrderComparator(ColumnDetails[] columns,
883 boolean[] orderSpecification) throws DException {
884 int length = columns.length;
885 SuperComparator[] comparators = new SuperComparator[length];
886 for (int i = 0; i < length; i++) {
887 TableDetails td = columns[i].getTable();
888 comparators[i] = td == null ?
889 new CPsefsDpnqbsbups(new CPckfduDpnqbsbups(), orderSpecification[i])
890 :
891 new CPsefsDpnqbsbups(GetByteComparator.getComparator(columns[i].
892 getDatatypeForOrder(), true,
893 td.getColumnCharacteristics().getCollator()), orderSpecification[i]);
894 }
895 return new CKpjoDpnqbsbups(comparators);
896 }
897
898
900 public static SuperComparator getOrderComparatorForBufferRange(ColumnDetails[]
901 columns, boolean[] orderSpecification) throws DException {
902 int length = columns.length;
903 SuperComparator[] comparators = new SuperComparator[length];
904 for (int i = 0; i < length; i++) {
905 TableDetails td = columns[i].getTable();
906 Collator collator = td == null ? null :
907 td.getColumnCharacteristics().getCollator();
908
909
910 comparators[i] = new CPsefsDpnqbsbups(GetByteComparator.
911 getComparatorForDataSystem(columns[i].
912 getDatatypeForOrder(), true, collator), orderSpecification[i]);
913 }
914
915 return new CKpjoDpnqbsbups(comparators);
916
917 }
918
919 public static Object [] initiateSetConditionVariableValues(_Iterator iterator,
920 _Reference[] references, Object [] values, int priority) throws DException {
921 Object [] fieldValues = null;
922 if (references != null) {
923 int length = values.length;
924 fieldValues = new Object [length];
925 for (int i = 0; i < length; i++) {
926 if (values[i] instanceof FieldBase) {
927 fieldValues[i] = values[i];
928 }
929 else if (values[i] instanceof Object [][]) {
930 fieldValues[i] = getFieldBases( (Object [][]) values[i]);
931 }
932 else if (values[i] instanceof Object []) {
933 fieldValues[i] = getFieldBases( (Object []) values[i]);
934 }
935 else {
936
937
938 fieldValues[i] = FieldUtility.getFieldForVariable(values[i]);
939
940
941
942
943 }
944 }
945 }
946 iterator.setConditionVariableValue(references, fieldValues, priority);
947 return fieldValues;
948 }
949
950 private static Object [][] getFieldBases(Object [][] source) throws DException {
951 Object [][] result = new Object [source.length][];
952 for (int i = 0; i < source.length; i++) {
953 result[i] = (Object []) getFieldBases(source[i]);
954 }
955 return result;
956 }
957
958 private static Object [] getFieldBases(Object [] source) throws DException {
959 Object [] result = new Object [source.length];
960 for (int i = 0; i < source.length; i++) {
961 result[i] = FieldUtility.getFieldForVariable(source[i]);
962 }
963 return result;
964 }
965
966
967 private static boolean isResultaBigDecimal(Object result) throws DException {
968 if (result instanceof BigDecimal) {
969 return true;
970 }
971 else {
972 return false;
973 }
974 }
975
976 private static int tryAddingIntAndInt(int first, int second) throws
977 DException {
978 int sum = 0;
979 if (first >= 0 && second >= 0) {
980 sum = first + second;
981 if (sum < 0) {
982 throw new DException("DSE8101", new Object [] {"OVERFLOW"});
983 }
984 else {
985 return sum;
986 }
987 }
988 if (first <= 0 && second <= 0) {
989 sum = first + second;
990 if (sum > 0) {
991 throw new DException("DSE8101", new Object [] {"OVERFLOW"});
992 }
993 else {
994 return sum;
995 }
996 }
997 return (first + second);
998 }
999
1000 private static long tryAddingLongAndInt(Object result, int second) throws
1001 DException {
1002 long first = ( (Long ) result).longValue();
1003 long sum = 0;
1004 if (first >= 0 && second >= 0) {
1005 sum = first + second;
1006 if (sum < 0) {
1007 throw new DException("DSE8101", new Object [] {"OVERFLOW"});
1008 }
1009 else {
1010 return sum;
1011 }
1012 }
1013 if (first <= 0 && second <= 0) {
1014 sum = first + second;
1015 if (sum > 0) {
1016 throw new DException("DSE8101", new Object [] {"OVERFLOW"});
1017 }
1018 else {
1019 return sum;
1020 }
1021 }
1022 return (first + second);
1023 }
1024
1025 private static long tryAddingLongAndLong(long first, long second) throws
1026 DException {
1027 long sum = 0;
1028 if (first >= 0 && second >= 0) {
1029 sum = first + second;
1030 if (sum < 0) {
1031 throw new DException("DSE8101", new Object [] {"OVERFLOW"});
1032 }
1033 else {
1034 return sum;
1035 }
1036 }
1037 if (first <= 0 && second <= 0) {
1038 sum = first + second;
1039 if (sum > 0) {
1040 throw new DException("DSE8101", new Object [] {"OVERFLOW"});
1041 }
1042 else {
1043 return sum;
1044 }
1045 }
1046 return (first + second);
1047 }
1048
1049 private static float tryAddingFloatAndFloat(float first, float second) throws
1050 DException {
1051 float sum;
1052 if (first >= 0 && second >= 0) {
1053 sum = first + second;
1054 if (sum < 0) {
1055 throw new DException("DSE8101", new Object [] {"OVERFLOW"});
1056 }
1057 else {
1058 return sum;
1059 }
1060 }
1061 if (first <= 0 && second <= 0) {
1062 sum = first + second;
1063 if (sum > 0) {
1064 throw new DException("DSE8101", new Object [] {"OVERFLOW"});
1065 }
1066 else {
1067 return sum;
1068 }
1069 }
1070 return (first + second);
1071 }
1072
1073 private static double tryAddingDoubleAndDouble(double first, double second) throws
1074 DException {
1075 double sum;
1076 if (first >= 0 && second >= 0) {
1077 sum = first + second;
1078 if (sum < 0) {
1079 throw new DException("DSE8101", new Object [] {"OVERFLOW"});
1080 }
1081 else {
1082 return sum;
1083 }
1084 }
1085 if (first <= 0 && second <= 0) {
1086 sum = first + second;
1087 if (sum > 0) {
1088 throw new DException("DSE8101", new Object [] {"OVERFLOW"});
1089 }
1090 else {
1091 return sum;
1092 }
1093 }
1094 return (first + second);
1095 }
1096
1097 public static boolean checkForIntAndDouble(int type) {
1098
1099 return ( (type >= 0 && type <= 5) || (type >= 5 && type <= 15));
1100 }
1101
1102 public static Object computeSum(Object result, FieldBase newObject,
1103 int dataType) throws DException {
1104 switch (dataType) {
1105 case BYTE:
1106 case TINYINT:
1107 case INTEGER:
1108 case INT:
1109 case SHORT:
1110 case SMALLINT:
1111 int secondInt = ( (Number ) newObject.getObject()).intValue();
1112 Number nm = (Number ) result;
1113 int firstInt = ( (Number ) result).intValue();
1114 int intSum = tryAddingIntAndInt(firstInt, secondInt);
1115 return new Integer (intSum);
1116 case LONG:
1117 case BIGINT:
1118 long secondLong = ( (Number ) newObject.getObject()).longValue();
1119 long firstLong = ( (Number ) result).longValue();
1120 long longSum = tryAddingLongAndLong(firstLong, secondLong);
1121 return new Long (longSum);
1122 case REAL:
1123 float firstFloat = ( (Number ) result).floatValue();
1124 float secondFloat = ( (Number ) newObject.getObject()).floatValue();
1125 float sum = tryAddingFloatAndFloat(firstFloat, secondFloat);
1126 return new Float (sum);
1127 case DOUBLE:
1128 case FLOAT:
1129 case DOUBLEPRECISION:
1130 double firstDouble = ( (Number ) result).doubleValue();
1131 double secondDouble = ( (Number ) newObject.getObject()).doubleValue();
1132 double sumDouble = tryAddingDoubleAndDouble(firstDouble, secondDouble);
1133 return new Double (sumDouble);
1134 case DEC:
1135 case DECIMAL:
1136 case NUMERIC:
1137 case BIGDECIMAL:
1138 if (result instanceof BigDecimal) {
1139 if (newObject.getObject() instanceof BigDecimal) {
1140 result = ( (BigDecimal) result).add( (BigDecimal) newObject.
1141 getObject());
1142 }
1143 else {
1144 result = ( (BigDecimal) result).add(new BigDecimal("" +
1145 ( (Number ) newObject.getObject()).doubleValue()));
1146 }
1147 return result;
1148 }
1149 BigDecimal sumBig = new BigDecimal("" + ( (Number ) result).doubleValue());
1150 if (newObject.getObject() instanceof BigDecimal) {
1151 sumBig = sumBig.add( (BigDecimal) newObject.getObject());
1152 }
1153 else {
1154 sumBig = sumBig.add(new BigDecimal("" +
1155 ( (Number ) newObject.getObject()).
1156 doubleValue()));
1157 }
1158 return sumBig;
1159 }
1160 return null;
1161 }
1162
1163 public static void checkForValidColumnsInAggregatesSumAndAvg(ColumnDetails[]
1164 cd, String functionName) throws DException {
1165 for (int i = 0; i < cd.length; i++) {
1166 int dt = cd[i].getDatatype();
1167 switch (dt) {
1168 case DATE:
1169 throw new DException("DSE4111", new Object [] {functionName,
1170 StaticClass.getDataTypeName(DATE)}); case TIME:
1172 throw new DException("DSE4111", new Object [] {functionName,
1173 StaticClass.getDataTypeName(TIME)});
1174 case TIMESTAMP:
1175 throw new DException("DSE4111", new Object [] {functionName,
1176 StaticClass.getDataTypeName(TIMESTAMP)});
1177 case TIME_WITH_TIMEZONE:
1178 throw new DException("DSE4111", new Object [] {functionName,
1179 StaticClass.getDataTypeName(TIME_WITH_TIMEZONE)});
1180 case TIMESTAMP_WITH_TIMEZONE:
1181 throw new DException("DSE4111", new Object [] {functionName,
1182 StaticClass.getDataTypeName(
1183 TIMESTAMP_WITH_TIMEZONE)});
1184 case BLOB:
1185 throw new DException("DSE4111", new Object [] {functionName,
1186 StaticClass.getDataTypeName(BLOB)});
1187 case LONGVARBINARY:
1188 throw new DException("DSE4111", new Object [] {functionName,
1189 StaticClass.getDataTypeName(LONGVARBINARY)});
1190 case CLOB:
1191 throw new DException("DSE4111", new Object [] {functionName,
1192 StaticClass.getDataTypeName(CLOB)});
1193 case CHARACTER:
1194 throw new DException("DSE4111", new Object [] {functionName,
1195 StaticClass.getDataTypeName(CHARACTER)});
1196 case CHARACTERLARGEOBJECT:
1197 throw new DException("DSE4111", new Object [] {functionName,
1198 StaticClass.getDataTypeName(CHARACTERLARGEOBJECT)});
1199 case CHARLARGEOBJECT:
1200 throw new DException("DSE4111", new Object [] {functionName,
1201 StaticClass.getDataTypeName(CHARLARGEOBJECT)});
1202 case BINARYLARGEOBJECT:
1203 throw new DException("DSE4111", new Object [] {functionName,
1204 StaticClass.getDataTypeName(BINARYLARGEOBJECT)});
1205 case BITVARYING:
1206 throw new DException("DSE4111", new Object [] {functionName,
1207 StaticClass.getDataTypeName(BITVARYING)});
1208 case VARBINARY:
1209 throw new DException("DSE4111", new Object [] {functionName,
1210 StaticClass.getDataTypeName(VARBINARY)});
1211 case VARCHAR:
1212 throw new DException("DSE4111", new Object [] {functionName,
1213 StaticClass.getDataTypeName(VARCHAR)});
1214 case LONGVARCHAR:
1215 throw new DException("DSE4111", new Object [] {functionName,
1216 StaticClass.getDataTypeName(LONGVARCHAR)});
1217 case BOOLEAN:
1218 throw new DException("DSE4111", new Object [] {functionName,
1219 StaticClass.getDataTypeName(BOOLEAN)});
1220 default:
1221 }
1222 }
1223 }
1224
1225 public static void checkForValidColumnsInAggregatesMaxMinAndCount(
1226 ColumnDetails[] cd, String functionName) throws DException {
1227 for (int i = 0; i < cd.length; i++) {
1228 int dt = cd[i].getDatatype();
1229 switch (dt) {
1230 case BLOB:
1231 throw new DException("DSE4111", new Object [] {functionName,
1232 StaticClass.getDataTypeName(BLOB)});
1233 case CLOB:
1234 throw new DException("DSE4111", new Object [] {functionName,
1235 StaticClass.getDataTypeName(CLOB)});
1236 case CHARACTERLARGEOBJECT:
1237 throw new DException("DSE4111", new Object [] {functionName,
1238 StaticClass.getDataTypeName(CHARACTERLARGEOBJECT)});
1239 case CHARLARGEOBJECT:
1240 throw new DException("DSE4111", new Object [] {functionName,
1241 StaticClass.getDataTypeName(CHARLARGEOBJECT)});
1242 case BINARYLARGEOBJECT:
1243 throw new DException("DSE4111", new Object [] {functionName,
1244 StaticClass.getDataTypeName(BINARYLARGEOBJECT)});
1245 case LONGVARBINARY:
1246 throw new DException("DSE4111", new Object [] {functionName,
1247 StaticClass.getDataTypeName(LONGVARBINARY)});
1248 case BOOLEAN:
1249 throw new DException("DSE4111", new Object [] {functionName,
1250 StaticClass.getDataTypeName(BOOLEAN)});
1251 default:
1252 }
1253 }
1254 }
1255
1256 public static void convertintoObjects(Object fbase1) throws DException {
1257 if (fbase1 instanceof Object []) {
1258 Object [] fbase = (Object []) fbase1;
1259 Object [] values = new Object [fbase.length];
1260 for (int i = 0; i < fbase.length; i++) {
1261 values[i] = ( (FieldBase) fbase[i]).getObject();
1262 }
1263 }
1264 else {
1265 }
1266 }
1267
1268 public static SuperComparator getObjectOrderComparator(boolean[]
1269 orderSpecification) throws DException {
1270 int length = orderSpecification.length;
1271 SuperComparator[] comparators = new SuperComparator[length];
1272 for (int i = 0; i < length; i++) {
1273 comparators[i] = new CPsefsDpnqbsbups(new CPckfduDpnqbsbups(),
1274 orderSpecification[i]);
1275 }
1276 return new CKpjoDpnqbsbups(comparators);
1277 }
1278
1279 public static ArrayList getTableDetails(_BVEPlan bvePlan) throws DException {
1280 ArrayList tableList = new ArrayList();
1281 _BVESingleTablePlan bveSingleTablePlans[] = bvePlan.getBVESingleTablePlans();
1282 if (bveSingleTablePlans != null) {
1283 for (int j = 0; j < bveSingleTablePlans.length; j++) {
1284 if (!bveSingleTablePlans[j].getCondition().isNullPredicate()) {
1285 TableDetails td = bveSingleTablePlans[j].getTableDetails()[0];
1286 if (!tableList.contains(td)) {
1287 tableList.add(td);
1288 }
1289 }
1290 }
1291 }
1292 _AllTablesJoinRelation allTablesJoinRelation = bvePlan.
1293 getAllTableJoinRelation();
1294 if (allTablesJoinRelation != null) {
1295 _JoinRelation joinRelations[] = allTablesJoinRelation.getRelations();
1296 for (int i = 0; i < joinRelations.length; i++) {
1297 TableDetails[] tds = joinRelations[i].getTableDetails();
1298 for (int j = 0; j < tds.length; j++) {
1299 if (!tableList.contains(tds[j])) {
1300 tableList.add(tds[j]);
1301 }
1302 }
1303 }
1304 }
1305 return tableList;
1306 }
1307
1308 public static ArrayList getAllTableDetails(_BVEPlan bvePlan) throws
1309 DException {
1310 ArrayList tableList = new ArrayList();
1311 _BVESingleTablePlan bveSingleTablePlans[] = bvePlan.getBVESingleTablePlans();
1312 if (bveSingleTablePlans != null) {
1313 for (int j = 0; j < bveSingleTablePlans.length; j++) {
1314 TableDetails td = bveSingleTablePlans[j].getTableDetails()[0];
1315 if (!tableList.contains(td)) {
1316 tableList.add(td);
1317 }
1318 }
1319 }
1320 _AllTablesJoinRelation allTablesJoinRelation = bvePlan.
1321 getAllTableJoinRelation();
1322 if (allTablesJoinRelation != null) {
1323 _JoinRelation joinRelations[] = allTablesJoinRelation.getRelations();
1324 for (int i = 0; i < joinRelations.length; i++) {
1325 TableDetails[] tds = joinRelations[i].getTableDetails();
1326 for (int j = 0; j < tds.length; j++) {
1327 if (!tableList.contains(tds[j])) {
1328 tableList.add(tds[j]);
1329 }
1330 }
1331 }
1332 }
1333 booleanvalueexpression remainingCondition = bvePlan.getRemainingCondition();
1334 if (remainingCondition != null) {
1335 remainingCondition.getTablesIncluded(tableList);
1336 }
1337 booleanvalueexpression aggregateCondition = bvePlan.getAggregateCondition();
1338 if (aggregateCondition != null) {
1339 aggregateCondition.getTablesIncluded(tableList);
1340 }
1341 return tableList;
1342 }
1343
1344 public static boolean isSameParameterTypes(Object [] previousParameters,
1345 Object [] newParameters,
1346 Object [] fieldBases) throws
1347 DException {
1348 for (int i = 0, j = 0;
1349 i < previousParameters.length && j < newParameters.length; i++, j++) {
1350 if (newParameters[j] == null) {
1351 continue;
1352 }
1353 if (previousParameters[i] == null && newParameters[j] != null) {
1354 return false;
1355 }
1356 if (previousParameters[i] instanceof FieldBase &&
1357 newParameters[j] instanceof FieldBase &&
1358 ( (FieldBase) previousParameters[i]).getDatatype() !=
1359 ( (FieldBase) newParameters[j]).getDatatype()) {
1360 return false;
1361 }
1362 if (previousParameters[i].getClass() != newParameters[j].getClass()) {
1363 return false;
1364 }
1365 if (previousParameters[i] instanceof Object [] ||
1366 previousParameters[i] instanceof Object [][]) {
1367 return false;
1368 }
1369 if (previousParameters[i].getClass() == newParameters[j].getClass() &&
1370 ( (FieldBase) fieldBases[i]).getDatatype() == -1) {
1371 return false;
1372 }
1373 }
1374 return true;
1375 }
1376
1377 public static Object [] getCombinedArray(Object [] first, Object [] second) {
1378 if (first == null) {
1379 return second;
1380 }
1381 if (second == null) {
1382 return first;
1383 }
1384 int length1 = first.length;
1385 int length2 = second.length;
1386 Object [] result = new Object [length1 + length2];
1387 System.arraycopy(first, 0, result, 0, length1);
1388 System.arraycopy(second, 0, result, length1, length2);
1389 return result;
1390 }
1391
1392 public static ParameterInfo[] getCombinedParameterInfoArray(ParameterInfo[]
1393 first, ParameterInfo[] second) {
1394 if (first == null) {
1395 return second;
1396 }
1397 if (second == null) {
1398 return first;
1399 }
1400 int length1 = first.length;
1401 int length2 = second.length;
1402 ParameterInfo[] result = new ParameterInfo[length1 + length2];
1403 System.arraycopy(first, 0, result, 0, length1);
1404 System.arraycopy(second, 0, result, length1, length2);
1405 return result;
1406 }
1407
1408
1421 public static void updateColumnDetailsProperties_old(ColumnDetails gainer,
1422 ColumnDetails looser) throws
1423 DException {
1424 gainer.setTableDetails(looser.getTable()); gainer.setObject(looser.getObject()); gainer.setColumnName(looser.getType() == TypeConstants.REFERENCE ?
1427 looser.getColumnName() :
1428 (String [])new String [] {looser.getColumn()});
1429 gainer.setUnderLyingReference(looser.getUnderLyingReference());
1430 if (gainer.getAliasName() == null) {
1431 gainer.setAliasName(looser.getAliasName());
1432 }
1433 int type = looser.getType();
1434 gainer.setType(type);
1435 gainer.setTableAliasArray(looser.getTableAliasArray());
1436 gainer.negativeFlag = looser.negativeFlag;
1437 gainer.setDatatype(looser.getDatatype());
1438 }
1439
1440 public static void updateColumnDetailsProperties(ColumnDetails gainer,
1441 ColumnDetails looser) throws DException {
1442
1443 gainer.setTableDetails(looser.getTable()); gainer.setObject(looser.getObject());
1446
1449 gainer.setColumnName(looser.getType() == TypeConstants.REFERENCE ?
1450 looser.getColumnName() :
1451 (String [])new String [] {looser.getColumn()});
1452
1453 if (gainer.getAliasName() == null) {
1454 gainer.setAliasName(looser.getAliasName());
1455 }
1456
1457
1458 if ( (gainer.getType() == CONSTANT && gainer.getUnderLyingReference()) == false) {
1459 gainer.setUnderLyingReference(looser.getUnderLyingReference());
1460 int type = looser.getType();
1461 gainer.setType(type);
1462 }
1463 gainer.setTableAliasArray(looser.getTableAliasArray());
1464 gainer.negativeFlag = looser.negativeFlag;
1465 gainer.setDatatype(looser.getDatatype());
1466
1467 }
1468
1469 static GregorianCalendar cal = new GregorianCalendar ();
1470 static GregorianCalendar cal2 = new GregorianCalendar ();
1471 public static FieldBase minus(int type1, int type2, Object result1,
1472 Object result2) throws DException {
1473 switch (type1) {
1474 case BYTE:
1475 case TINYINT:
1476 byte operand0 = ( (Byte ) result1).byteValue();
1477 switch (type2) {
1478 case BYTE:
1479 case TINYINT:
1480 byte s11 = ( (Byte ) result2).byteValue();
1481 return new FieldLiteral(new Short ( (short) (operand0 - s11)), SHORT);
1482 case SHORT:
1483 case SMALLINT:
1484 short s1 = ( (Short ) result2).shortValue();
1485 return new FieldLiteral(new Integer (operand0 - s1), INTEGER);
1486 case INTEGER:
1487 case INT:
1488 int s2 = ( (Integer ) result2).intValue();
1489 return new FieldLiteral(new Long ( (operand0 - s2)), LONG);
1490 case LONG:
1491 case BIGINT:
1492 long s3 = ( (Long ) result2).longValue();
1493 return new FieldLiteral(new BigDecimal("" + (operand0 - s3)),
1494 BIGDECIMAL);
1495 case BIGDECIMAL:
1496 case DEC:
1497 case DECIMAL:
1498 case NUMERIC:
1499 BigDecimal bbb = new BigDecimal(operand0 + "");
1500 return new FieldLiteral(bbb.subtract( (BigDecimal) result2),
1501 BIGDECIMAL);
1502 case REAL:
1503 float s4 = ( (Float ) result2).floatValue();
1504 return new FieldLiteral(new Double (operand0 - s4), FLOAT);
1505 case DOUBLE:
1506 case FLOAT:
1507 case DOUBLEPRECISION:
1508 double s5 = ( (Double ) result2).doubleValue();
1509 return new FieldLiteral(new Double (operand0 - s5), DOUBLE);
1510 case CHARACTER:
1511 case VARCHAR:
1512 case CHAR:
1513 case CHARACTERVARYING:
1514 throw new DException("DSE87", new Object [] {"CHARACTER", "BYTE"});
1515 case DATE:
1516 case TIME:
1517 case TIMESTAMP:
1518 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
1519 "BYTE"});
1520 }
1521 break;
1522 case SHORT:
1523 case SMALLINT:
1524 short operand = ( (Short ) result1).shortValue();
1525 switch (type2) {
1526 case BYTE:
1527 case TINYINT:
1528 byte s11 = ( (Byte ) result2).byteValue();
1529 return new FieldLiteral(new Integer (operand - s11), INTEGER);
1530 case SHORT:
1531 case SMALLINT:
1532 short s1 = ( (Short ) result2).shortValue();
1533 return new FieldLiteral(new Integer ( (int) (operand - s1)), INTEGER);
1534 case INTEGER:
1535 case INT:
1536 int s2 = ( (Integer ) result2).intValue();
1537 return new FieldLiteral(new Long ( (long) (operand - s2)), LONG);
1538 case LONG:
1539 case BIGINT:
1540 long s3 = ( (Long ) result2).longValue();
1541 return new FieldLiteral(new BigDecimal( (double) (operand - s3)),
1542 BIGDECIMAL);
1543 case BIGDECIMAL:
1544 case DEC:
1545 case DECIMAL:
1546 case NUMERIC:
1547 double b1 = ( (Short ) result1).doubleValue();
1548 return new FieldLiteral( (new BigDecimal(b1)).subtract( (BigDecimal)
1549 result2), BIGDECIMAL);
1550 case REAL:
1551 float s4 = ( (Float ) result2).floatValue();
1552 return new FieldLiteral(new Double ( (double) (operand - s4)),
1553 DOUBLE);
1554 case DOUBLE:
1555 case FLOAT:
1556 case DOUBLEPRECISION:
1557 double s5 = ( (Double ) result2).doubleValue();
1558 return new FieldLiteral(new BigDecimal(operand - s5), BIGDECIMAL);
1559 case CHARACTER:
1560 case VARCHAR:
1561 case CHAR:
1562 case CHARACTERVARYING:
1563 throw new DException("DSE87", new Object [] {"CHARACTER", "SHORT"});
1564 case DATE:
1565 case TIME:
1566 case TIMESTAMP:
1567 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
1568 "SORT"});
1569 }
1570 break;
1571 case INTEGER:
1572 case INT:
1573 int operand1 = ( (Integer ) result1).intValue();
1574 switch (type2) {
1575 case BYTE:
1576 case TINYINT:
1577 byte s11 = ( (Byte ) result2).byteValue();
1578 return new FieldLiteral(new Long ( (operand1 - s11)), LONG);
1579 case SHORT:
1580 case SMALLINT:
1581 short s6 = ( (Short ) result2).shortValue();
1582 return new FieldLiteral(new Long ( (long) operand1 - s6), LONG);
1583 case INTEGER:
1584 case INT:
1585 int operand2 = ( (Integer ) result2).intValue();
1586 return new FieldLiteral(new Long ( (long) operand1 - operand2), LONG);
1587 case LONG:
1588 case BIGINT:
1589 long operand3 = ( (Long ) result2).longValue();
1590 return new FieldLiteral(new Double ( (double) operand1 - operand3),
1591 DOUBLE);
1592 case BIGDECIMAL:
1593 case DEC:
1594 case DECIMAL:
1595 case NUMERIC:
1596 double b2 = ( (Integer ) result1).doubleValue();
1597 return new FieldLiteral( (new BigDecimal(b2)).subtract( (BigDecimal)
1598 result2), BIGDECIMAL);
1599 case REAL:
1600 float operand4 = ( (Float ) result2).floatValue();
1601 return new FieldLiteral(new Double (operand1 - operand4), DOUBLE);
1602 case DOUBLE:
1603 case FLOAT:
1604 case DOUBLEPRECISION:
1605 double operand5 = ( (Double ) result2).doubleValue();
1606 return new FieldLiteral(new BigDecimal(operand1 - operand5),
1607 BIGDECIMAL);
1608 case CHARACTER:
1609 case VARCHAR:
1610 case CHAR:
1611 case CHARACTERVARYING:
1612 throw new DException("DSE87", new Object [] {"CHARACTER", "INT"});
1613 case DATE:
1614 case TIME:
1615 case TIMESTAMP:
1616 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
1617 "INT"});
1618 }
1619 break;
1620 case LONG:
1621 case BIGINT:
1622 long operand11 = ( (Long ) result1).longValue();
1623 switch (type2) {
1624 case BYTE:
1625 case TINYINT:
1626 byte s11 = ( (Byte ) result2).byteValue();
1627 return new FieldLiteral(new BigDecimal("" + (operand11 - s11)),
1628 BIGDECIMAL);
1629 case SHORT:
1630 case SMALLINT:
1631 short s7 = ( (Short ) result2).shortValue();
1632 return new FieldLiteral(new Double ( (double) operand11 - s7),
1633 DOUBLE);
1634 case INTEGER:
1635 case INT:
1636 int operand6 = ( (Integer ) result2).intValue();
1637 return new FieldLiteral(new Double ( (double) operand11 - operand6),
1638 DOUBLE);
1639 case LONG:
1640 case BIGINT:
1641 long operand7 = ( (Long ) result2).longValue();
1642 return new FieldLiteral(new Double ( (double) operand11 - operand7),
1643 DOUBLE);
1644 case BIGDECIMAL:
1645 case DEC:
1646 case DECIMAL:
1647 case NUMERIC:
1648 double b3 = ( (Long ) result1).doubleValue();
1649 return new FieldLiteral( (new BigDecimal(b3)).subtract( (BigDecimal)
1650 result2), BIGDECIMAL);
1651 case REAL:
1652 float operand8 = ( (Float ) result2).floatValue();
1653 return new FieldLiteral(new Double ( (double) operand11 - operand8),
1654 DOUBLE);
1655 case DOUBLE:
1656 case FLOAT:
1657 case DOUBLEPRECISION:
1658 double operand9 = ( (Double ) result2).doubleValue();
1659 return new FieldLiteral(new BigDecimal(operand11 - operand9),
1660 BIGDECIMAL);
1661 case CHARACTER:
1662 case VARCHAR:
1663 case CHAR:
1664 case CHARACTERVARYING:
1665 throw new DException("DSE87", new Object [] {"CHARACTER", "LONG"});
1666 case DATE:
1667 case TIME:
1668 case TIMESTAMP:
1669 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
1670 "LONG"});
1671 }
1672 break;
1673 case BIGDECIMAL:
1674 case DEC:
1675 case DECIMAL:
1676 case NUMERIC:
1677 switch (type2) {
1678 case SHORT:
1679 case SMALLINT:
1680 double d1 = ( (Number ) result2).doubleValue();
1681 return new FieldLiteral( ( (BigDecimal) result1).subtract(new
1682 BigDecimal(d1)), BIGDECIMAL);
1683 case BYTE:
1684 case TINYINT:
1685 double s11 = ( (Byte ) result2).doubleValue();
1686 return new FieldLiteral( ( (BigDecimal) result1).subtract(new
1687 BigDecimal(s11)), BIGDECIMAL);
1688 case INTEGER:
1689 case INT:
1690 double s12 = ( (Integer ) result2).doubleValue();
1691 return new FieldLiteral( ( (BigDecimal) result1).subtract(new
1692 BigDecimal(s12)), BIGDECIMAL);
1693 case DOUBLE:
1694 case FLOAT:
1695 case DOUBLEPRECISION:
1696 double s13 = ( (Double ) result2).doubleValue();
1697 return new FieldLiteral( ( (BigDecimal) result1).subtract(new
1698 BigDecimal(s13)), BIGDECIMAL);
1699 case REAL:
1700 double s14 = ( (Float ) result2).doubleValue();
1701 return new FieldLiteral( ( (BigDecimal) result1).subtract(new
1702 BigDecimal(s14)), BIGDECIMAL);
1703 case LONG:
1704 case BIGINT:
1705 double s15 = ( (Long ) result2).doubleValue();
1706 return new FieldLiteral( ( (BigDecimal) result1).subtract(new
1707 BigDecimal(s15)), BIGDECIMAL);
1708 case BIGDECIMAL:
1709 case DEC:
1710 case DECIMAL:
1711 case NUMERIC:
1712 return new FieldLiteral( ( (BigDecimal) result1).subtract( (
1713 BigDecimal) result2), BIGDECIMAL);
1714 case CHARACTER:
1715 case VARCHAR:
1716 case CHAR:
1717 case CHARACTERVARYING:
1718 throw new DException("DSE87", new Object [] {"CHARACTER",
1719 "BIGDECIMAL"});
1720 case DATE:
1721 case TIME:
1722 case TIMESTAMP:
1723 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
1724 "BIGDECIMAL"});
1725 }
1726 break;
1727 case REAL:
1728 float operand111 = ( (Float ) result1).floatValue();
1729 switch (type2) {
1730 case SHORT:
1731 case SMALLINT:
1732 short s8 = ( (Short ) result2).shortValue();
1733 return new FieldLiteral(new Double ( (double) operand111 - s8),
1734 DOUBLE);
1735 case BYTE:
1736 case TINYINT:
1737 byte s11 = ( (Byte ) result2).byteValue();
1738 return new FieldLiteral(new Double ( (double) operand111 - s11),
1739 DOUBLE);
1740 case INTEGER:
1741 case INT:
1742 int operand12 = ( (Integer ) result2).intValue();
1743 return new FieldLiteral(new Double (operand111 - operand12), DOUBLE);
1744 case LONG:
1745 case BIGINT:
1746 long operand13 = ( (Long ) result2).longValue();
1747 return new FieldLiteral(new Double (operand111 - operand13), DOUBLE);
1748 case BIGDECIMAL:
1749 case DEC:
1750 case DECIMAL:
1751 case NUMERIC:
1752 double b4 = ( (Float ) result1).doubleValue();
1753 return new FieldLiteral( (new BigDecimal(b4)).subtract( (BigDecimal)
1754 result2), BIGDECIMAL);
1755 case REAL:
1756 float operand14 = ( (Float ) result2).floatValue();
1757 return new FieldLiteral(new Double (operand111 - operand14), DOUBLE);
1758 case DOUBLE:
1759 case FLOAT:
1760 case DOUBLEPRECISION:
1761 double operand15 = ( (Double ) result2).doubleValue();
1762 return new FieldLiteral(new BigDecimal(operand111 - operand15),
1763 BIGDECIMAL);
1764 case CHARACTER:
1765 case VARCHAR:
1766 case CHAR:
1767 case CHARACTERVARYING:
1768 throw new DException("DSE87", new Object [] {"CHARACTER", "FLOAT"});
1769 case DATE:
1770 case TIME:
1771 case TIMESTAMP:
1772 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
1773 "FLOAT"});
1774 }
1775 break;
1776 case DOUBLE:
1777 case FLOAT:
1778 case DOUBLEPRECISION:
1779 double operand1111 = ( (Double ) result1).doubleValue();
1780 switch (type2) {
1781 case SHORT:
1782 case SMALLINT:
1783 short s9 = ( (Short ) result2).shortValue();
1784 return new FieldLiteral(new BigDecimal(operand1111 - s9),
1785 BIGDECIMAL);
1786 case BYTE:
1787 case TINYINT:
1788 byte s11 = ( (Byte ) result2).byteValue();
1789 return new FieldLiteral(new BigDecimal(operand1111 - s11),
1790 BIGDECIMAL);
1791 case INTEGER:
1792 case INT:
1793 int operand16 = ( (Integer ) result2).intValue();
1794 return new FieldLiteral(new BigDecimal(operand1111 - operand16),
1795 BIGDECIMAL);
1796 case LONG:
1797 case BIGINT:
1798 long operand17 = ( (Long ) result2).longValue();
1799 return new FieldLiteral(new BigDecimal(operand1111 - operand17),
1800 BIGDECIMAL);
1801 case BIGDECIMAL:
1802 case DEC:
1803 case DECIMAL:
1804 case NUMERIC:
1805 double b5 = ( (Double ) result1).doubleValue();
1806 return new FieldLiteral( (new BigDecimal(b5)).subtract( (BigDecimal)
1807 result2), BIGDECIMAL);
1808 case REAL:
1809 float operand18 = ( (Float ) result2).floatValue();
1810 return new FieldLiteral(new BigDecimal(operand1111 - operand18),
1811 BIGDECIMAL);
1812 case DOUBLE:
1813 case FLOAT:
1814 case DOUBLEPRECISION:
1815 double operand19 = ( (Double ) result2).doubleValue();
1816 return new FieldLiteral(new BigDecimal(operand1111 - operand19),
1817 BIGDECIMAL);
1818 case CHARACTER:
1819 case VARCHAR:
1820 case CHAR:
1821 case CHARACTERVARYING:
1822 throw new DException("DSE87", new Object [] {"CHARACTER", "DOUBLE"});
1823 case DATE:
1824 case TIME:
1825 case TIMESTAMP:
1826 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
1827 "DOUBLE"});
1828 }
1829 break;
1830 case CHARACTER:
1831 case VARCHAR:
1832 case CHAR:
1833 case CHARACTERVARYING:
1834 switch (type2) {
1835 case SHORT:
1836 case SMALLINT:
1837 throw new DException("DSE87", new Object [] {"CHARACTER", "SHORT"});
1838 case INTEGER:
1839 case INT:
1840 throw new DException("DSE87", new Object [] {"CHARACTER", "INT"});
1841 case LONG:
1842 case BIGINT:
1843 throw new DException("DSE87", new Object [] {"CHARACTER", "LONG"});
1844 case BIGDECIMAL:
1845 case DEC:
1846 case DECIMAL:
1847 case NUMERIC:
1848 throw new DException("DSE87", new Object [] {"CHARACTER",
1849 "BIGDECIMAL"});
1850 case REAL:
1851 throw new DException("DSE87", new Object [] {"CHARACTER", "FLOAT"});
1852 case DOUBLE:
1853 case FLOAT:
1854 case DOUBLEPRECISION:
1855 throw new DException("DSE87", new Object [] {"CHARACTER", "DOUBLE"});
1856 case DATE:
1857 case TIME:
1858 case TIMESTAMP:
1859 throw new DException("DSE87", new Object [] {"CHARACTER",
1860 "DATE/TIME/TIMESTAMP"});
1861 }
1862 break;
1863 case TIMESTAMP:
1864 switch (type2) {
1865 case SHORT:
1866 case SMALLINT:
1867 case INTEGER:
1868 case INT:
1869 case LONG:
1870 case BIGINT:
1871 case BIGDECIMAL:
1872 case DEC:
1873 case DECIMAL:
1874 case NUMERIC:
1875 case TINYINT:
1876 case REAL:
1877 case DOUBLE:
1878 case FLOAT:
1879 case BYTE:
1880 case DOUBLEPRECISION:
1881 long timeInMls = ( (Timestamp ) result1).getTime();
1882 return calculateTimeStampSum(timeInMls, (result2));
1883
1884 case TIMESTAMP:
1885 long timeInMls2 = ( (Timestamp ) result1).getTime();
1886 long timeInMls3 = ( (Timestamp ) result2).getTime();
1887 return calculateTimestampAndTimeStamp(timeInMls2, timeInMls3);
1888 case DATE:
1889 case TIME:
1890
1891 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
1892 "DATE/TIME/TIMESTAMP"});
1893 }
1894
1895 case DATE:
1896 switch (type2) {
1897 case SHORT:
1898 case SMALLINT:
1899 case INTEGER:
1900 case INT:
1901 case LONG:
1902 case BIGINT:
1903 case BIGDECIMAL:
1904 case DEC:
1905 case DECIMAL:
1906 case NUMERIC:
1907 case REAL:
1908 case DOUBLE:
1909 case TINYINT:
1910 case FLOAT:
1911 case BYTE:
1912 case DOUBLEPRECISION:
1913 long timeInMls = ( (Date ) result1).getTime();
1914 return calculateDateSum(timeInMls, result2);
1915 case DATE:
1916 long timeInMls2 = ( (Date ) result1).getTime();
1917 long timeInMls3 = ( (Date ) result2).getTime();
1918
1919 return calculateDateAndDate(timeInMls2, timeInMls3);
1920 case TIME:
1921 case TIMESTAMP:
1922 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
1923 "DATE/TIME/TIMESTAMP"});
1924 }
1925 }
1926
1927 throw new DException("DSE35",
1928 new Object [] {StaticClass.getDataTypeName(type1),
1929 StaticClass.getDataTypeName(type2)});
1930 }
1931
1932 public static int getDataTypeForArithmetic(int dataType1, int dataType2) throws
1933 DException {
1934 if (dataType1 == -1 || dataType2 == -1) { return -1;
1936 }
1937
1938 switch (dataType1) {
1939 case BYTE:
1940 case TINYINT:
1941 switch (dataType2) {
1942 case BYTE:
1943 case TINYINT:
1944 return SHORT;
1945 case SHORT:
1946 case SMALLINT:
1947 return INTEGER;
1948 case INTEGER:
1949 case INT:
1950 return LONG;
1951 case LONG:
1952 case BIGINT:
1953 return BIGDECIMAL;
1954 case BIGDECIMAL:
1955 case DEC:
1956 case DECIMAL:
1957 case NUMERIC:
1958 return BIGDECIMAL;
1959 case REAL:
1960 return FLOAT;
1961 case DOUBLE:
1962 case FLOAT:
1963 case DOUBLEPRECISION:
1964 return DOUBLE;
1965 case CHARACTER:
1966 case VARCHAR:
1967 case CHAR:
1968 case CHARACTERVARYING:
1969 throw new DException("DSE87", new Object [] {"CHARACTER", "BYTE"});
1970
1971 case DATE:
1972 return DATE;
1973 case TIMESTAMP:
1974 return TIMESTAMP;
1975 case TIME:
1976 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
1977 "BYTE"});
1978 }
1979 case SHORT:
1980 case SMALLINT:
1981 switch (dataType2) {
1982 case BYTE:
1983 case TINYINT:
1984 return INTEGER;
1985 case SHORT:
1986 case SMALLINT:
1987 return INTEGER;
1988 case INTEGER:
1989 case INT:
1990 return LONG;
1991 case LONG:
1992 case BIGINT:
1993 return BIGDECIMAL;
1994 case BIGDECIMAL:
1995 case DEC:
1996 case DECIMAL:
1997 case NUMERIC:
1998 return BIGDECIMAL;
1999 case REAL:
2000 return DOUBLE;
2001 case DOUBLE:
2002 case FLOAT:
2003 case DOUBLEPRECISION:
2004 return BIGDECIMAL;
2005 case CHARACTER:
2006 case VARCHAR:
2007 case CHAR:
2008 case CHARACTERVARYING:
2009 throw new DException("DSE87", new Object [] {"CHARACTER", "SHORT"});
2010
2011 case DATE:
2012 return DATE;
2013 case TIMESTAMP:
2014 return TIMESTAMP;
2015 case TIME:
2016 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
2017 "SORT"});
2018 }
2019 case INTEGER:
2020 case INT:
2021 switch (dataType2) {
2022 case BYTE:
2023 case TINYINT:
2024 return LONG;
2025 case SHORT:
2026 case SMALLINT:
2027 return LONG;
2028 case INTEGER:
2029 case INT:
2030 return LONG;
2031 case LONG:
2032 case BIGINT:
2033 return DOUBLE;
2034 case BIGDECIMAL:
2035 case DEC:
2036 case DECIMAL:
2037 case NUMERIC:
2038 return BIGDECIMAL;
2039 case REAL:
2040 return DOUBLE;
2041 case DOUBLE:
2042 case FLOAT:
2043 case DOUBLEPRECISION:
2044 return BIGDECIMAL;
2045 case CHARACTER:
2046 case VARCHAR:
2047 case CHAR:
2048 case CHARACTERVARYING:
2049 throw new DException("DSE87", new Object [] {"CHARACTER", "INT"});
2050
2051 case DATE:
2052 return DATE;
2053 case TIMESTAMP:
2054 return TIMESTAMP;
2055 case TIME:
2056 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
2057 "INT"});
2058 }
2059 case LONG:
2060 case BIGINT:
2061 switch (dataType2) {
2062 case BYTE:
2063 case TINYINT:
2064 return BIGDECIMAL;
2065 case SHORT:
2066 case SMALLINT:
2067 return DOUBLE;
2068 case INTEGER:
2069 case INT:
2070 return DOUBLE;
2071 case LONG:
2072 case BIGINT:
2073 return DOUBLE;
2074 case BIGDECIMAL:
2075 case DEC:
2076 case DECIMAL:
2077 case NUMERIC:
2078 return BIGDECIMAL;
2079 case REAL:
2080 return DOUBLE;
2081 case DOUBLE:
2082 case FLOAT:
2083 case DOUBLEPRECISION:
2084 return BIGDECIMAL;
2085 case CHARACTER:
2086 case VARCHAR:
2087 case CHAR:
2088 case CHARACTERVARYING:
2089 throw new DException("DSE87", new Object [] {"CHARACTER", "LONG"});
2090
2091 case DATE:
2092 return DATE;
2093 case TIMESTAMP:
2094 return TIMESTAMP;
2095 case TIME:
2096 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
2097 "LONG"});
2098 }
2099 case BIGDECIMAL:
2100 case DEC:
2101 case DECIMAL:
2102 case NUMERIC:
2103 switch (dataType2) {
2104 case SHORT:
2105 case SMALLINT:
2106 return BIGDECIMAL;
2107 case BYTE:
2108 case TINYINT:
2109 return BIGDECIMAL;
2110 case INTEGER:
2111 case INT:
2112 return BIGDECIMAL;
2113 case DOUBLE:
2114 case FLOAT:
2115 case DOUBLEPRECISION:
2116 return BIGDECIMAL;
2117 case REAL:
2118 return BIGDECIMAL;
2119 case LONG:
2120 case BIGINT:
2121 return BIGDECIMAL;
2122 case BIGDECIMAL:
2123 case DEC:
2124 case DECIMAL:
2125 case NUMERIC:
2126 return BIGDECIMAL;
2127 case CHARACTER:
2128 case VARCHAR:
2129 case CHAR:
2130 case CHARACTERVARYING:
2131 throw new DException("DSE87", new Object [] {"CHARACTER",
2132 "BIGDECIMAL"});
2133
2134 case DATE:
2135 return DATE;
2136 case TIMESTAMP:
2137 return TIMESTAMP;
2138 case TIME:
2139 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
2140 "BIGDECIMAL"});
2141 }
2142 case REAL:
2143 switch (dataType2) {
2144 case SHORT:
2145 case SMALLINT:
2146 return DOUBLE;
2147 case BYTE:
2148 case TINYINT:
2149 return DOUBLE;
2150 case INTEGER:
2151 case INT:
2152 return DOUBLE;
2153 case LONG:
2154 case BIGINT:
2155 return DOUBLE;
2156 case BIGDECIMAL:
2157 case DEC:
2158 case DECIMAL:
2159 case NUMERIC:
2160 return BIGDECIMAL;
2161 case REAL:
2162 return DOUBLE;
2163 case DOUBLE:
2164 case FLOAT:
2165 case DOUBLEPRECISION:
2166 return BIGDECIMAL;
2167 case CHARACTER:
2168 case VARCHAR:
2169 case CHAR:
2170 case CHARACTERVARYING:
2171 throw new DException("DSE87", new Object [] {"CHARACTER", "FLOAT"});
2172
2173 case DATE:
2174 return DATE;
2175 case TIMESTAMP:
2176 return TIMESTAMP;
2177 case TIME:
2178 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
2179 "FLOAT"});
2180 }
2181 case DOUBLE:
2182 case FLOAT:
2183 case DOUBLEPRECISION:
2184 switch (dataType2) {
2185 case SHORT:
2186 case SMALLINT:
2187 return BIGDECIMAL;
2188 case BYTE:
2189 case TINYINT:
2190 return BIGDECIMAL;
2191 case INTEGER:
2192 case INT:
2193 return BIGDECIMAL;
2194 case LONG:
2195 case BIGINT:
2196 return BIGDECIMAL;
2197 case BIGDECIMAL:
2198 case DEC:
2199 case DECIMAL:
2200 case NUMERIC:
2201 return BIGDECIMAL;
2202 case REAL:
2203 return BIGDECIMAL;
2204 case DOUBLE:
2205 case FLOAT:
2206 case DOUBLEPRECISION:
2207 return BIGDECIMAL;
2208 case CHARACTER:
2209 case VARCHAR:
2210 case CHAR:
2211 case CHARACTERVARYING:
2212 throw new DException("DSE87", new Object [] {"CHARACTER", "DOUBLE"});
2213
2214 case DATE:
2215 return DATE;
2216 case TIMESTAMP:
2217 return TIMESTAMP;
2218 case TIME:
2219 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
2220 "DOUBLE"});
2221 }
2222 case CHARACTER:
2223 case VARCHAR:
2224 case CHAR:
2225 case CHARACTERVARYING:
2226 switch (dataType2) {
2227 case BYTE:
2228 throw new DException("DSE87", new Object [] {"CHARACTER", "BYTE"});
2229 case SHORT:
2230 case SMALLINT:
2231 throw new DException("DSE87", new Object [] {"CHARACTER", "SHORT"});
2232 case INTEGER:
2233 case INT:
2234 throw new DException("DSE87", new Object [] {"CHARACTER", "INT"});
2235 case LONG:
2236 case BIGINT:
2237 throw new DException("DSE87", new Object [] {"CHARACTER", "LONG"});
2238 case BIGDECIMAL:
2239 case DEC:
2240 case DECIMAL:
2241 case NUMERIC:
2242 throw new DException("DSE87", new Object [] {"CHARACTER",
2243 "BIGDECIMAL"});
2244 case REAL:
2245 throw new DException("DSE87", new Object [] {"CHARACTER", "FLOAT"});
2246 case DOUBLE:
2247 case FLOAT:
2248 case DOUBLEPRECISION:
2249 throw new DException("DSE87", new Object [] {"CHARACTER", "DOUBLE"});
2250 case DATE:
2251 case TIME:
2252 case TIMESTAMP:
2253 throw new DException("DSE87", new Object [] {"CHARACTER",
2254 "DATE/TIME/TIMESTAMP"});
2255 case CHARACTER:
2256 case VARCHAR:
2257 case CHAR:
2258 case CHARACTERVARYING:
2259 throw new DException("DSE87", new Object [] {"CHARACTER",
2260 "CHARACTER"});
2261
2262 }
2263
2264 case DATE:
2265 switch (dataType2) {
2266 case BYTE:
2267 case TINYINT:
2268 case SHORT:
2269 case INT:
2270 case INTEGER:
2271 case LONG:
2272 case BIGINT:
2273 case REAL:
2274 case DOUBLE:
2275 case FLOAT:
2276 case DOUBLEPRECISION:
2277 case SMALLINT:
2278 case BIGDECIMAL:
2279 case DEC:
2280 case DECIMAL:
2281 case NUMERIC:
2282 return DATE;
2283 case DATE:
2284 return LONG;
2285 case TIME:
2286 case TIMESTAMP:
2287 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
2288 "DATE/TIME/TIMESTAMP"});
2289
2290 }
2291
2292 case TIMESTAMP:
2293 switch (dataType2) {
2294 case SHORT:
2295 case SMALLINT:
2296 case INTEGER:
2297 case INT:
2298 case LONG:
2299 case BIGINT:
2300 case BIGDECIMAL:
2301 case DEC:
2302 case DECIMAL:
2303 case BYTE:
2304 case NUMERIC:
2305 case REAL:
2306 case DOUBLE:
2307 case FLOAT:
2308 case DOUBLEPRECISION:
2309 case TINYINT:
2310 return TIMESTAMP;
2311 case TIMESTAMP:
2312 return LONG;
2313 case DATE:
2314 case TIME:
2315
2316 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
2317 "DATE/TIME/TIMESTAMP"});
2318
2319 }
2320
2321
2322 case TIME:
2323 switch (dataType2) {
2324 case SHORT:
2325 case SMALLINT:
2326 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
2327 "SHORT"});
2328 case INTEGER:
2329 case INT:
2330 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
2331 "INT"});
2332 case LONG:
2333 case BIGINT:
2334 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
2335 "LONG"});
2336 case BIGDECIMAL:
2337 case DEC:
2338 case DECIMAL:
2339 case NUMERIC:
2340 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
2341 "BIGDECIMAL"});
2342 case REAL:
2343 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
2344 "FLOAT"});
2345 case DOUBLE:
2346 case FLOAT:
2347 case DOUBLEPRECISION:
2348 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
2349 "DOUBLE"});
2350 case DATE:
2351 case TIME:
2352 case TIMESTAMP:
2353 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
2354 "DATE/TIME/TIMESTAMP"});
2355
2356 }
2357
2358 }
2359
2360 throw new DException("DSE35",
2361 new Object [] {StaticClass.getDataTypeName(dataType1),
2362 StaticClass.getDataTypeName(dataType2)});
2363
2364 }
2365
2366 public static boolean isCharacterType(int dataType) {
2367 return dataType == CHAR || dataType == CHARACTER || dataType == CHARVARYING ||
2368 dataType == VARCHAR;
2369 }
2370
2371 public static ColumnDetails[] getCombinedCDArray(ColumnDetails[] first,
2372 ColumnDetails[] second) {
2373 if (first == null) {
2374 return second;
2375 }
2376 if (second == null) {
2377 return first;
2378 }
2379 int length1 = first.length;
2380 int length2 = second.length;
2381 ColumnDetails[] result = new ColumnDetails[length1 + length2];
2382 System.arraycopy(first, 0, result, 0, length1);
2383 System.arraycopy(second, 0, result, length1, length2);
2384 return result;
2385 }
2386
2387 public static FieldBase convertToAppropriateType(FieldBase field,
2388 int datatype, int size, Collator collator) throws DException {
2389 int fieldType = field.getDatatype();
2390 if (fieldType == Datatypes.DEFAULT_DATATYPE) {
2391 return field;
2392 }
2393
2394 if (field.isNull()) {
2395 FieldBase convertedField = FieldUtility.getField(datatype, null, collator);
2396 convertedField.setBufferRange(FieldUtility.NULLBUFFERRANGE);
2397 return convertedField;
2398 }
2399 if (fieldType == -1) {
2400 try {
2401 field.setDatatype( -1);
2402 }
2403 catch (Exception ex) {
2404 throw new RuntimeException (ex.getMessage());
2405 }
2406 fieldType = field.getDatatype();
2407 }
2408 FieldBase convertedField;
2409 switch (datatype) {
2410 case Datatype.BIGDECIMAL:
2411 case Datatype.DEC:
2412 case Datatype.DECIMAL:
2413 case Datatype.NUMERIC:
2414 switch (fieldType) {
2415 case Datatype.BOOLEAN:
2416 convertedField = new FieldBigDecimal(
2417 new BufferRange(Boolean.TRUE.equals(field.getObject()) ?
2418 "1.0".getBytes() : "0.0".getBytes()),
2419 datatype);
2420 return convertedField;
2421 case Datatype.BIGDECIMAL:
2422 case Datatype.DEC:
2423 case Datatype.DECIMAL:
2424 case Datatype.NUMERIC:
2425 BigDecimal bd = (BigDecimal) field.getObject();
2426 convertedField = new FieldBigDecimal(field.getBufferRange() == null ?
2427 new
2428 BufferRange(CCzufDpowfsufs.
2429 getBytes(bd)) : field.getBufferRange(), datatype);
2430 return convertedField;
2431 case Datatype.LONG:
2432 case Datatype.BIGINT:
2433 case Datatype.SHORT:
2434 case Datatype.SMALLINT:
2435 case Datatype.DOUBLE:
2436 case Datatype.DOUBLEPRECISION:
2437 case Datatype.FLOAT:
2438 case Datatype.REAL:
2439 case Datatype.TINYINT:
2440 case Datatype.BYTE:
2441 case Datatype.INT:
2442 case Datatype.INTEGER:
2443 bd = new BigDecimal(field.getObject().toString());
2444 convertedField = new FieldBigDecimal(
2445 new BufferRange(CCzufDpowfsufs.getBytes(bd)),
2446 datatype);
2447 return convertedField;
2448 case Datatype.CHAR:
2449 case Datatype.CHARACTER:
2450 case Datatype.CHARACTERVARYING:
2451 case Datatype.CHARVARYING:
2452 case Datatype.VARCHAR:
2453 default:
2454 try {
2455 bd = new BigDecimal(field.getObject().toString());
2456 convertedField = new FieldBigDecimal(
2457 new BufferRange(CCzufDpowfsufs.getBytes(bd)),
2458 datatype);
2459 return convertedField;
2460 }
2461 catch (RuntimeException ex) {
2462 throw new DException("DSE773", new Object [] {field.getObject(),
2463 StaticClass.getDataTypeName(datatype)});
2464 }
2465
2466 }
2467 case Datatype.BIGINT:
2468 case Datatype.LONG:
2469 switch (fieldType) {
2470 case Datatype.BIGINT:
2471 case Datatype.LONG:
2472 convertedField = new FieldLong(field.getBufferRange() == null ?
2473 new
2474 BufferRange(CCzufDpowfsufs.
2475 getBytes( (Long ) field.getObject())) : field.getBufferRange(),
2476 datatype);
2477 return convertedField;
2478 case Datatype.BIGDECIMAL:
2479 case Datatype.DEC:
2480 case Datatype.DECIMAL:
2481 case Datatype.NUMERIC:
2482 TypeValidityHandler.checkLongWithBigDecimal(field);
2483 convertedField = new FieldLong(
2484 new BufferRange(CCzufDpowfsufs.getBytes( ( (BigDecimal) field.
2485 getObject()).longValue())),
2486 datatype);
2487 return convertedField;
2488 case Datatype.BOOLEAN:
2489 convertedField = new FieldLong(
2490 new BufferRange(CCzufDpowfsufs.getBytes(Boolean.TRUE.equals(
2491 field.getObject()) ? 1 : 0)),
2492 datatype);
2493 return convertedField;
2494 case Datatype.DOUBLE:
2495 case Datatype.DOUBLEPRECISION:
2496 case Datatype.FLOAT:
2497 TypeValidityHandler.checkLongWithDouble(field);
2498 convertedField = new FieldLong(
2499 new BufferRange(CCzufDpowfsufs.getBytes( ( (Number ) field.
2500 getObject()).longValue())),
2501 datatype);
2502 return convertedField;
2503 case Datatype.REAL:
2504 TypeValidityHandler.checkLongWithFloat(field);
2505 convertedField = new FieldLong(
2506 new BufferRange(CCzufDpowfsufs.getBytes( ( (Number ) field.
2507 getObject()).longValue())),
2508 datatype);
2509 return convertedField;
2510 case Datatype.INT:
2511 case Datatype.INTEGER:
2512 case Datatype.SHORT:
2513 case Datatype.SMALLINT:
2514 case Datatype.TINYINT:
2515 case Datatype.BYTE:
2516 convertedField = new FieldLong(
2517 new BufferRange(CCzufDpowfsufs.getBytes( ( (Number ) field.
2518 getObject()).longValue())),
2519 datatype);
2520 return convertedField;
2521 default:
2522 try {
2523 convertedField = new FieldLong(
2524 new BufferRange(CCzufDpowfsufs.getBytes(new Long (field.
2525 getObject().toString()))),
2526 datatype);
2527 return convertedField;
2528 }
2529 catch (RuntimeException re) {
2530 throw new DException("DSE773", new Object [] {field.getObject(),
2531 StaticClass.getDataTypeName(datatype)});
2532 }
2533
2534 }
2535 case Datatype.BOOLEAN:
2536 switch (fieldType) {
2537 case Datatype.BOOLEAN:
2538 convertedField = new FieldBoolean(field.getBufferRange() == null ?
2539 new
2540 BufferRange(CCzufDpowfsufs.
2541 getBytes( (Boolean ) field.getObject())) : field.getBufferRange(),
2542 datatype);
2543 return convertedField;
2544 default:
2545 try {
2546 convertedField = new FieldBoolean(
2547 new BufferRange(CCzufDpowfsufs.getBytes(new Boolean (field.
2548 getObject().toString()))),
2549 datatype);
2550 return convertedField;
2551 }
2552 catch (RuntimeException re) {
2553 throw new DException("DSE773", new Object [] {field.getObject(),
2554 StaticClass.getDataTypeName(datatype)});
2555 }
2556
2557 }
2558 case Datatype.TINYINT:
2559 case Datatype.BYTE:
2560 switch (fieldType) {
2561 case Datatype.BYTE:
2562 case Datatype.TINYINT:
2563 convertedField = new FieldByte(field.getBufferRange() == null ?
2564 new
2565 BufferRange(CCzufDpowfsufs.
2566 getBytes( (Byte ) field.getObject())) : field.getBufferRange(),
2567 datatype);
2568 return convertedField;
2569 case Datatype.BOOLEAN:
2570 convertedField = new FieldByte(
2571 new BufferRange(Boolean.TRUE.equals(field.getObject()) ?
2572 new byte[] {1}
2573 : new byte[] {0}),
2574 datatype);
2575 return convertedField;
2576 case Datatype.INT:
2577 case Datatype.INTEGER:
2578 case Datatype.LONG:
2579 case Datatype.BIGINT:
2580 case Datatype.SHORT:
2581 case Datatype.SMALLINT:
2582 TypeValidityHandler.checkByteWithNonDecimal(field);
2583 convertedField = new FieldByte(
2584 new BufferRange(new byte[] { ( (Number ) field.getObject()).
2585 byteValue()}), datatype);
2586 return convertedField;
2587 case Datatype.DOUBLE:
2588 case Datatype.DOUBLEPRECISION:
2589 case Datatype.FLOAT:
2590 TypeValidityHandler.checkByteWithDouble(field);
2591 convertedField = new FieldByte(
2592 new BufferRange(new byte[] { ( (Number ) field.getObject()).
2593 byteValue()}), datatype);
2594 return convertedField;
2595 case Datatype.REAL:
2596 TypeValidityHandler.checkByteWithFloat(field);
2597 convertedField = new FieldByte(
2598 new BufferRange(new byte[] { ( (Number ) field.getObject()).
2599 byteValue()}), datatype);
2600 return convertedField;
2601 default:
2602 try {
2603 convertedField = new FieldByte(
2604 new BufferRange(CCzufDpowfsufs.getBytes(new Byte (field.
2605 getObject().toString()))),
2606 datatype);
2607 return convertedField;
2608 }
2609 catch (RuntimeException re) {
2610 throw new DException("DSE773", new Object [] {field.getObject(),
2611 StaticClass.getDataTypeName(datatype)});
2612 }
2613
2614 }
2615 case Datatype.BINARY:
2616 case Datatype.VARBINARY:
2617 switch (fieldType) {
2618 case Datatype.BINARY:
2619 case Datatype.VARBINARY:
2620 try {
2621 if (field.getBufferRange().getLength() > size) {
2622 throw new SizeMisMatchException("DSE773",
2623 new Object [] {field.getObject(),
2624 StaticClass.getDataTypeName(
2625 datatype)});
2626 }
2627 }
2628 catch (NullPointerException ex) {
2629 throw ex;
2630 }
2631
2632 byte[] bytes1 = (byte[]) field.getObject();
2633 if (datatype == Datatype.BINARY) {
2634 byte[] tmp1 = new byte[size];
2635 Arrays.fill(tmp1, (byte) 0);
2636 System.arraycopy(bytes1, 0, tmp1, (size - bytes1.length),
2637 bytes1.length);
2638 bytes1 = tmp1;
2639 }
2640 convertedField = new FieldBinary(new BufferRange(bytes1), datatype);
2641 return convertedField;
2642 }
2643 case Datatype.CHAR:
2644 case Datatype.CHARACTER:
2645 case Datatype.CHARACTERVARYING:
2646 case Datatype.CHARVARYING:
2647 case Datatype.VARCHAR:
2648 switch (fieldType) {
2649 default:
2650 String ss = field.getObject().toString();
2651 if (ss.length() > size) {
2652 ; throw new SizeMisMatchException("DSE773",
2654 new Object [] {field.getObject(),
2655 StaticClass.getDataTypeName(
2656 datatype)});
2657 }
2658 convertedField = new FieldString(
2659 new BufferRange(CCzufDpowfsufs.getBytes(ss,
2660 datatype == Datatype.CHAR || datatype == Datatype.CHARACTER ?
2661 size : -1, collator != null)),
2662 datatype, collator);
2663 return convertedField;
2664 }
2665
2666 case Datatype.BIT:
2667 case Datatype.BITVARYING:
2668 switch (fieldType) {
2669 case Datatype.BOOLEAN:
2670 String s = field.getObject().toString().trim();
2671 s = (s.equalsIgnoreCase("0") || s.equalsIgnoreCase("false")) ? "0" :
2672 "1";
2673 if (s.length() > size) {
2674 throw new SizeMisMatchException("DSE773",
2675 new Object [] {field.getObject(),
2676 StaticClass.getDataTypeName(
2677 datatype)});
2678 }
2679 convertedField = new FieldString(new BufferRange(CCzufDpowfsufs.
2680 getBytes(s, datatype == Datatype.BIT ? size : -1, false)),
2681 datatype, collator);
2682 return convertedField;
2683 default:
2684 try {
2685 String ss = field.getObject().toString().trim();
2686 ss = (ss.equalsIgnoreCase("0") || ss.equalsIgnoreCase("false")) ?
2687 "0" : "1";
2688 if (ss.length() > size) {
2689 ; throw new SizeMisMatchException("DSE773",
2691 new Object [] {field.getObject(),
2692 StaticClass.getDataTypeName(
2693 datatype)});
2694 }
2695 convertedField = new FieldString(new BufferRange(CCzufDpowfsufs.
2696 getBytes(ss, datatype == Datatype.BIT ? size : -1, false)),
2697 datatype, collator);
2698 return convertedField;
2699 }
2700 catch (RuntimeException re) {
2701 throw new DException("DSE773", new Object [] {field.getObject(),
2702 StaticClass.getDataTypeName(datatype)});
2703 }
2704
2705 }
2706
2707 case Datatype.DOUBLE:
2708 case Datatype.DOUBLEPRECISION:
2709 case Datatype.FLOAT:
2710 switch (fieldType) {
2711 case Datatype.DOUBLE:
2712 case Datatype.DOUBLEPRECISION:
2713 case Datatype.FLOAT:
2714 convertedField = new FieldDouble(field.getBufferRange() == null ?
2715 new
2716 BufferRange(CCzufDpowfsufs.
2717 getBytes( (Double ) field.getObject())) : field.getBufferRange(),
2718 datatype);
2719 return convertedField;
2720 case Datatype.BIGDECIMAL:
2721 TypeValidityHandler.checkDoubleWithBigDecimal(field);
2722 convertedField = new FieldDouble(
2723 new BufferRange(CCzufDpowfsufs.getBytes( ( (BigDecimal) field.
2724 getObject()).doubleValue())),
2725 datatype);
2726 return convertedField;
2727 case Datatype.BOOLEAN:
2728 convertedField = new FieldDouble(
2729 new BufferRange(CCzufDpowfsufs.getBytes(Boolean.TRUE.equals(
2730 field.getObject()) ? 1d : 0d)),
2731 datatype);
2732 return convertedField;
2733 case Datatype.INT:
2734 case Datatype.INTEGER:
2735 case Datatype.SHORT:
2736 case Datatype.SMALLINT:
2737 case Datatype.BIGINT:
2738 case Datatype.LONG:
2739 case Datatype.TINYINT:
2740 case Datatype.BYTE:
2741 convertedField = new FieldDouble(
2742 new BufferRange(CCzufDpowfsufs.getBytes( ( (Number ) field.
2743 getObject()).doubleValue())),
2744 Datatype.DOUBLE);
2745 return convertedField;
2746 case Datatype.REAL:
2747 TypeValidityHandler.checkDoubleWithFloat(field);
2748 convertedField = new FieldDouble(
2749 new BufferRange(CCzufDpowfsufs.getBytes( ( (Number ) field.
2750 getObject()).doubleValue())),
2751 Datatype.DOUBLE);
2752 return convertedField;
2753 default:
2754 try {
2755 convertedField = new FieldDouble(
2756 new BufferRange(CCzufDpowfsufs.getBytes(new Double (field.
2757 getObject().toString()))),
2758 datatype);
2759 return convertedField;
2760 }
2761 catch (RuntimeException re) {
2762 throw new DException("DSE773", new Object [] {field.getObject(),
2763 StaticClass.getDataTypeName(datatype)});
2764 }
2765
2766 }
2767
2768 case Datatype.INT:
2769 case Datatype.INTEGER:
2770 switch (fieldType) {
2771 case Datatype.INT:
2772 case Datatype.INTEGER:
2773 convertedField = new FieldInteger(field.getBufferRange() == null ?
2774 new
2775 BufferRange(CCzufDpowfsufs.
2776 getBytes( (Integer ) field.getObject())) : field.getBufferRange(),
2777 datatype);
2778 return convertedField;
2779 case Datatype.BIGDECIMAL:
2780 case Datatype.DEC:
2781 case Datatype.DECIMAL:
2782 case Datatype.NUMERIC:
2783 TypeValidityHandler.checkIntegerWithBigDecimal(field);
2784 convertedField = new FieldInteger(
2785 new BufferRange(CCzufDpowfsufs.getBytes( ( (BigDecimal) field.
2786 getObject()).intValue())),
2787 datatype);
2788 return convertedField;
2789 case Datatype.BOOLEAN:
2790 convertedField = new FieldInteger(
2791 new BufferRange(CCzufDpowfsufs.getBytes(Boolean.TRUE.equals(
2792 field.getObject()) ? 1 : 0)),
2793 datatype);
2794 return convertedField;
2795 case Datatype.BIGINT:
2796 case Datatype.LONG:
2797 TypeValidityHandler.checkIntegerWithNonDecimal(field);
2798 convertedField = new FieldInteger(
2799 new BufferRange(CCzufDpowfsufs.getBytes( ( (Number ) field.
2800 getObject()).intValue())),
2801 datatype);
2802 return convertedField;
2803 case Datatype.DOUBLE:
2804 case Datatype.DOUBLEPRECISION:
2805 case Datatype.FLOAT:
2806 TypeValidityHandler.checkIntegerWithDouble(field);
2807 convertedField = new FieldInteger(
2808 new BufferRange(CCzufDpowfsufs.getBytes( ( (Number ) field.
2809 getObject()).intValue())),
2810 datatype);
2811 return convertedField;
2812 case Datatype.REAL:
2813 TypeValidityHandler.checkIntegerWithFloat(field);
2814 convertedField = new FieldInteger(
2815 new BufferRange(CCzufDpowfsufs.getBytes( ( (Number ) field.
2816 getObject()).intValue())),
2817 datatype);
2818 return convertedField;
2819 case Datatype.SHORT:
2820 case Datatype.SMALLINT:
2821 case Datatype.TINYINT:
2822 case Datatype.BYTE:
2823 convertedField = new FieldInteger(
2824 new BufferRange(CCzufDpowfsufs.getBytes( ( (Number ) field.
2825 getObject()).intValue())),
2826 datatype);
2827 return convertedField;
2828 default:
2829 try {
2830 convertedField = new FieldInteger(
2831 new BufferRange(CCzufDpowfsufs.getBytes(new Integer (field.
2832 getObject().toString()))),
2833 datatype);
2834 return convertedField;
2835 }
2836 catch (RuntimeException re) {
2837 throw new DException("DSE773", new Object [] {field.getObject(),
2838 StaticClass.getDataTypeName(datatype)});
2839 }
2840
2841 }
2842
2843 case Datatype.REAL:
2844 switch (fieldType) {
2845 case Datatype.REAL:
2846 convertedField = new FieldReal(field.getBufferRange() == null ?
2847 new
2848 BufferRange(CCzufDpowfsufs.
2849 getBytes( (Float ) field.getObject())) : field.getBufferRange(),
2850 datatype);
2851 return convertedField;
2852 case Datatype.BIGDECIMAL:
2853 case Datatype.DEC:
2854 case Datatype.DECIMAL:
2855 case Datatype.NUMERIC:
2856 TypeValidityHandler.checkFloatWithBigDecimal(field);
2857 convertedField = new FieldReal(
2858 new BufferRange(CCzufDpowfsufs.getBytes( ( (BigDecimal) field.
2859 getObject()).floatValue())),
2860 datatype);
2861 return convertedField;
2862 case Datatype.BOOLEAN:
2863 convertedField = new FieldReal(
2864 new BufferRange(CCzufDpowfsufs.getBytes(Boolean.TRUE.equals(
2865 field.getObject()) ? 1.0f : 0.0f)),
2866 datatype);
2867 return convertedField;
2868 case Datatype.SHORT:
2869 case Datatype.SMALLINT:
2870 case Datatype.BIGINT:
2871 case Datatype.LONG:
2872 case Datatype.INT:
2873 case Datatype.INTEGER:
2874 case Datatype.DOUBLE:
2875 case Datatype.DOUBLEPRECISION:
2876 case Datatype.TINYINT:
2877 case Datatype.BYTE:
2878 convertedField = new FieldReal(
2879 new BufferRange(CCzufDpowfsufs.getBytes( ( (Number ) field.
2880 getObject()).floatValue())),
2881 datatype);
2882 return convertedField;
2883 case Datatype.FLOAT:
2884 TypeValidityHandler.checkFloatWithDouble(field);
2885 convertedField = new FieldReal(
2886 new BufferRange(CCzufDpowfsufs.getBytes( ( (Number ) field.
2887 getObject()).floatValue())),
2888 datatype);
2889 return convertedField;
2890 default:
2891 try {
2892 convertedField = new FieldReal(
2893 new BufferRange(CCzufDpowfsufs.getBytes(new Float (field.
2894 getObject().toString()))),
2895 datatype);
2896 return convertedField;
2897 }
2898 catch (RuntimeException e) {
2899 throw new DException("DSE773", new Object [] {field.getObject(),
2900 StaticClass.getDataTypeName(datatype)});
2901 }
2902
2903 }
2904
2905 case Datatype.SHORT:
2906 case Datatype.SMALLINT:
2907
2908 switch (fieldType) {
2909 case Datatype.BYTE:
2910 case Datatype.TINYINT:
2911 convertedField = new FieldShort(new BufferRange(CCzufDpowfsufs.
2912 getBytes( ( (Number ) field.getObject()).shortValue())),
2913 datatype);
2914 return convertedField;
2915 case Datatype.SHORT:
2916 case Datatype.SMALLINT:
2917 convertedField = new FieldShort(field.getBufferRange() == null ?
2918 new
2919 BufferRange(CCzufDpowfsufs.
2920 getBytes( (Short ) field.getObject())) : field.getBufferRange(),
2921 datatype);
2922 return convertedField;
2923 case Datatype.BIGDECIMAL:
2924 TypeValidityHandler.checkShortWithBigDecimal(field);
2925 convertedField = new FieldShort(
2926 new BufferRange(CCzufDpowfsufs.getBytes( ( (BigDecimal) field.
2927 getObject()).shortValue())),
2928 datatype);
2929 return convertedField;
2930 case Datatype.BOOLEAN:
2931 convertedField = new FieldShort(
2932 new BufferRange(CCzufDpowfsufs.getBytes(Boolean.TRUE.equals(
2933 field.getObject()) ? new Short ("1") : new Short ("0"))),
2934 datatype);
2935 return convertedField;
2936 case Datatype.BIGINT:
2937 case Datatype.LONG:
2938 case Datatype.INT:
2939 case Datatype.INTEGER:
2940 TypeValidityHandler.checkShortWithNonDecimal(field);
2941 convertedField = new FieldShort(
2942 new BufferRange(CCzufDpowfsufs.getBytes( ( (Number ) field.
2943 getObject()).shortValue())),
2944 datatype);
2945 return convertedField;
2946 case Datatype.DOUBLE:
2947 case Datatype.DOUBLEPRECISION:
2948 case Datatype.FLOAT:
2949 TypeValidityHandler.checkShortWithDouble(field);
2950 convertedField = new FieldShort(
2951 new BufferRange(CCzufDpowfsufs.getBytes( ( (Number ) field.
2952 getObject()).shortValue())),
2953 datatype);
2954 return convertedField;
2955 case Datatype.REAL:
2956 TypeValidityHandler.checkShortWithFloat(field);
2957 convertedField = new FieldShort(
2958 new BufferRange(CCzufDpowfsufs.getBytes( ( (Number ) field.
2959 getObject()).shortValue())),
2960 datatype);
2961 return convertedField;
2962 default:
2963 try {
2964 convertedField = new FieldShort(
2965 new BufferRange(CCzufDpowfsufs.getBytes(new Short (field.
2966 getObject().toString()))),
2967 datatype);
2968 return convertedField;
2969 }
2970 catch (RuntimeException e) {
2971 throw new DException("DSE773", new Object [] {field.getObject(),
2972 StaticClass.getDataTypeName(datatype)});
2973 }
2974
2975 }
2976
2977 case Datatype.DATE:
2978 switch (fieldType) {
2979 case Datatype.DATE:
2980 convertedField = new FieldDate(field.getBufferRange() == null ?
2981 new
2982 BufferRange(CCzufDpowfsufs.
2983 getBytes( (Date ) field.getObject())) : field.getBufferRange(),
2984 datatype);
2985 return convertedField;
2986 case Datatype.TIMESTAMP:
2987 convertedField = new FieldDate(
2988 new BufferRange(CCzufDpowfsufs.getBytes(TypeValidityHandler.
2989 getDBDate( (Timestamp ) field.getObject()))),
2990 datatype);
2991 return convertedField;
2992 case Datatype.TIME:
2993 throw new DException("DSE5547", new Object [] {"Time", "Date"});
2994 case Datatype.CHAR:
2995 case Datatype.CHARACTER:
2996 case Datatype.CHARACTERVARYING:
2997 case Datatype.CHARVARYING:
2998 case Datatype.VARCHAR:
2999 convertedField = new FieldDate(
3000 new BufferRange(CCzufDpowfsufs.getBytes(TypeValidityHandler.
3001 getDBDateFromDateTimestamp( (String ) field.getObject()))),
3002 datatype);
3003 return convertedField;
3004 default:
3005 throw new DException("DSE773", new Object [] {field.getObject(),
3006 StaticClass.getDataTypeName(datatype)});
3007 }
3008
3009 case Datatype.TIME:
3010 switch (fieldType) {
3011 case Datatype.TIME:
3012 convertedField = new FieldTime(field.getBufferRange() == null ?
3013 new
3014 BufferRange(CCzufDpowfsufs.
3015 getBytes( (Time) field.getObject())) : field.getBufferRange(),
3016 datatype);
3017 return convertedField;
3018 case Datatype.TIMESTAMP:
3019 convertedField = new FieldTime(
3020 new BufferRange(CCzufDpowfsufs.getBytes(TypeValidityHandler.
3021 getTime( (Timestamp ) field.getObject()))),
3022 datatype);
3023 return convertedField;
3024 case Datatype.DATE:
3025 throw new DException("DSE5547", new Object [] {"Date", "Time"});
3026 case Datatype.CHAR:
3027 case Datatype.CHARACTER:
3028 case Datatype.CHARACTERVARYING:
3029 case Datatype.CHARVARYING:
3030 case Datatype.VARCHAR:
3031 convertedField = new FieldTime(
3032 new BufferRange(CCzufDpowfsufs.getBytes(TypeValidityHandler.
3033 getTimeFromTimeTimeStamp( (String ) field.getObject()))),
3034 datatype);
3035 return convertedField;
3036 default:
3037 throw new DException("DSE773", new Object [] {field.getObject(),
3038 StaticClass.getDataTypeName(datatype)});
3039 }
3040
3041 case Datatype.TIMESTAMP:
3042 switch (fieldType) {
3043 case Datatype.TIMESTAMP:
3044 convertedField = new FieldTimeStamp(field.getBufferRange() == null ?
3045 new
3046 BufferRange(CCzufDpowfsufs.
3047 getBytes( (Timestamp ) field.getObject())) :
3048 field.getBufferRange(),
3049 datatype);
3050 return convertedField;
3051 case Datatype.TIME:
3052 throw new DException("DSE5547", new Object [] {"Time", "Timestamp"});
3053 case Datatype.DATE:
3054 convertedField = new FieldTimeStamp(
3055 new BufferRange(CCzufDpowfsufs.getBytes(new Timestamp ( ( (Date )
3056 field.getObject()).getTime()))),
3057 datatype);
3058 return convertedField;
3059 case Datatype.CHAR:
3060 case Datatype.CHARACTER:
3061 case Datatype.CHARACTERVARYING:
3062 case Datatype.CHARVARYING:
3063 case Datatype.VARCHAR:
3064 convertedField = new FieldTimeStamp(
3065 new BufferRange(CCzufDpowfsufs.getBytes(TypeValidityHandler.
3066 getTimeStampFromTimestampDate( (String ) field.getObject()))),
3067 datatype);
3068 return convertedField;
3069 default:
3070 throw new DException("DSE773", new Object [] {field.getObject(),
3071 StaticClass.getDataTypeName(datatype)});
3072 }
3073
3074 case Datatype.ARRAY:
3075 case Datatype.MODULE:
3076 case Datatype.RECORD:
3077 case Datatype.RECORDSET:
3078 case Datatype.REF:
3079 case Datatype.STRUCT:
3080 case Datatype.SUM:
3081 case Datatype.TIME_WITH_TIMEZONE:
3082 case Datatype.TIMESTAMP_WITH_TIMEZONE:
3083 throw new DException("DSE1133", new Object [] {new Integer (datatype)});
3084 default:
3085 throw new DException("DSE1021", new Object [] {new Integer (datatype)});
3086 }
3087 }
3088
3089 public static String getFormattedString(String s, char c) {
3090 if (s.indexOf(c) == -1) {
3091 return s;
3092 }
3093 StringBuffer strBuff = new StringBuffer ();
3094 char[] to = s.toCharArray();
3095 for (int i = 0; i < to.length; i++) {
3096 strBuff.append(to[i]);
3097 if (to[i] == c) {
3098 strBuff.append(to[i]);
3099 }
3100 }
3101 return strBuff.toString();
3102 }
3103
3104 public static ColumnDetails getColumnDetails(String columnName) throws
3105 DException {
3106 ColumnDetails cd = new ColumnDetails();
3107 cd.setColumnName(new String [] {columnName});
3108 cd.setDatatype(Datatypes.LONG);
3109 cd.setSize(Datatypes.LONGSIZE);
3110 return cd;
3111 }
3112
3113 public static booleanvalueexpression getCondition(String condition,
3114 int datatype) throws DException {
3115 booleanvalueexpression termCondition = ConditionParser.parseCondition(
3116 condition);
3117 ColumnDetails[] cd = termCondition.getColumnDetails();
3118 cd[0].setDatatype(datatype);
3119 return termCondition;
3120 }
3121
3122 public static _Iterator getIndexedFilteredIterator(_Iterator iterator,
3123 booleanvalueexpression bve) throws DException {
3124 _Reference[] ref = bve.getReferences(null);
3125 _VariableValues vv = new VariableValues(ref, null);
3126 vv.setIterator(iterator);
3127 ConditionVariableValue cvv = new ConditionVariableValue(vv, bve);
3128 _VariableValues vv1 = new VariableValues(ref, null);
3129 ConditionVariableValue cvv1 = new ConditionVariableValue(vv1, bve);
3130 return new IndexedFilterIterator(iterator, cvv,
3131 new ConditionVariableValue[] {cvv1});
3132 }
3133
3134 public static void getChildTableDetails(ArrayList list,
3135 ColumnDetails reference) throws
3136 DException {
3137 int type = reference.getType();
3138 if (type == TypeConstants.SCALARFUNCTION ||
3139 type == TypeConstants.CASEEXPRESSION ||
3140 type == TypeConstants.FUNCTIONAL) {
3141 ColumnDetails childColumnDetails[] = reference.getChildColumnDetails();
3142 for (int k = 0; k < childColumnDetails.length; k++) {
3143 TableDetails childTable = childColumnDetails[k].getTable();
3144 getChildTableDetails(list, childColumnDetails[k]);
3145 }
3146 }
3147 else {
3148 list.add(reference);
3149 }
3150 }
3151
3152
3153
3154 public static TableDetails[] getAllTableDetails(booleanvalueexpression joinCondition) throws DException {
3155 ArrayList list = new ArrayList(5);
3156 ColumnDetails[] cd = joinCondition.getColumnDetails();
3157 for (int i = 0; i < cd.length; i++) {
3158 int type = cd[i].getType();
3159 if (type == TypeConstants.SCALARFUNCTION || type == TypeConstants.CASEEXPRESSION || type == TypeConstants.FUNCTIONAL) {
3160 ArrayList columns = new ArrayList();
3161 GeneralPurposeStaticClass.getChildTableDetails(columns, cd[i]);
3162 ColumnDetails[] childcolumnDetails = (ColumnDetails[]) columns.toArray(new ColumnDetails[0]);
3163 for (int j = 0; j < childcolumnDetails.length; j++) {
3164 TableDetails td = childcolumnDetails[j].getTableDetails();
3165 if (td != null && !list.contains(td)) {
3166 list.add(td);
3167 }
3168 }
3169 } else {
3170 TableDetails td = cd[i].getTableDetails();
3171
3172 if (td != null && !list.contains(td)) {
3173 list.add(td);
3174 }
3175 }
3176 }
3177 return (TableDetails[]) list.toArray(new TableDetails[list.size()]);
3178 }
3179
3180
3186 public static _Reference[] getAllReferences(_Reference[] references) throws
3187 DException {
3188 if (references == null) {
3189 return null;
3190 }
3191 ArrayList aList = new ArrayList(5);
3192 for (int i = 0; i < references.length; i++) {
3193 if (references[i] instanceof subquery) {
3194 getAllReferencesForSubQuery(aList,
3195 ( (subquery) references[i]).
3196 _queryexpression0.
3197 getReferences(null));
3198 }
3199 else {
3200 aList.add(references[i]);
3201 }
3202 }
3203 return aList.isEmpty() ? null :
3204 (_Reference[]) aList.toArray(new _Reference[0]);
3205 }
3206
3207 private static void getAllReferencesForSubQuery(ArrayList aList,
3208 _Reference[] references) throws
3209 DException {
3210 if (references == null) {
3211 return;
3212 }
3213 for (int i = 0; i < references.length; i++) {
3214 if (references[i] instanceof subquery) {
3215 getAllReferencesForSubQuery(aList,
3216 ( (subquery) references[i]).
3217 _queryexpression0.
3218 getReferences(null));
3219 }
3220 else {
3221 aList.add(references[i]);
3222 }
3223 }
3224 }
3225
3226 public static boolean isSameTableDetails(TableDetails td1, TableDetails td2) throws
3227 DException {
3228 if (td1 == null || td2 == null) {
3229 return td1 == null && td2 == null;
3230 }
3231 String ta1 = td1.getAliasName();
3232 String ta2 = td2.getAliasName();
3233 if (ta1 != null) {
3234 if (ta2 != null && ta2.equalsIgnoreCase(ta1))
3235 return true;
3236 return false;
3237 }
3238 else {
3239 return td1.getQualifiedTableName().equalsIgnoreCase(td2.
3240 getQualifiedTableName());
3241 }
3242 }
3243
3244
3245 public static ArrayList getValuesFrom2DArray(Object [][] mapping,
3246 int indexOf2D) {
3247 ArrayList arr = new ArrayList();
3248 for (int i = 0; i < mapping.length; i++) {
3249 arr.add(mapping[i][indexOf2D]);
3250 }
3251 return arr;
3252 }
3253
3254
3255 public static ArrayList getNonClonedReferences(_Reference[] refs) throws
3256 DException {
3257 ArrayList arr = new ArrayList();
3258 for (int i = 0; i < refs.length; i++) {
3259 if (!refs[i].isCloned())
3260 arr.add(refs[i]);
3261 }
3262 return arr;
3263 }
3264
3265 public static void addRecursively(ColumnDetails[] cd, ArrayList aList) throws
3266 DException {
3267 if (cd == null) {
3268 return;
3269 }
3270 for (int i = 0; i < cd.length; i++) {
3271 int type = cd[i].getType();
3272 if (type == TypeConstants.REFERENCE) {
3273 aList.add(cd[i]);
3274 }
3275 else if (type == TypeConstants.SCALARFUNCTION ||
3276 type == TypeConstants.CASEEXPRESSION ||
3277 type == TypeConstants.FUNCTIONAL || type == USERFUNCTION) {
3278 addRecursively(cd[i].getExistingColumnDetails(), aList);
3279 }
3280 else if (type == TypeConstants.GROUPING) {
3281 throw new DException("DSE3551", null);
3282 }
3283 }
3284 }
3285
3286 private static FieldTimeStampLiteral calculateTimeStampSum(long result1,
3287 Object result2) {
3288 cal.setTimeInMillis(result1);
3289 cal.add(Calendar.DATE, - ( (Number ) result2).intValue());
3290 return new FieldTimeStampLiteral(new Timestamp (cal.getTimeInMillis()));
3291 }
3292
3293 private static FieldDateLiteral calculateDateSum(long result1, Object result2) {
3294 cal.setTimeInMillis(result1);
3295 cal.add(Calendar.DATE, - ( (Number ) result2).intValue());
3296 return new FieldDateLiteral(new DBDate(cal.getTimeInMillis()));
3297 }
3298
3299 private static _VariableValues temporaryVariableValue(_Reference[] tempRef,
3300 _ServerSession serverSession, TableDetails[] tables,
3301 _Iterator underLyingIterator) throws DException {
3302 _VariableValues vv = getVariableValues(tempRef, serverSession);
3303 if (tempRef != null) {
3304 for (int i = 0; i < tempRef.length; i++) {
3305 if (tempRef[i].getReferenceType() == SimpleConstants.SUBQUERY) {
3306 _Iterator iter1 = ( (_Iterator) vv.getColumnValues(tempRef[i]));
3307 _Reference[] ref = GeneralPurposeStaticClass.getAllReferences(new
3308 _Reference[] {tempRef[i]});
3309 ref = GeneralPurposeStaticClass.getUnderLyingReferencesOnly(ref,
3310 tables);
3311 if (ref != null) {
3312 Object [] values = new Object [ref.length];
3313 Arrays.fill(values, underLyingIterator);
3314 iter1.setConditionVariableValue(ref, values, 0);
3315 }
3316 }
3317 }
3318 }
3319 return vv;
3320
3321 }
3322
3323 private static FieldLiteral calculateTimestampAndTimeStamp(long result1,
3324 long result2) {
3325 long time = (result1 - result2) / (1000 * 60 * 60 * 24);
3326 return new FieldLiteral(new Long (time), LONG);
3327 }
3328
3329 private static FieldLiteral calculateDateAndDate(long result1, long result2) {
3330 long time = (result1 - result2) / (1000 * 60 * 60 * 24);
3331 return new FieldLiteral(new Long (time), LONG);
3332 }
3333
3334 public static ColumnDetails[] getJointColumnDetails(ColumnDetails[] cd1,
3335 ColumnDetails[] cd2) throws DException {
3336 if (cd2 == null) {
3337 return cd1;
3338 }
3339 if (cd1 == null) {
3340 return cd2;
3341 }
3342 ColumnDetails[] result = new ColumnDetails[cd1.length + cd2.length];
3343 System.arraycopy(cd1, 0, result, 0, cd1.length);
3344 System.arraycopy(cd2, 0, result, cd1.length, cd2.length);
3345 return result;
3346 }
3347
3348 public static _Iterator getTemporaryIndexIteratorForSubQuery(_Iterator
3349 underLyingIterator, _TablePlan underLyingPLan,
3350 _ServerSession serverSession, _Order order, _Reference[] ref,
3351 _Iterator[] iter) throws DException {
3352 TableDetails[] tables = underLyingPLan.getTableDetails();
3353
3354 _Order tempOrder = GeneralPurposeStaticClass.getJoinOrdered(order, underLyingIterator.getDefaultOrder());
3355 _Reference[] tempRef = tempOrder.getReferences(tables);
3356
3357 _VariableValues vv = GeneralPurposeStaticClass.getVariableValues123(tempRef,
3358 serverSession, ref, iter);
3359 vv.setIterator(underLyingIterator);
3360 if(underLyingPLan.getRowCount(serverSession)<=2000 && (underLyingIterator instanceof SingleTableIterator))
3361 return new MemoryIndexIteratorForSubQuery(underLyingIterator, new ExpressionOrderValues(tempOrder, vv));
3362 CbCUsffWbmvfIboemfs tempHandler = new TempIndexHandler(underLyingIterator);
3363 return serverSession.getIndexedIterator(underLyingIterator,new ExpressionOrderValues(tempOrder, vv), tempHandler); }
3365
3366 public static _VariableValues getVariableValues123(_Reference[]
3367 selectReferences,
3368 _ServerSession serverSession, _Reference[] ref, _Iterator[] iter) throws
3369 DException {
3370 if (ref != null) {
3371 Object [][] subQueryIteratorMapping = new Object [ref.length][2];
3372 for (int i = 0; i < ref.length; i++) {
3373 subQueryIteratorMapping[i][0] = ref[i];
3374 subQueryIteratorMapping[i][1] = iter[i];
3375 }
3376 _Reference[] simpleReferences = getSimpleReferences(selectReferences);
3377 return new SubQueryVariableValues(simpleReferences,
3378 subQueryIteratorMapping, serverSession);
3379 }
3380 else
3381 return new VariableValues(selectReferences, serverSession);
3382 }
3383
3384 public static FieldBase datePlusTerm(int type1, int type2, Object result1,
3385 Object result2) throws DException {
3386 switch (type1) {
3387 case TIMESTAMP:
3388 switch (type2) {
3389 case SHORT:
3390 case SMALLINT:
3391 case INTEGER:
3392 case INT:
3393 case BYTE:
3394 case LONG:
3395 case BIGINT:
3396 case BIGDECIMAL:
3397 case DEC:
3398 case DECIMAL:
3399 case NUMERIC:
3400 case REAL:
3401 case DOUBLE:
3402 case FLOAT:
3403 case DOUBLEPRECISION:
3404 long timeStampInMls = ( (Timestamp ) result1).getTime();
3405
3406 return calculateTimeStampSumFORSUM(timeStampInMls, result2);
3407
3408 case DATE:
3409 case TIME:
3410 case TIMESTAMP:
3411 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
3412 "DATE/TIME/TIMESTAMP"});
3413 }
3414
3415 case DATE:
3416 switch (type2) {
3417 case SHORT:
3418 case SMALLINT:
3419 case INTEGER:
3420 case INT:
3421 case BYTE:
3422 case LONG:
3423 case BIGINT:
3424 case BIGDECIMAL:
3425 case DEC:
3426 case DECIMAL:
3427 case NUMERIC:
3428 case REAL:
3429 case DOUBLE:
3430 case FLOAT:
3431 case DOUBLEPRECISION:
3432
3433 long dateInMls = ( (Date ) result1).getTime();
3434 return calculateDateSumFORSUM(dateInMls, result2);
3435 }
3436 case TIME:
3437 switch (type2) {
3438 case SHORT:
3439 case SMALLINT:
3440 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
3441 "SHORT"});
3442 case INTEGER:
3443 case INT:
3444 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
3445 "INT"});
3446 case LONG:
3447 case BIGINT:
3448 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
3449 "LONG"});
3450 case BIGDECIMAL:
3451 case DEC:
3452 case DECIMAL:
3453 case NUMERIC:
3454 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
3455 "BIGDECIMAL"});
3456 case REAL:
3457 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
3458 "FLOAT"});
3459 case DOUBLE:
3460 case FLOAT:
3461 case DOUBLEPRECISION:
3462 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
3463 "DOUBLE"});
3464 case DATE:
3465 case TIME:
3466 case TIMESTAMP:
3467 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
3468 "DATE/TIME/TIMESTAMP"});
3469 }
3470
3471
3472 }
3473 throw new DException("DSE35",
3474 new Object [] {StaticClass.getDataTypeName(type1),
3475 StaticClass.getDataTypeName(type2)});
3476
3477 }
3478
3479 static GregorianCalendar calendar = new GregorianCalendar ();
3480 private static FieldTimeStampLiteral calculateTimeStampSumFORSUM(long result1,
3481 Object result2) {
3482
3483 calendar.setTimeInMillis(result1);
3484 calendar.add(Calendar.DATE, ( (Number ) result2).intValue());
3485 return new FieldTimeStampLiteral(new Timestamp (calendar.getTimeInMillis()));
3486 }
3487
3488
3489 private static FieldDateLiteral calculateDateSumFORSUM(long result1,
3490 Object result2) {
3491 calendar.setTimeInMillis(result1);
3492 calendar.add(Calendar.DATE, ( (Number ) result2).intValue());
3493 return new FieldDateLiteral(new DBDate(calendar.getTimeInMillis()));
3494 }
3495
3496 public static FieldBase dateMinusTerm(int type1, int type2, Object result1,
3497 Object result2) throws DException {
3498 switch (type1) {
3499 case TIMESTAMP:
3500 switch (type2) {
3501 case SHORT:
3502 case SMALLINT:
3503 case INTEGER:
3504 case INT:
3505 case LONG:
3506 case BIGINT:
3507 case BIGDECIMAL:
3508 case DEC:
3509 case DECIMAL:
3510 case NUMERIC:
3511 case TINYINT:
3512 case REAL:
3513 case DOUBLE:
3514 case FLOAT:
3515 case BYTE:
3516 case DOUBLEPRECISION:
3517 long timeInMls = ( (Timestamp ) result1).getTime();
3518 return calculateTimeStampSum(timeInMls, (result2));
3519
3520 case TIMESTAMP:
3521 long timeInMls2 = ( (Timestamp ) result1).getTime();
3522 long timeInMls3 = ( (Timestamp ) result2).getTime();
3523 return calculateTimestampAndTimeStamp(timeInMls2, timeInMls3);
3524 case DATE:
3525 case TIME:
3526
3527 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
3528 "DATE/TIME/TIMESTAMP"});
3529 }
3530
3531 case DATE:
3532 switch (type2) {
3533 case SHORT:
3534 case SMALLINT:
3535 case INTEGER:
3536 case INT:
3537 case LONG:
3538 case BIGINT:
3539 case BIGDECIMAL:
3540 case DEC:
3541 case DECIMAL:
3542 case NUMERIC:
3543 case REAL:
3544 case DOUBLE:
3545 case TINYINT:
3546 case FLOAT:
3547 case BYTE:
3548 case DOUBLEPRECISION:
3549 long timeInMls = ( (Date ) result1).getTime();
3550 return calculateDateSum(timeInMls, result2);
3551 case DATE:
3552 long timeInMls2 = ( (Date ) result1).getTime();
3553 long timeInMls3 = ( (Date ) result2).getTime();
3554
3555 return calculateDateAndDate(timeInMls2, timeInMls3);
3556 case TIME:
3557 case TIMESTAMP:
3558 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
3559 "DATE/TIME/TIMESTAMP"});
3560 }
3561
3562 case TIME:
3563
3564 switch (type2) {
3565 case SHORT:
3566 case SMALLINT:
3567 throw new DException("DSE87", new Object [] {"TIME", "SHORT"});
3568 case INTEGER:
3569 case INT:
3570 throw new DException("DSE87", new Object [] {"TIME", "INT"});
3571 case LONG:
3572 case BIGINT:
3573 throw new DException("DSE87", new Object [] {"TIME", "LONG"});
3574 case BIGDECIMAL:
3575 case DEC:
3576 case DECIMAL:
3577 case NUMERIC:
3578 case TINYINT:
3579 throw new DException("DSE87", new Object [] {"TIME", "BIGDECIMAL"});
3580 case REAL:
3581 throw new DException("DSE87", new Object [] {"TIME", "FLOAT"});
3582 case DOUBLE:
3583 case FLOAT:
3584 case BYTE:
3585 case DOUBLEPRECISION:
3586 throw new DException("DSE87", new Object [] {"TIME", "DOUBLE"});
3587
3588 case TIMESTAMP:
3589 case DATE:
3590 case TIME:
3591
3592 throw new DException("DSE87", new Object [] {"TIME",
3593 "TIME"});
3594 }
3595
3596 }
3597 throw new DException("DSE35",
3598 new Object [] {StaticClass.getDataTypeName(type1),
3599 StaticClass.getDataTypeName(type2)});
3600 }
3601
3602 public static ColumnDetails[] getJoinOfColumnDetailsAndReferences(
3603 ColumnDetails[] cd,
3604 _Reference[] ref) throws DException {
3605 if (cd == null) {
3606 if (ref != null) {
3607 ColumnDetails[] result = new ColumnDetails[ref.length];
3608 System.arraycopy(cd, 0, result, 0, ref.length);
3609 return result;
3610 }
3611 }
3612 if (cd != null && ref != null) {
3613 ColumnDetails[] result = new ColumnDetails[cd.length + ref.length];
3614 System.arraycopy(cd, 0, result, 0, cd.length);
3615 System.arraycopy(ref, 0, result, cd.length, ref.length);
3616 return result;
3617 }
3618 return cd;
3619 }
3620
3625 public static boolean isfromNumericFamily(int dataType){
3626 return dataType == BYTE || dataType == TINYINT || dataType == SMALLINT || dataType == SHORT
3627 || dataType == INT || dataType == INTEGER || dataType == LONG || dataType == BIGINT
3628 || dataType == REAL || dataType == FLOAT || dataType == DOUBLE || dataType == DOUBLEPRECISION
3629 || dataType == NUMERIC || dataType == DECIMAL || dataType == DEC || dataType == BIGDECIMAL;
3630
3631}
3632
3633
3638
3639 public static void addRecursivelyParameterInfoOfSubquery(ArrayList aList,ParameterInfo pi[], int j) throws
3640 DException {
3641 if (pi == null)
3642 return;
3643 for (int i = 0; i < pi.length; i++) {
3644 if (pi[i].getQuestionMark()) {
3645 if (pi[i].getName() == null) {
3646 pi[i].setName("Expr" + j++);
3647 }
3648 aList.add(pi[i]);
3649 }
3650 else if (pi[i].getSubQuery()) {
3651 addRecursivelyParameterInfoOfSubquery(aList,
3652 pi[i].getParameterInfoArray(), j);
3653 }
3654
3655 }
3656
3657 }
3658
3659
3664
3665 public static int getPrecision(int dataType ) {
3666 switch(dataType){
3667 case INT:
3668 case INTEGER:
3669 return INT_PRECISION;
3670 case LONG:
3671 return LONG_PRECISION;
3672 case DATE:
3673 return DATE_PRECISION;
3674 case TIME:
3675 return TIME_PRECISION;
3676 case TIMESTAMP:
3677 return TIMESTAMP_PRECISION;
3678 case FLOAT:
3679 case DOUBLE:
3680 case DOUBLEPRECISION:
3681 return FLOAT_PRECISION;
3682 case SHORT:
3683 return SHORT_PRECISION;
3684 case BOOLEAN:
3685 return BOOLEAN_PRECISION;
3686 case BYTE:
3687 return BYTE_PRECISION;
3688 case REAL:
3689 return REAL_PRECISION;
3690 case BIGDECIMAL:
3691 return BIGDECIMAL_PRECISION;
3692 default:
3693 return 0;
3694 }
3695 }
3696
3697
3698
3701 public static ColumnDetails[] getAllCoumnDetails(ColumnDetails[] cds) throws
3702 DException {
3703 if (cds == null)
3704 return null;
3705
3706 ArrayList aList = new ArrayList();
3707 for (int i = 0; i < cds.length; i++) {
3708 int type = cds[i].getType();
3709 if (type == TypeConstants.SCALARFUNCTION ||
3710 type == TypeConstants.CASEEXPRESSION ||
3711 type == TypeConstants.FUNCTIONAL || type == USERFUNCTION ||
3712 type == TypeConstants.GROUPING) {
3713 ColumnDetails[] temp = getAllCoumnDetails(cds[i].
3714 getExistingColumnDetails());
3715 if (temp != null)
3716 aList.addAll(Arrays.asList(temp));
3717 }
3718 else
3719 aList.add(cds[i]);
3720
3721 }
3722 return (ColumnDetails[]) aList.toArray(new ColumnDetails[0]);
3723 }
3724
3725}
3726 |
Popular Tags |
Java API By Example, From Geeks To Geeks.