KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > daffodilwoods > daffodildb > server > sql99 > expression > numericvalueexpression > termSsolidus_2030455159factor


1 package com.daffodilwoods.daffodildb.server.sql99.expression.
2     numericvalueexpression;
3
4 import java.math.*;
5
6 import com.daffodilwoods.daffodildb.server.serversystem.*;
7 import com.daffodilwoods.daffodildb.server.sql99.common.*;
8 import com.daffodilwoods.daffodildb.server.sql99.expression.rowvalueexpression.*;
9 import com.daffodilwoods.daffodildb.server.sql99.token.*;
10 import com.daffodilwoods.daffodildb.server.sql99.utils.*;
11 import com.daffodilwoods.daffodildb.utils.field.*;
12 import com.daffodilwoods.database.resource.*;
13 import com.daffodilwoods.database.utility.P;
14
15 public class termSsolidus_2030455159factor
16     extends AbstractTerm
17     implements term, Datatypes, _sortspecificationAndselectSubList {
18   public factor _factor0;
19   public Ssolidus_2030455159 _Ssolidus_20304551591;
20   public term _term2;
21
22   public _Reference[] checkSemantic(_ServerSession parent) throws DException {
23     _Reference[] refs = super.checkSemantic(parent);
24     if (refs == null || refs.length == 0) { // check put by Kaushik on 14/07/2004 for 'invalid column' problem in DDL
25 ByteComparison bc1 = _term2.getByteComparison(parent);
26       ByteComparison bc2 = _factor0.getByteComparison(parent);
27       checkSemantic(parent, bc1, bc2);
28     }
29     setAppropriateDatatypeAndCheck(parent);
30     return refs;
31   }
32
33   int dtType = -1;
34   private void setAppropriateDatatypeAndCheck(Object JavaDoc object) throws DException {
35     ColumnDetails[] cd = _term2.getColumnDetails();
36     ColumnDetails[] Rcd = _factor0.getColumnDetails();
37     int dataType1 = 0;
38     int dataType2 = 0;
39     switch (cd.length) {
40       case 0: // for subquery
41 switch (Rcd.length) {
42           case 0: //for subquery
43 dataType1 = getDataTypeForByte(childs[0].getByteComparison(object));
44             dataType2 = getDataTypeForByte(childs[1].getByteComparison(object));
45             break;
46           default: //Handle Subquery
47 dataType1 = getDataTypeForByte(childs[0].getByteComparison(object));
48             Rcd[0].setDatatype(Datatypes.BIGDECIMAL);
49             dataType2 = Datatypes.BIGDECIMAL;
50         }
51         break;
52       default:
53         switch (Rcd.length) {
54           case 0: //subquery
55 dataType2 = getDataTypeForByte(childs[1].getByteComparison(object));
56             dataType1 = Datatypes.BIGDECIMAL;
57             break;
58           default:
59             if ( (cd[0].getQuestion() && (Rcd[0].getQuestion()))) {
60               cd[0].setDatatype(BIGDECIMAL); //BIGDECIMAL
61 Rcd[0].setDatatype(BIGDECIMAL); //BIGDECIMAL
62 dataType1 = BIGDECIMAL;
63               dataType2 = BIGDECIMAL;
64             }
65             else
66             if (cd[0].getQuestion()) {
67               dataType2 = getDataTypeForByte(childs[1].getByteComparison(object));
68               cd[0].setDatatype(BIGDECIMAL); //BIGDECIMAL
69 dataType1 = BIGDECIMAL;
70             }
71             else
72             if (Rcd[0].getQuestion()) {
73               dataType1 = getDataTypeForByte(childs[0].getByteComparison(object));
74               Rcd[0].setDatatype(BIGDECIMAL); //BIGDECIMAL
75 dataType2 = BIGDECIMAL;
76             }
77             else {
78               dataType1 = getDataTypeForByte(childs[0].getByteComparison(object));
79               dataType2 = getDataTypeForByte(childs[1].getByteComparison(object));
80
81             }
82         }
83     }
84      if (dataType1 == -1 || dataType2 == -1) { // To avoid checking for '?' when called from SemanticChecking
85 dtType = -1;
86        return;
87      }
88
89     switch (dataType1) {
90       case BYTE:
91       case TINYINT:
92         switch (dataType2) {
93           case BYTE:
94           case TINYINT:
95             dtType = DOUBLE;
96             break;
97           case SHORT:
98           case SMALLINT:
99             dtType = DOUBLE;
100             break;
101           case INTEGER:
102           case INT:
103             dtType = DOUBLE;
104             break;
105           case LONG:
106           case BIGINT:
107             dtType = DOUBLE;
108             break;
109           case BIGDECIMAL:
110           case DEC:
111           case DECIMAL:
112           case NUMERIC:
113             dtType = BIGDECIMAL;
114             break;
115           case REAL:
116             dtType = DOUBLE;
117             break;
118           case DOUBLE:
119           case FLOAT:
120           case DOUBLEPRECISION:
121             dtType = DOUBLE;
122             break;
123           case CHARACTER:
124           case VARCHAR:
125           case CHAR:
126           case CHARACTERVARYING:
127             throw new DException("DSE87", new Object JavaDoc[] {"CHARACTER", "BYTE"});
128           case DATE:
129           case TIME:
130           case TIMESTAMP:
131             throw new DException("DSE87", new Object JavaDoc[] {"DATE/TIME/TIMESTAMP",
132                                  "BYTE"});
133         }
134         break;
135       case SHORT:
136       case SMALLINT:
137         switch (dataType2) {
138           case SHORT:
139           case SMALLINT:
140             dtType = DOUBLE;
141             break;
142           case BYTE:
143           case TINYINT:
144             dtType = DOUBLE;
145             break;
146           case INTEGER:
147           case INT:
148             dtType = DOUBLE;
149             break;
150           case LONG:
151           case BIGINT:
152             dtType = DOUBLE;
153             break;
154           case BIGDECIMAL:
155           case DEC:
156           case DECIMAL:
157           case NUMERIC:
158             dtType = BIGDECIMAL;
159             break;
160           case REAL:
161             dtType = DOUBLE;
162             break;
163           case DOUBLE:
164           case FLOAT:
165           case DOUBLEPRECISION:
166             dtType = DOUBLE;
167             break;
168           case CHARACTER:
169           case VARCHAR:
170           case CHAR:
171           case CHARACTERVARYING:
172             throw new DException("DSE87", new Object JavaDoc[] {"CHARACTER", "SHORT"});
173           case DATE:
174           case TIME:
175           case TIMESTAMP:
176             throw new DException("DSE87", new Object JavaDoc[] {"DATE/TIME/TIMESTAMP",
177                                  "SHORT"});
178         }
179         break;
180       case INTEGER:
181       case INT:
182         switch (dataType2) {
183           case SHORT:
184           case SMALLINT:
185             dtType = DOUBLE;
186             break;
187           case BYTE:
188           case TINYINT:
189             dtType = DOUBLE;
190             break;
191           case INTEGER:
192           case INT:
193             dtType = DOUBLE;
194             break;
195           case LONG:
196           case BIGINT:
197             dtType = DOUBLE;
198             break;
199           case BIGDECIMAL:
200           case DEC:
201           case DECIMAL:
202           case NUMERIC:
203             dtType = BIGDECIMAL;
204             break;
205           case REAL:
206             dtType = DOUBLE;
207             break;
208           case DOUBLE:
209           case FLOAT:
210           case DOUBLEPRECISION:
211             dtType = DOUBLE;
212             break;
213           case CHARACTER:
214           case VARCHAR:
215           case CHAR:
216           case CHARACTERVARYING:
217             throw new DException("DSE87", new Object JavaDoc[] {"CHARACTER", "INT"});
218           case DATE:
219           case TIME:
220           case TIMESTAMP:
221             throw new DException("DSE87", new Object JavaDoc[] {"DATE/TIME/TIMESTAMP",
222                                  "INT"});
223         }
224         break;
225       case LONG:
226       case BIGINT:
227         switch (dataType2) {
228           case SHORT:
229           case SMALLINT:
230             dtType = DOUBLE;
231             break;
232           case BYTE:
233           case TINYINT:
234             dtType = DOUBLE;
235             break;
236           case INTEGER:
237           case INT:
238             dtType = DOUBLE;
239             break;
240           case LONG:
241           case BIGINT:
242             dtType = DOUBLE;
243             break;
244           case BIGDECIMAL:
245           case DEC:
246           case DECIMAL:
247           case NUMERIC:
248             dtType = BIGDECIMAL;
249             break;
250           case REAL:
251             dtType = DOUBLE;
252             break;
253           case DOUBLE:
254           case FLOAT:
255           case DOUBLEPRECISION:
256             dtType = DOUBLE;
257             break;
258           case CHARACTER:
259           case VARCHAR:
260           case CHAR:
261           case CHARACTERVARYING:
262             throw new DException("DSE87", new Object JavaDoc[] {"CHARACTER", "LONG"});
263           case DATE:
264           case TIME:
265           case TIMESTAMP:
266             throw new DException("DSE87", new Object JavaDoc[] {"DATE/TIME/TIMESTAMP",
267                                  "LONG"});
268         }
269         break;
270       case BIGDECIMAL:
271       case DEC:
272       case DECIMAL:
273       case NUMERIC:
274         switch (dataType2) {
275           case SHORT:
276           case SMALLINT:
277             dtType = BIGDECIMAL;
278             break;
279           case INTEGER:
280           case INT:
281             dtType = BIGDECIMAL;
282             break;
283           case LONG:
284           case BIGINT:
285             dtType = BIGDECIMAL;
286             break;
287           case BYTE:
288           case TINYINT:
289             dtType = BIGDECIMAL;
290             break;
291           case DOUBLE:
292           case FLOAT:
293           case DOUBLEPRECISION:
294             dtType = BIGDECIMAL;
295             break;
296           case REAL:
297             dtType = BIGDECIMAL;
298             break;
299           case BIGDECIMAL:
300           case DEC:
301           case DECIMAL:
302           case NUMERIC:
303             dtType = BIGDECIMAL;
304             break;
305           case CHARACTER:
306           case VARCHAR:
307           case CHAR:
308           case CHARACTERVARYING:
309             throw new DException("DSE87", new Object JavaDoc[] {"CHARACTER",
310                                  "BIGDECIMAL"});
311           case DATE:
312           case TIME:
313           case TIMESTAMP:
314             throw new DException("DSE87", new Object JavaDoc[] {"DATE/TIME/TIMESTAMP",
315                                  "LONG"});
316         }
317         break;
318       case REAL:
319         switch (dataType2) {
320           case SHORT:
321           case SMALLINT:
322             dtType = DOUBLE;
323             break;
324           case BYTE:
325           case TINYINT:
326             dtType = DOUBLE;
327             break;
328           case INTEGER:
329           case INT:
330             dtType = DOUBLE;
331             break;
332           case LONG:
333           case BIGINT:
334             dtType = DOUBLE;
335             break;
336           case BIGDECIMAL:
337           case DEC:
338           case DECIMAL:
339           case NUMERIC:
340             dtType = BIGDECIMAL;
341             break;
342           case REAL:
343             dtType = DOUBLE;
344             break;
345           case DOUBLE:
346           case FLOAT:
347           case DOUBLEPRECISION:
348             dtType = DOUBLE;
349             break;
350           case CHARACTER:
351           case VARCHAR:
352           case CHAR:
353           case CHARACTERVARYING:
354             throw new DException("DSE87", new Object JavaDoc[] {"CHARACTER", "FLOAT"});
355           case DATE:
356           case TIME:
357           case TIMESTAMP:
358             throw new DException("DSE87", new Object JavaDoc[] {"DATE/TIME/TIMESTAMP",
359                                  "FLOAT"});
360         }
361         break;
362       case DOUBLE:
363       case FLOAT:
364       case DOUBLEPRECISION:
365         switch (dataType2) {
366           case BYTE:
367           case TINYINT:
368             dtType = DOUBLE;
369             break;
370           case SHORT:
371           case SMALLINT:
372             dtType = DOUBLE;
373             break;
374           case INTEGER:
375           case INT:
376             dtType = DOUBLE;
377             break;
378           case LONG:
379           case BIGINT:
380             dtType = DOUBLE;
381             break;
382           case BIGDECIMAL:
383           case DEC:
384           case DECIMAL:
385           case NUMERIC:
386             dtType = BIGDECIMAL;
387             break;
388           case REAL:
389             dtType = DOUBLE;
390             break;
391           case DOUBLE:
392           case FLOAT:
393           case DOUBLEPRECISION:
394             dtType = DOUBLE;
395             break;
396           case CHARACTER:
397           case VARCHAR:
398           case CHAR:
399           case CHARACTERVARYING:
400             throw new DException("DSE87", new Object JavaDoc[] {"CHARACTER", "DOUBLE"});
401           case DATE:
402           case TIME:
403           case TIMESTAMP:
404             throw new DException("DSE87", new Object JavaDoc[] {"DATE/TIME/TIMESTAMP",
405                                  "DOUBLE"});
406         }
407         break;
408       case CHARACTER:
409       case VARCHAR:
410       case CHAR:
411       case CHARACTERVARYING:
412         switch (dataType2) {
413           case SHORT:
414           case SMALLINT:
415             throw new DException("DSE87", new Object JavaDoc[] {"CHARACTER", "SHORT"});
416           case INTEGER:
417           case INT:
418             throw new DException("DSE87", new Object JavaDoc[] {"CHARACTER", "INT"});
419           case LONG:
420           case BIGINT:
421             throw new DException("DSE87", new Object JavaDoc[] {"CHARACTER", "LONG"});
422           case BIGDECIMAL:
423           case DEC:
424           case DECIMAL:
425           case NUMERIC:
426             throw new DException("DSE87", new Object JavaDoc[] {"CHARACTER",
427                                  "BIGDECIMAL"});
428           case REAL:
429             throw new DException("DSE87", new Object JavaDoc[] {"CHARACTER", "FLOAT"});
430           case DOUBLE:
431           case FLOAT:
432           case DOUBLEPRECISION:
433             throw new DException("DSE87", new Object JavaDoc[] {"CHARACTER", "DOUBLE"});
434           case DATE:
435           case TIME:
436           case TIMESTAMP:
437             throw new DException("DSE87", new Object JavaDoc[] {"CHARACTER",
438                                  "DATE/TIME/TIMESTAMP"});
439         }
440         break;
441       case DATE:
442       case TIME:
443       case TIMESTAMP:
444         switch (dataType2) {
445           case SHORT:
446           case SMALLINT:
447             throw new DException("DSE87", new Object JavaDoc[] {"DATE/TIME/TIMESTAMP",
448                                  "SHORT"});
449           case INTEGER:
450           case INT:
451             throw new DException("DSE87", new Object JavaDoc[] {"DATE/TIME/TIMESTAMP",
452                                  "INT"});
453           case LONG:
454           case BIGINT:
455             throw new DException("DSE87", new Object JavaDoc[] {"DATE/TIME/TIMESTAMP",
456                                  "LONG"});
457           case BIGDECIMAL:
458           case DEC:
459           case DECIMAL:
460           case NUMERIC:
461             throw new DException("DSE87", new Object JavaDoc[] {"DATE/TIME/TIMESTAMP",
462                                  "BIGDECIMAL"});
463           case REAL:
464             throw new DException("DSE87", new Object JavaDoc[] {"DATE/TIME/TIMESTAMP",
465                                  "FLOAT"});
466           case DOUBLE:
467           case FLOAT:
468           case DOUBLEPRECISION:
469             throw new DException("DSE87", new Object JavaDoc[] {"DATE/TIME/TIMESTAMP",
470                                  "DOUBLE"});
471           case DATE:
472           case TIME:
473           case TIMESTAMP:
474             throw new DException("DSE87", new Object JavaDoc[] {"DATE/TIME/TIMESTAMP",
475                                  "DATE/TIME/TIMESTAMP"});
476         }
477         break;
478       default:
479         throw new DException("DSE35",
480                              new Object JavaDoc[] {StaticClass.getDataTypeName(
481             dataType1),
482                              StaticClass.getDataTypeName(dataType2)});
483
484     }
485
486   }
487
488   public void checkSemantic(_ServerSession parent, ByteComparison bc1,
489                             ByteComparison bc2) throws DException {
490     super.checkSemantic(parent, bc1, bc2);
491     if (childs[1].getColumnDetails().length > 0) {
492
493       if ( (childs[1].getColumnDetails()[0].getType() == CONSTANT) &&
494           (!childs[1].getColumnDetails()[0].getUnderLyingReference()) &&
495           (!childs[1].getColumnDetails()[0].getQuestion()) &&
496           (!childs[0].checkForSubQuery() &&
497            !childs[0].getColumnDetails()[0].getQuestion())) {
498         VariableValues vv = new VariableValues(parent);
499         Object JavaDoc obj = ( (FieldBase) childs[1].run(vv)).getObject();
500         if (obj instanceof Number JavaDoc)
501           if ( ( (Number JavaDoc) obj).doubleValue() == 0) {
502             throw new DException("DSE334", null);
503           }
504       }
505     }
506   }
507
508   public FieldBase getObject(int type1, int type2, Object JavaDoc result1,
509                              Object JavaDoc result2) throws DException {
510     if (result2 instanceof Number JavaDoc)
511       if ( ( (Number JavaDoc) result2).doubleValue() == 0) {
512         throw new DException("DSE334", null);
513       }
514
515     try {
516       switch (type1) {
517         case BYTE:
518         case TINYINT:
519           byte operand0 = ( (Byte JavaDoc) result1).byteValue();
520           switch (type2) {
521             case BYTE:
522             case TINYINT:
523               double s11 = ( (Byte JavaDoc) result2).doubleValue();
524               return new FieldLiteral(new Double JavaDoc(operand0 / s11), DOUBLE);
525             case SHORT:
526             case SMALLINT:
527               double s1 = ( (Short JavaDoc) result2).doubleValue();
528               return new FieldLiteral(new Double JavaDoc(operand0 / s1), DOUBLE);
529             case INTEGER:
530             case INT:
531               double s2 = ( (Integer JavaDoc) result2).doubleValue();
532               return new FieldLiteral(new Double JavaDoc(operand0 / s2), DOUBLE);
533             case LONG:
534             case BIGINT:
535               double s3 = ( (Long JavaDoc) result2).longValue();
536               return new FieldLiteral(new Double JavaDoc(operand0 / s3), DOUBLE);
537             case BIGDECIMAL:
538             case DEC:
539             case DECIMAL:
540             case NUMERIC:
541               BigDecimal bbb = new BigDecimal(operand0 + "");
542               return new FieldLiteral(bbb.divide( (BigDecimal) result2, 5, 0),
543                                       BIGDECIMAL);
544             case REAL:
545               float s4 = ( (Float JavaDoc) result2).floatValue();
546               return new FieldLiteral(new Double JavaDoc(operand0 / s4), DOUBLE);
547             case DOUBLE:
548             case FLOAT:
549             case DOUBLEPRECISION:
550               double s5 = ( (Double JavaDoc) result2).doubleValue();
551               return new FieldLiteral(new Double JavaDoc(operand0 / s5), DOUBLE);
552             case CHARACTER:
553             case VARCHAR:
554             case CHAR:
555             case CHARACTERVARYING:
556               throw new DException("DSE87", new Object JavaDoc[] {"CHARACTER", "BYTE"});
557             case DATE:
558             case TIME:
559             case TIMESTAMP:
560               throw new DException("DSE87", new Object JavaDoc[] {"DATE/TIME/TIMESTAMP",
561                                    "BYTE"});
562           }
563           break;
564         case SHORT:
565         case SMALLINT:
566           short operand = ( (Short JavaDoc) result1).shortValue();
567           switch (type2) {
568             case SHORT:
569             case SMALLINT:
570               double s1 = ( (Short JavaDoc) result2).doubleValue();
571               return new FieldLiteral(new Double JavaDoc(operand / s1), DOUBLE);
572             case BYTE:
573             case TINYINT:
574               double s11 = ( (Byte JavaDoc) result2).doubleValue();
575               return new FieldLiteral(new Double JavaDoc(operand / s11), DOUBLE);
576             case INTEGER:
577             case INT:
578               double s2 = ( (Integer JavaDoc) result2).doubleValue();
579               return new FieldLiteral(new Double JavaDoc(operand / s2), DOUBLE);
580             case LONG:
581             case BIGINT:
582               long s3 = ( (Long JavaDoc) result2).longValue();
583               return new FieldLiteral(new Double JavaDoc(operand / s3), DOUBLE);
584             case BIGDECIMAL:
585             case DEC:
586             case DECIMAL:
587             case NUMERIC:
588               BigDecimal bbb = new BigDecimal(operand + "");
589               return new FieldLiteral(bbb.divide( (BigDecimal) result2, 5, 0),
590                                       BIGDECIMAL);
591             case REAL:
592               double s4 = ( (Float JavaDoc) result2).doubleValue();
593               return new FieldLiteral(new Double JavaDoc(operand / s4), DOUBLE);
594             case DOUBLE:
595             case FLOAT:
596             case DOUBLEPRECISION:
597               double s5 = ( (Double JavaDoc) result2).doubleValue();
598               return new FieldLiteral(new Double JavaDoc(operand / s5), DOUBLE);
599             case CHARACTER:
600             case VARCHAR:
601             case CHAR:
602             case CHARACTERVARYING:
603               throw new DException("DSE87", new Object JavaDoc[] {"CHARACTER", "SHORT"});
604             case DATE:
605             case TIME:
606             case TIMESTAMP:
607               throw new DException("DSE87", new Object JavaDoc[] {"DATE/TIME/TIMESTAMP",
608                                    "SHORT"});
609           }
610           break;
611         case INTEGER:
612         case INT:
613           int operand1 = ( (Integer JavaDoc) result1).intValue();
614           switch (type2) {
615             case SHORT:
616             case SMALLINT:
617               double s6 = ( (Short JavaDoc) result2).doubleValue();
618               return new FieldLiteral(new Double JavaDoc(operand1 / s6), DOUBLE);
619             case BYTE:
620             case TINYINT:
621               double s11 = ( (Byte JavaDoc) result2).doubleValue();
622               return new FieldLiteral(new Double JavaDoc( (operand1 / s11)), DOUBLE);
623             case INTEGER:
624             case INT:
625               double operand2 = ( (Integer JavaDoc) result2).doubleValue();
626               return new FieldLiteral(new Double JavaDoc(operand1 / operand2), DOUBLE);
627             case LONG:
628             case BIGINT:
629               long operand3 = ( (Long JavaDoc) result2).longValue();
630               return new FieldLiteral(new Double JavaDoc(operand1 / operand3), DOUBLE);
631             case BIGDECIMAL:
632             case DEC:
633             case DECIMAL:
634             case NUMERIC:
635               BigDecimal bbb1 = new BigDecimal(operand1 + "");
636               return new FieldLiteral(bbb1.divide( (BigDecimal) result2, 5, 0),
637                                       BIGDECIMAL);
638             case REAL:
639               double operand4 = ( (Double JavaDoc) result2).doubleValue();
640               return new FieldLiteral(new Double JavaDoc(operand1 / operand4), DOUBLE);
641             case DOUBLE:
642             case FLOAT:
643             case DOUBLEPRECISION:
644               double operand5 = ( (Double JavaDoc) result2).doubleValue();
645               return new FieldLiteral(new Double JavaDoc(operand1 / operand5), DOUBLE);
646             case CHARACTER:
647             case VARCHAR:
648             case CHAR:
649             case CHARACTERVARYING:
650               throw new DException("DSE87", new Object JavaDoc[] {"CHARACTER", "INT"});
651             case DATE:
652             case TIME:
653             case TIMESTAMP:
654               throw new DException("DSE87", new Object JavaDoc[] {"DATE/TIME/TIMESTAMP",
655                                    "INT"});
656           }
657           break;
658         case LONG:
659         case BIGINT:
660           long operand11 = ( (Long JavaDoc) result1).longValue();
661           switch (type2) {
662             case SHORT:
663             case SMALLINT:
664               double s7 = ( (Short JavaDoc) result2).doubleValue();
665               return new FieldLiteral(new Double JavaDoc(operand11 / s7), DOUBLE);
666             case BYTE:
667             case TINYINT:
668               double s11 = ( (Byte JavaDoc) result2).doubleValue();
669               return new FieldLiteral(new Double JavaDoc(operand11 / s11), DOUBLE);
670             case INTEGER:
671             case INT:
672               double operand6 = ( (Integer JavaDoc) result2).doubleValue();
673               return new FieldLiteral(new Double JavaDoc(operand11 / operand6), DOUBLE);
674             case LONG:
675             case BIGINT:
676               double operand7 = ( (Long JavaDoc) result2).longValue();
677               return new FieldLiteral(new Double JavaDoc(operand11 / operand7), DOUBLE);
678             case BIGDECIMAL:
679             case DEC:
680             case DECIMAL:
681             case NUMERIC:
682               BigDecimal bbb2 = new BigDecimal(operand11 + "");
683               return new FieldLiteral(bbb2.divide( (BigDecimal) result2, 5, 0),
684                                       BIGDECIMAL);
685             case REAL:
686               double operand8 = ( (Float JavaDoc) result2).doubleValue();
687               return new FieldLiteral(new Double JavaDoc(operand11 / operand8), DOUBLE);
688             case DOUBLE:
689             case FLOAT:
690             case DOUBLEPRECISION:
691               double operand9 = ( (Double JavaDoc) result2).doubleValue();
692               return new FieldLiteral(new Double JavaDoc(operand11 / operand9), DOUBLE);
693             case CHARACTER:
694             case VARCHAR:
695             case CHAR:
696             case CHARACTERVARYING:
697               throw new DException("DSE87", new Object JavaDoc[] {"CHARACTER", "LONG"});
698             case DATE:
699             case TIME:
700             case TIMESTAMP:
701               throw new DException("DSE87", new Object JavaDoc[] {"DATE/TIME/TIMESTAMP",
702                                    "LONG"});
703           }
704           break;
705         case BIGDECIMAL:
706         case DEC:
707         case DECIMAL:
708         case NUMERIC:
709           switch (type2) {
710             case SHORT:
711             case SMALLINT:
712               double d1 = ( (Short JavaDoc) result2).doubleValue();
713               return new FieldLiteral( ( (BigDecimal) result1).divide(new
714                   BigDecimal(d1), 5, 0), BIGDECIMAL);
715             case INTEGER:
716             case INT:
717               double d2 = ( (Integer JavaDoc) result2).doubleValue();
718               return new FieldLiteral( ( (BigDecimal) result1).divide(new
719                   BigDecimal(d2), 5, 0), BIGDECIMAL);
720             case LONG:
721             case BIGINT:
722
723               return new FieldLiteral( ( (BigDecimal) result1).divide(new
724                   BigDecimal("" + result2), 5, 0), BIGDECIMAL); //this is due to precision lost when we called doublevalue() of long
725 case BYTE:
726             case TINYINT:
727               double d4 = ( (Byte JavaDoc) result2).doubleValue();
728               return new FieldLiteral( ( (BigDecimal) result1).divide(new
729                   BigDecimal(d4), 5, 0), BIGDECIMAL);
730             case DOUBLE:
731             case FLOAT:
732             case DOUBLEPRECISION:
733
734               return new FieldLiteral( ( (BigDecimal) result1).divide(new
735                   BigDecimal("" + result2), 5, 0), BIGDECIMAL);
736             case REAL:
737
738               return new FieldLiteral( ( (BigDecimal) result1).divide(new
739                   BigDecimal("" + result2), 5, 0), BIGDECIMAL);
740             case BIGDECIMAL:
741             case DEC:
742             case DECIMAL:
743             case NUMERIC:
744               return new FieldLiteral( ( (BigDecimal) result1).divide( (
745                   BigDecimal) result2, 5, 0), BIGDECIMAL);
746             case CHARACTER:
747             case VARCHAR:
748             case CHAR:
749             case CHARACTERVARYING:
750               throw new DException("DSE87", new Object JavaDoc[] {"CHARACTER",
751                                    "BIGDECIMAL"});
752             case DATE:
753             case TIME:
754             case TIMESTAMP:
755               throw new DException("DSE87", new Object JavaDoc[] {"DATE/TIME/TIMESTAMP",
756                                    "LONG"});
757           }
758           break;
759         case REAL:
760           float operand111 = ( (Float JavaDoc) result1).floatValue();
761           switch (type2) {
762             case SHORT:
763             case SMALLINT:
764               short s8 = ( (Short JavaDoc) result2).shortValue();
765               return new FieldLiteral(new Double JavaDoc(operand111 / s8), DOUBLE);
766             case BYTE:
767             case TINYINT:
768               byte d4 = ( (Byte JavaDoc) result2).byteValue();
769               return new FieldLiteral(new Double JavaDoc(operand111 / d4), DOUBLE);
770             case INTEGER:
771             case INT:
772               int operand12 = ( (Integer JavaDoc) result2).intValue();
773               return new FieldLiteral(new Double JavaDoc(operand111 / operand12),
774                                       DOUBLE);
775             case LONG:
776             case BIGINT:
777               long operand13 = ( (Long JavaDoc) result2).longValue();
778               return new FieldLiteral(new Double JavaDoc(operand111 / operand13),
779                                       DOUBLE);
780             case BIGDECIMAL:
781             case DEC:
782             case DECIMAL:
783             case NUMERIC:
784               BigDecimal bbb3 = new BigDecimal(operand111 + "");
785               return new FieldLiteral(bbb3.divide( (BigDecimal) result2, 5, 0),
786                                       BIGDECIMAL);
787             case REAL:
788               float operand14 = ( (Float JavaDoc) result2).floatValue();
789               return new FieldLiteral(new Double JavaDoc(operand111 / operand14),
790                                       DOUBLE);
791             case DOUBLE:
792             case FLOAT:
793             case DOUBLEPRECISION:
794               double operand15 = ( (Double JavaDoc) result2).doubleValue();
795               return new FieldLiteral(new Double JavaDoc(operand111 / operand15),
796                                       DOUBLE);
797             case CHARACTER:
798             case VARCHAR:
799             case CHAR:
800             case CHARACTERVARYING:
801               throw new DException("DSE87", new Object JavaDoc[] {"CHARACTER", "FLOAT"});
802             case DATE:
803             case TIME:
804             case TIMESTAMP:
805               throw new DException("DSE87", new Object JavaDoc[] {"DATE/TIME/TIMESTAMP",
806                                    "FLOAT"});
807           }
808           break;
809         case DOUBLE:
810         case FLOAT:
811         case DOUBLEPRECISION:
812           double operand1111 = ( (Double JavaDoc) result1).doubleValue();
813           switch (type2) {
814             case BYTE:
815             case TINYINT:
816               byte d4 = ( (Byte JavaDoc) result2).byteValue();
817               return new FieldLiteral(new Double JavaDoc(operand1111 / d4), DOUBLE);
818             case SHORT:
819             case SMALLINT:
820               short s9 = ( (Short JavaDoc) result2).shortValue();
821               return new FieldLiteral(new Double JavaDoc(operand1111 / s9), DOUBLE);
822             case INTEGER:
823             case INT:
824               int operand16 = ( (Integer JavaDoc) result2).intValue();
825               return new FieldLiteral(new Double JavaDoc(operand1111 / operand16),
826                                       DOUBLE);
827             case LONG:
828             case BIGINT:
829               long operand17 = ( (Long JavaDoc) result2).longValue();
830               return new FieldLiteral(new Double JavaDoc(operand1111 / operand17),
831                                       DOUBLE);
832             case BIGDECIMAL:
833             case DEC:
834             case DECIMAL:
835             case NUMERIC:
836               BigDecimal bbb4 = new BigDecimal(operand1111 + "");
837               return new FieldLiteral(bbb4.divide( (BigDecimal) result2, 5, 0),
838                                       BIGDECIMAL);
839             case REAL:
840               float operand18 = ( (Float JavaDoc) result2).floatValue();
841               return new FieldLiteral(new Double JavaDoc(operand1111 / operand18),
842                                       DOUBLE);
843             case DOUBLE:
844             case FLOAT:
845             case DOUBLEPRECISION:
846               double operand19 = ( (Double JavaDoc) result2).doubleValue();
847               return new FieldLiteral(new Double JavaDoc(operand1111 / operand19),
848                                       DOUBLE);
849             case CHARACTER:
850             case VARCHAR:
851             case CHAR:
852             case CHARACTERVARYING:
853               throw new DException("DSE87", new Object JavaDoc[] {"CHARACTER", "DOUBLE"});
854             case DATE:
855             case TIME:
856             case TIMESTAMP:
857               throw new DException("DSE87", new Object JavaDoc[] {"DATE/TIME/TIMESTAMP",
858                                    "DOUBLE"});
859           }
860           break;
861         case CHARACTER:
862         case VARCHAR:
863         case CHAR:
864         case CHARACTERVARYING:
865           switch (type2) {
866             case SHORT:
867             case SMALLINT:
868               throw new DException("DSE87", new Object JavaDoc[] {"CHARACTER", "SHORT"});
869             case INTEGER:
870             case INT:
871               throw new DException("DSE87", new Object JavaDoc[] {"CHARACTER", "INT"});
872             case LONG:
873             case BIGINT:
874               throw new DException("DSE87", new Object JavaDoc[] {"CHARACTER", "LONG"});
875             case BIGDECIMAL:
876             case DEC:
877             case DECIMAL:
878             case NUMERIC:
879               throw new DException("DSE87", new Object JavaDoc[] {"CHARACTER",
880                                    "BIGDECIMAL"});
881             case REAL:
882               throw new DException("DSE87", new Object JavaDoc[] {"CHARACTER", "FLOAT"});
883             case DOUBLE:
884             case FLOAT:
885             case DOUBLEPRECISION:
886               throw new DException("DSE87", new Object JavaDoc[] {"CHARACTER", "DOUBLE"});
887             case DATE:
888             case TIME:
889             case TIMESTAMP:
890               throw new DException("DSE87", new Object JavaDoc[] {"CHARACTER",
891                                    "DATE/TIME/TIMESTAMP"});
892           }
893           break;
894         case DATE:
895         case TIME:
896         case TIMESTAMP:
897           switch (type2) {
898             case SHORT:
899             case SMALLINT:
900               throw new DException("DSE87", new Object JavaDoc[] {"DATE/TIME/TIMESTAMP",
901                                    "SHORT"});
902             case INTEGER:
903             case INT:
904               throw new DException("DSE87", new Object JavaDoc[] {"DATE/TIME/TIMESTAMP",
905                                    "INT"});
906             case LONG:
907             case BIGINT:
908               throw new DException("DSE87", new Object JavaDoc[] {"DATE/TIME/TIMESTAMP",
909                                    "LONG"});
910             case BIGDECIMAL:
911             case DEC:
912             case DECIMAL:
913             case NUMERIC:
914               throw new DException("DSE87", new Object JavaDoc[] {"DATE/TIME/TIMESTAMP",
915                                    "BIGDECIMAL"});
916             case REAL:
917               throw new DException("DSE87", new Object JavaDoc[] {"DATE/TIME/TIMESTAMP",
918                                    "FLOAT"});
919             case DOUBLE:
920             case FLOAT:
921             case DOUBLEPRECISION:
922               throw new DException("DSE87", new Object JavaDoc[] {"DATE/TIME/TIMESTAMP",
923                                    "DOUBLE"});
924             case DATE:
925             case TIME:
926             case TIMESTAMP:
927               throw new DException("DSE87", new Object JavaDoc[] {"DATE/TIME/TIMESTAMP",
928                                    "DATE/TIME/TIMESTAMP"});
929           }
930       }
931       throw new DException("DSE35",
932                            new Object JavaDoc[] {StaticClass.getDataTypeName(type1),
933                            StaticClass.getDataTypeName(type2)});
934     }
935     catch (ArithmeticException JavaDoc ex) {
936       throw new DException("DSE334", null);
937     }
938   }
939
940   public int getDataType(Object JavaDoc object) throws DException {
941     return super.getDataType(object, "DIVIDE");
942   }
943
944   public AbstractRowValueExpression[] getChilds() {
945     AbstractRowValueExpression[] childs = new AbstractRowValueExpression[] {
946         (AbstractRowValueExpression) _term2,
947         (AbstractRowValueExpression) _factor0};
948     return childs;
949   }
950
951   /* public ColumnDetails[] getColumnDetails() throws DException {
952       if (columnDetails == null) {
953          ColumnDetails firstlistOfColumns[] = _term2.getColumnDetails();
954          ColumnDetails secondlistOfColumns[] = _factor0.getColumnDetails();
955          int length = firstlistOfColumns.length + secondlistOfColumns.length;
956          columnDetails = new ColumnDetails[length];
957          int index = 0;
958          for (; index < firstlistOfColumns.length; ++index) {
959             columnDetails[index] = firstlistOfColumns[index];
960          }
961          for (int i = 0; i < secondlistOfColumns.length; ++i, ++index) {
962             columnDetails[index] = secondlistOfColumns[i];
963          }
964       }
965       return columnDetails;
966    }
967    */
968   public String JavaDoc toString() {
969     StringBuffer JavaDoc sb = new StringBuffer JavaDoc();
970     sb.append(" ");
971     sb.append(_term2);
972     sb.append(" ");
973     sb.append(_Ssolidus_20304551591);
974     sb.append(" ");
975     sb.append(_factor0);
976     return sb.toString();
977   }
978
979   public Object JavaDoc clone() throws CloneNotSupportedException JavaDoc {
980     termSsolidus_2030455159factor tempClass = new termSsolidus_2030455159factor();
981     tempClass._factor0 = (factor) _factor0.clone();
982     tempClass._Ssolidus_20304551591 = (Ssolidus_2030455159)
983         _Ssolidus_20304551591.clone();
984     tempClass._term2 = (term) _term2.clone();
985     return tempClass;
986   }
987
988   /*protected int getAppropriateDataType(Object object) throws DException {
989       int dataType1 = getDataTypeForByte(childs[0].getByteComparison(object));
990       int dataType2 = getDataTypeForByte(childs[1].getByteComparison(object));
991       if (dataType1 == -1 || dataType2 == -1) { // To avoid checking for '?' when called from SemanticChecking
992         return -1;
993       }
994       switch (dataType1) {
995         case BYTE:
996         case TINYINT:
997           switch (dataType2) {
998             case BYTE:
999             case TINYINT:
1000              return DOUBLE;
1001            case SHORT:
1002            case SMALLINT:
1003              return DOUBLE;
1004            case INTEGER:
1005            case INT:
1006              return DOUBLE;
1007            case LONG:
1008            case BIGINT:
1009              return DOUBLE;
1010            case BIGDECIMAL:
1011            case DEC:
1012            case DECIMAL:
1013            case NUMERIC:
1014              return BIGDECIMAL;
1015            case REAL:
1016              return DOUBLE;
1017            case DOUBLE:
1018            case FLOAT:
1019            case DOUBLEPRECISION:
1020              return DOUBLE;
1021            case CHARACTER:
1022            case VARCHAR:
1023            case CHAR:
1024            case CHARACTERVARYING:
1025   throw new DException("DSE87", new Object[] {"CHARACTER", "BYTE"});
1026            case DATE:
1027            case TIME:
1028            case TIMESTAMP:
1029   throw new DException("DSE87", new Object[] {"DATE/TIME/TIMESTAMP",
1030                                   "BYTE"});
1031          }
1032        case SHORT:
1033        case SMALLINT:
1034          switch (dataType2) {
1035            case SHORT:
1036            case SMALLINT:
1037              return DOUBLE;
1038            case BYTE:
1039            case TINYINT:
1040              return DOUBLE;
1041            case INTEGER:
1042            case INT:
1043              return DOUBLE;
1044            case LONG:
1045            case BIGINT:
1046              return DOUBLE;
1047            case BIGDECIMAL:
1048            case DEC:
1049            case DECIMAL:
1050            case NUMERIC:
1051              return BIGDECIMAL;
1052            case REAL:
1053              return DOUBLE;
1054            case DOUBLE:
1055            case FLOAT:
1056            case DOUBLEPRECISION:
1057              return DOUBLE;
1058            case CHARACTER:
1059            case VARCHAR:
1060            case CHAR:
1061            case CHARACTERVARYING:
1062   throw new DException("DSE87", new Object[] {"CHARACTER", "SHORT"});
1063            case DATE:
1064            case TIME:
1065            case TIMESTAMP:
1066   throw new DException("DSE87", new Object[] {"DATE/TIME/TIMESTAMP",
1067                                   "SHORT"});
1068          }
1069        case INTEGER:
1070        case INT:
1071          switch (dataType2) {
1072            case SHORT:
1073            case SMALLINT:
1074              return DOUBLE;
1075            case BYTE:
1076            case TINYINT:
1077              return DOUBLE;
1078            case INTEGER:
1079            case INT:
1080              return DOUBLE;
1081            case LONG:
1082            case BIGINT:
1083              return DOUBLE;
1084            case BIGDECIMAL:
1085            case DEC:
1086            case DECIMAL:
1087            case NUMERIC:
1088              return BIGDECIMAL;
1089            case REAL:
1090              return DOUBLE;
1091            case DOUBLE:
1092            case FLOAT:
1093            case DOUBLEPRECISION:
1094              return DOUBLE;
1095            case CHARACTER:
1096            case VARCHAR:
1097            case CHAR:
1098            case CHARACTERVARYING:
1099              throw new DException("DSE87", new Object[] {"CHARACTER", "INT"});
1100            case DATE:
1101            case TIME:
1102            case TIMESTAMP:
1103   throw new DException("DSE87", new Object[] {"DATE/TIME/TIMESTAMP",
1104                                   "INT"});
1105          }
1106        case LONG:
1107        case BIGINT:
1108          switch (dataType2) {
1109            case SHORT:
1110            case SMALLINT:
1111              return DOUBLE;
1112            case BYTE:
1113            case TINYINT:
1114              return DOUBLE;
1115            case INTEGER:
1116            case INT:
1117              return DOUBLE;
1118            case LONG:
1119            case BIGINT:
1120              return DOUBLE;
1121            case BIGDECIMAL:
1122            case DEC:
1123            case DECIMAL:
1124            case NUMERIC:
1125              return BIGDECIMAL;
1126            case REAL:
1127              return DOUBLE;
1128            case DOUBLE:
1129            case FLOAT:
1130            case DOUBLEPRECISION:
1131              return DOUBLE;
1132            case CHARACTER:
1133            case VARCHAR:
1134            case CHAR:
1135            case CHARACTERVARYING:
1136   throw new DException("DSE87", new Object[] {"CHARACTER", "LONG"});
1137            case DATE:
1138            case TIME:
1139            case TIMESTAMP:
1140   throw new DException("DSE87", new Object[] {"DATE/TIME/TIMESTAMP",
1141                                   "LONG"});
1142          }
1143        case BIGDECIMAL:
1144        case DEC:
1145        case DECIMAL:
1146        case NUMERIC:
1147          switch (dataType2) {
1148            case SHORT:
1149            case SMALLINT:
1150              return BIGDECIMAL;
1151            case INTEGER:
1152            case INT:
1153              return BIGDECIMAL;
1154            case LONG:
1155            case BIGINT:
1156              return BIGDECIMAL;
1157            case BYTE:
1158            case TINYINT:
1159              return BIGDECIMAL;
1160            case DOUBLE:
1161            case FLOAT:
1162            case DOUBLEPRECISION:
1163              return BIGDECIMAL;
1164            case REAL:
1165              return BIGDECIMAL;
1166            case BIGDECIMAL:
1167            case DEC:
1168            case DECIMAL:
1169            case NUMERIC:
1170              return BIGDECIMAL;
1171            case CHARACTER:
1172            case VARCHAR:
1173            case CHAR:
1174            case CHARACTERVARYING:
1175              throw new DException("DSE87", new Object[] {"CHARACTER",
1176                                   "BIGDECIMAL"});
1177            case DATE:
1178            case TIME:
1179            case TIMESTAMP:
1180   throw new DException("DSE87", new Object[] {"DATE/TIME/TIMESTAMP",
1181                                   "LONG"});
1182          }
1183        case REAL:
1184          switch (dataType2) {
1185            case SHORT:
1186            case SMALLINT:
1187              return DOUBLE;
1188            case BYTE:
1189            case TINYINT:
1190              return DOUBLE;
1191            case INTEGER:
1192            case INT:
1193              return DOUBLE;
1194            case LONG:
1195            case BIGINT:
1196              return DOUBLE;
1197            case BIGDECIMAL:
1198            case DEC:
1199            case DECIMAL:
1200            case NUMERIC:
1201              return BIGDECIMAL;
1202            case REAL:
1203              return DOUBLE;
1204            case DOUBLE:
1205            case FLOAT:
1206            case DOUBLEPRECISION:
1207              return DOUBLE;
1208            case CHARACTER:
1209            case VARCHAR:
1210            case CHAR:
1211            case CHARACTERVARYING:
1212   throw new DException("DSE87", new Object[] {"CHARACTER", "FLOAT"});
1213            case DATE:
1214            case TIME:
1215            case TIMESTAMP:
1216   throw new DException("DSE87", new Object[] {"DATE/TIME/TIMESTAMP",
1217                                   "FLOAT"});
1218          }
1219        case DOUBLE:
1220        case FLOAT:
1221        case DOUBLEPRECISION:
1222          switch (dataType2) {
1223            case BYTE:
1224            case TINYINT:
1225              return DOUBLE;
1226            case SHORT:
1227            case SMALLINT:
1228              return DOUBLE;
1229            case INTEGER:
1230            case INT:
1231              return DOUBLE;
1232            case LONG:
1233            case BIGINT:
1234              return DOUBLE;
1235            case BIGDECIMAL:
1236            case DEC:
1237            case DECIMAL:
1238            case NUMERIC:
1239              return BIGDECIMAL;
1240            case REAL:
1241              return DOUBLE;
1242            case DOUBLE:
1243            case FLOAT:
1244            case DOUBLEPRECISION:
1245              return DOUBLE;
1246            case CHARACTER:
1247            case VARCHAR:
1248            case CHAR:
1249            case CHARACTERVARYING:
1250   throw new DException("DSE87", new Object[] {"CHARACTER", "DOUBLE"});
1251            case DATE:
1252            case TIME:
1253            case TIMESTAMP:
1254   throw new DException("DSE87", new Object[] {"DATE/TIME/TIMESTAMP",
1255                                   "DOUBLE"});
1256          }
1257        case CHARACTER:
1258        case VARCHAR:
1259        case CHAR:
1260        case CHARACTERVARYING:
1261          switch (dataType2) {
1262            case SHORT:
1263            case SMALLINT:
1264   throw new DException("DSE87", new Object[] {"CHARACTER", "SHORT"});
1265            case INTEGER:
1266            case INT:
1267              throw new DException("DSE87", new Object[] {"CHARACTER", "INT"});
1268            case LONG:
1269            case BIGINT:
1270   throw new DException("DSE87", new Object[] {"CHARACTER", "LONG"});
1271            case BIGDECIMAL:
1272            case DEC:
1273            case DECIMAL:
1274            case NUMERIC:
1275              throw new DException("DSE87", new Object[] {"CHARACTER",
1276                                   "BIGDECIMAL"});
1277            case REAL:
1278   throw new DException("DSE87", new Object[] {"CHARACTER", "FLOAT"});
1279            case DOUBLE:
1280            case FLOAT:
1281            case DOUBLEPRECISION:
1282   throw new DException("DSE87", new Object[] {"CHARACTER", "DOUBLE"});
1283            case DATE:
1284            case TIME:
1285            case TIMESTAMP:
1286              throw new DException("DSE87", new Object[] {"CHARACTER",
1287                                   "DATE/TIME/TIMESTAMP"});
1288          }
1289        case DATE:
1290        case TIME:
1291        case TIMESTAMP:
1292          switch (dataType2) {
1293            case SHORT:
1294            case SMALLINT:
1295   throw new DException("DSE87", new Object[] {"DATE/TIME/TIMESTAMP",
1296                                   "SHORT"});
1297            case INTEGER:
1298            case INT:
1299   throw new DException("DSE87", new Object[] {"DATE/TIME/TIMESTAMP",
1300                                   "INT"});
1301            case LONG:
1302            case BIGINT:
1303   throw new DException("DSE87", new Object[] {"DATE/TIME/TIMESTAMP",
1304                                   "LONG"});
1305            case BIGDECIMAL:
1306            case DEC:
1307            case DECIMAL:
1308            case NUMERIC:
1309   throw new DException("DSE87", new Object[] {"DATE/TIME/TIMESTAMP",
1310                                   "BIGDECIMAL"});
1311            case REAL:
1312   throw new DException("DSE87", new Object[] {"DATE/TIME/TIMESTAMP",
1313                                   "FLOAT"});
1314            case DOUBLE:
1315            case FLOAT:
1316            case DOUBLEPRECISION:
1317   throw new DException("DSE87", new Object[] {"DATE/TIME/TIMESTAMP",
1318                                   "DOUBLE"});
1319            case DATE:
1320            case TIME:
1321            case TIMESTAMP:
1322   throw new DException("DSE87", new Object[] {"DATE/TIME/TIMESTAMP",
1323                                   "DATE/TIME/TIMESTAMP"});
1324          }
1325      }
1326      throw new DException("DSE35",
1327   new Object[] {StaticClass.getDataTypeName(dataType1),
1328                           StaticClass.getDataTypeName(dataType2)});
1329
1330    }*/
1331
1332  public ByteComparison getByteComparison(Object JavaDoc object) throws DException {
1333
1334    initializeChildren();
1335    return new ByteComparison(false,
1336                              new int[] {dtType});
1337  }
1338
1339  public ColumnDetails[] getColumnDetails() throws DException {
1340    if (columnDetails == null) {
1341      ColumnDetails firstlistOfColumns[] = _term2.getColumnDetails();
1342      ColumnDetails secondlistOfColumns[] = _factor0.getColumnDetails();
1343      int length = firstlistOfColumns.length + secondlistOfColumns.length;
1344      columnDetails = new ColumnDetails[length];
1345      int index = 0;
1346      for (; index < firstlistOfColumns.length; ++index) {
1347        columnDetails[index] = firstlistOfColumns[index];
1348      }
1349      for (int i = 0; i < secondlistOfColumns.length; ++i, ++index) {
1350        columnDetails[index] = secondlistOfColumns[i];
1351      }
1352    }
1353
1354    if (columnDetails.length == 1)
1355      return columnDetails;
1356
1357    ColumnDetails columnDetail = new ColumnDetails();
1358    String JavaDoc str = toString();
1359    columnDetail.setColumn(new String JavaDoc[] {str});
1360    columnDetail.setType(FUNCTIONAL);
1361    columnDetail.setObject(this);
1362    columnDetail.setExpression(str);
1363    return new ColumnDetails[] {
1364        columnDetail};
1365  }
1366
1367  public ColumnDetails[] getChildColumnDetails() throws DException {
1368    return columnDetails;
1369  }
1370
1371  /* Method overridden by Kaushik to solve Bug no. 11993 */
1372  public ParameterInfo[] getParameterInfo() throws DException {
1373    ParameterInfo[] parameterInfo = super.getParameterInfo();
1374    for (int i = 0; i < parameterInfo.length; i++) {
1375      if (parameterInfo[i].getQuestionMark()) {
1376        parameterInfo[i].setDataType(Datatypes.BIGDECIMAL);
1377      }
1378    }
1379    return parameterInfo;
1380  }
1381
1382}
1383
Popular Tags