|
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
14 public class termSasterisk_344623246factor
15 extends AbstractTerm
16 implements term, Datatypes, _sortspecificationAndselectSubList {
17 public factor _factor0;
18 public Sasterisk_344623246 _Sasterisk_3446232461;
19 public term _term2;
20
21 public _Reference[] checkSemantic(_ServerSession parent) throws DException {
22 _Reference[] refs = super.checkSemantic(parent);
23 if (refs == null || refs.length == 0) { ByteComparison bc1 = _term2.getByteComparison(parent);
25 ByteComparison bc2 = _factor0.getByteComparison(parent);
26 checkSemantic(parent, bc1, bc2);
27 }
28 setAppropriateDatatypeAndCheck(parent);
29 return refs;
30 }
31
32 int dtType = -1;
33 private void setAppropriateDatatypeAndCheck(Object  object) throws DException {
34 ColumnDetails[] cd = _term2.getColumnDetails();
35 ColumnDetails[] Rcd = _factor0.getColumnDetails();
36 int dataType1 = 0;
37 int dataType2 = 0;
38 switch (cd.length) {
39 case 0: switch (Rcd.length) {
41 case 0: dataType1 = getDataTypeForByte(childs[0].getByteComparison(object));
43 dataType2 = getDataTypeForByte(childs[1].getByteComparison(object));
44 break;
45 default: dataType1 = getDataTypeForByte(childs[0].getByteComparison(object));
47 Rcd[0].setDatatype(Datatypes.BIGDECIMAL);
48 dataType2 = Datatypes.BIGDECIMAL;
49 }
50 break;
51 default:
52 switch (Rcd.length) {
53 case 0: dataType2 = getDataTypeForByte(childs[1].getByteComparison(object));
55 cd[0].setDatatype(Datatypes.BIGDECIMAL);
56 dataType1 = Datatypes.BIGDECIMAL;
57 break;
58 default:
59 if ( (cd[0].getQuestion() && (Rcd[0].getQuestion()))) {
60 cd[0].setDatatype(15); Rcd[0].setDatatype(15); dataType1 = 15;
63 dataType2 = 15;
64 }
65 else
66 if (cd[0].getQuestion()) {
67 dataType2 = getDataTypeForByte(childs[1].getByteComparison(object));
68 cd[0].setDatatype(15); dataType1 = 15;
70 }
71 else
72 if (Rcd[0].getQuestion()) {
73 dataType1 = getDataTypeForByte(childs[0].getByteComparison(object));
74 Rcd[0].setDatatype(15); dataType2 = 15;
76 }
77 else {
78 dataType1 = getDataTypeForByte(childs[0].getByteComparison(object));
79 dataType2 = getDataTypeForByte(childs[1].getByteComparison(object));
80
81 }
82 }
83 }
84
85
86 if (dataType1 == -1 || dataType2 == -1) { dtType = -1;
88 return;
89 }
90
91
92 switch (dataType1) {
93 case BYTE:
94 case TINYINT:
95 switch (dataType2) {
96 case BYTE:
97 case TINYINT:
98 dtType = SHORT;
99 break;
100 case SHORT:
101 case SMALLINT:
102 dtType = INTEGER;
103 break;
104 case INTEGER:
105 case INT:
106 dtType = LONG;
107 break;
108 case LONG:
109 case BIGINT:
110 dtType = BIGDECIMAL;
111 break;
112 case BIGDECIMAL:
113 case DEC:
114 case DECIMAL:
115 case NUMERIC:
116 dtType = BIGDECIMAL;
117 break;
118 case REAL:
119 dtType = FLOAT;
120 break;
121 case DOUBLE:
122 case FLOAT:
123 case DOUBLEPRECISION:
124 dtType = DOUBLE;
125 break;
126 case CHARACTER:
127 case VARCHAR:
128 case CHAR:
129 case CHARACTERVARYING:
130 throw new DException("DSE87", new Object [] {"CHARACTER", "BYTE"});
131
132 case DATE:
133 case TIMESTAMP:
134 case TIME:
135 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
136 "BYTE"});
137 }
138 break;
139 case SHORT:
140 case SMALLINT:
141 switch (dataType2) {
142 case BYTE:
143 case TINYINT:
144 dtType = INTEGER;
145 break;
146 case SHORT:
147 case SMALLINT:
148 dtType = INTEGER;
149 break;
150 case INTEGER:
151 case INT:
152 dtType = LONG;
153 break;
154 case LONG:
155 case BIGINT:
156 dtType = BIGDECIMAL;
157 break;
158 case BIGDECIMAL:
159 case DEC:
160 case DECIMAL:
161 case NUMERIC:
162 dtType = BIGDECIMAL;
163 break;
164 case REAL:
165 dtType = DOUBLE;
166 break;
167 case DOUBLE:
168 case FLOAT:
169 case DOUBLEPRECISION:
170 dtType = BIGDECIMAL;
171 break;
172 case CHARACTER:
173 case VARCHAR:
174 case CHAR:
175 case CHARACTERVARYING:
176 throw new DException("DSE87", new Object [] {"CHARACTER", "SHORT"});
177
178 case DATE:
179 case TIMESTAMP:
180 case TIME:
181 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
182 "SORT"});
183 }
184 break;
185 case INTEGER:
186 case INT:
187 switch (dataType2) {
188
189 case BYTE:
190 case TINYINT:
191 dtType = LONG;
192 break;
193 case SHORT:
194 case SMALLINT:
195 dtType = LONG;
196 break;
197
198 case INTEGER:
199 case INT:
200 dtType = LONG;
201 break;
202 case LONG:
203 case BIGINT:
204 dtType = DOUBLE;
205 break;
206 case BIGDECIMAL:
207 case DEC:
208 case DECIMAL:
209 case NUMERIC:
210 dtType = BIGDECIMAL;
211 break;
212 case REAL:
213 dtType = DOUBLE;
214 break;
215 case DOUBLE:
216 case FLOAT:
217 case DOUBLEPRECISION:
218 dtType = BIGDECIMAL;
219 break;
220 case CHARACTER:
221 case VARCHAR:
222 case CHAR:
223 case CHARACTERVARYING:
224 throw new DException("DSE87", new Object [] {"CHARACTER", "INT"});
225
226 case DATE:
227 case TIMESTAMP:
228 case TIME:
229 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
230 "INT"});
231 }
232 break;
233 case LONG:
234 case BIGINT:
235 switch (dataType2) {
236 case BYTE:
237 case TINYINT:
238 dtType = BIGDECIMAL;
239 break;
240 case SHORT:
241 case SMALLINT:
242 dtType = DOUBLE;
243 break;
244 case INTEGER:
245 case INT:
246 dtType = DOUBLE;
247 break;
248 case LONG:
249 case BIGINT:
250 dtType = DOUBLE;
251 break;
252 case BIGDECIMAL:
253 case DEC:
254 case DECIMAL:
255 case NUMERIC:
256 dtType = BIGDECIMAL;
257 break;
258 case REAL:
259 dtType = DOUBLE;
260 break;
261 case DOUBLE:
262 case FLOAT:
263 case DOUBLEPRECISION:
264 dtType = BIGDECIMAL;
265 break;
266 case CHARACTER:
267 case VARCHAR:
268 case CHAR:
269 case CHARACTERVARYING:
270 throw new DException("DSE87", new Object [] {"CHARACTER", "LONG"});
271
272 case DATE:
273 case TIMESTAMP:
274 case TIME:
275 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
276 "LONG"});
277 }
278 break;
279 case BIGDECIMAL:
280 case DEC:
281 case DECIMAL:
282 case NUMERIC:
283 switch (dataType2) {
284 case SHORT:
285 case SMALLINT:
286 dtType = BIGDECIMAL;
287 break;
288 case BYTE:
289 case TINYINT:
290 dtType = BIGDECIMAL;
291 break;
292 case INTEGER:
293 case INT:
294 dtType = BIGDECIMAL;
295 break;
296 case DOUBLE:
297 case FLOAT:
298 case DOUBLEPRECISION:
299 dtType = BIGDECIMAL;
300 break;
301 case REAL:
302 dtType = BIGDECIMAL;
303 break;
304 case LONG:
305 case BIGINT:
306 dtType = BIGDECIMAL;
307 break;
308 case BIGDECIMAL:
309 case DEC:
310 case DECIMAL:
311 case NUMERIC:
312 dtType = BIGDECIMAL;
313 break;
314 case CHARACTER:
315 case VARCHAR:
316 case CHAR:
317 case CHARACTERVARYING:
318 throw new DException("DSE87", new Object [] {"CHARACTER",
319 "BIGDECIMAL"});
320
321 case DATE:
322 case TIMESTAMP:
323 case TIME:
324 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
325 "BIGDECIMAL"});
326 }
327 break;
328 case REAL:
329 switch (dataType2) {
330 case SHORT:
331 case SMALLINT:
332 dtType = DOUBLE;
333 break;
334 case BYTE:
335 case TINYINT:
336 dtType = DOUBLE;
337 break;
338 case INTEGER:
339 case INT:
340 dtType = DOUBLE;
341 break;
342 case LONG:
343 case BIGINT:
344 dtType = DOUBLE;
345 break;
346 case BIGDECIMAL:
347 case DEC:
348 case DECIMAL:
349 case NUMERIC:
350 dtType = BIGDECIMAL;
351 break;
352 case REAL:
353 dtType = DOUBLE;
354 break;
355 case DOUBLE:
356 case FLOAT:
357 case DOUBLEPRECISION:
358 dtType = BIGDECIMAL;
359 break;
360 case CHARACTER:
361 case VARCHAR:
362 case CHAR:
363 case CHARACTERVARYING:
364 throw new DException("DSE87", new Object [] {"CHARACTER", "FLOAT"});
365
366 case DATE:
367 case TIMESTAMP:
368 case TIME:
369 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
370 "FLOAT"});
371 }
372 break;
373 case DOUBLE:
374 case FLOAT:
375 case DOUBLEPRECISION:
376 switch (dataType2) {
377 case SHORT:
378 case SMALLINT:
379 dtType = BIGDECIMAL;
380 break;
381 case BYTE:
382 case TINYINT:
383 dtType = BIGDECIMAL;
384 break;
385 case INTEGER:
386 case INT:
387 dtType = BIGDECIMAL;
388 break;
389 case LONG:
390 case BIGINT:
391 dtType = BIGDECIMAL;
392 break;
393 case BIGDECIMAL:
394 case DEC:
395 case DECIMAL:
396 case NUMERIC:
397 dtType = BIGDECIMAL;
398 break;
399 case REAL:
400 dtType = BIGDECIMAL;
401 break;
402 case DOUBLE:
403 case FLOAT:
404 case DOUBLEPRECISION:
405 dtType = BIGDECIMAL;
406 break;
407 case CHARACTER:
408 case VARCHAR:
409 case CHAR:
410 case CHARACTERVARYING:
411 throw new DException("DSE87", new Object [] {"CHARACTER", "DOUBLE"});
412
413 case DATE:
414 case TIMESTAMP:
415 case TIME:
416 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
417 "DOUBLE"});
418 }
419 break;
420 case CHARACTER:
421 case VARCHAR:
422 case CHAR:
423 case CHARACTERVARYING:
424 switch (dataType2) {
425 case BYTE:
426 throw new DException("DSE87", new Object [] {"CHARACTER", "BYTE"});
427 case SHORT:
428 case SMALLINT:
429 throw new DException("DSE87", new Object [] {"CHARACTER", "SHORT"});
430 case INTEGER:
431 case INT:
432 throw new DException("DSE87", new Object [] {"CHARACTER", "INT"});
433 case LONG:
434 case BIGINT:
435 throw new DException("DSE87", new Object [] {"CHARACTER", "LONG"});
436 case BIGDECIMAL:
437 case DEC:
438 case DECIMAL:
439 case NUMERIC:
440 throw new DException("DSE87", new Object [] {"CHARACTER",
441 "BIGDECIMAL"});
442 case REAL:
443 throw new DException("DSE87", new Object [] {"CHARACTER", "FLOAT"});
444 case DOUBLE:
445 case FLOAT:
446 case DOUBLEPRECISION:
447 throw new DException("DSE87", new Object [] {"CHARACTER", "DOUBLE"});
448 case DATE:
449 case TIME:
450 case TIMESTAMP:
451 throw new DException("DSE87", new Object [] {"CHARACTER",
452 "DATE/TIME/TIMESTAMP"});
453 case CHARACTER:
454 case VARCHAR:
455 case CHAR:
456 case CHARACTERVARYING:
457 throw new DException("DSE87", new Object [] {"CHARACTER",
458 "CHARACTER"});
459
460 }
461 break;
462
463
518
519 case DATE:
520 case TIMESTAMP:
521 case TIME:
522 switch (dataType2) {
523 case SHORT:
524 case SMALLINT:
525 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
526 "SHORT"});
527 case INTEGER:
528 case INT:
529 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
530 "INT"});
531 case LONG:
532 case BIGINT:
533 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
534 "LONG"});
535 case BIGDECIMAL:
536 case DEC:
537 case DECIMAL:
538 case NUMERIC:
539 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
540 "BIGDECIMAL"});
541 case REAL:
542 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
543 "FLOAT"});
544 case DOUBLE:
545 case FLOAT:
546 case DOUBLEPRECISION:
547 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
548 "DOUBLE"});
549 case DATE:
550 case TIME:
551 case TIMESTAMP:
552 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
553 "DATE/TIME/TIMESTAMP"});
554 }
555 break;
556 default:
557 throw new DException("DSE35",
558 new Object [] {StaticClass.getDataTypeName(dataType1),
559 StaticClass.getDataTypeName(dataType2)});
560 }
561 }
562
563 public FieldBase getObject(int type1, int type2, Object result1,
564 Object result2) throws DException {
565 try {
566 switch (type1) {
567 case BYTE:
568 case TINYINT:
569 byte operand0 = ( (Byte ) result1).byteValue();
570 switch (type2) {
571 case BYTE:
572 case TINYINT:
573 byte s11 = ( (Byte ) result2).byteValue();
574 return new FieldLiteral(new Short ( (short) (operand0 * s11)),
575 SHORT);
576 case SHORT:
577 case SMALLINT:
578 short s1 = ( (Short ) result2).shortValue();
579 return new FieldLiteral(new Integer ( (int) (operand0 * s1)),
580 INTEGER);
581 case INTEGER:
582 case INT:
583 int s2 = ( (Integer ) result2).intValue();
584 return new FieldLiteral(new Long ( (operand0 * s2)), LONG);
585 case LONG:
586 case BIGINT:
587 long s3 = ( (Long ) result2).longValue();
588 return new FieldLiteral(new BigDecimal("" + (operand0 * s3)),
589 BIGDECIMAL);
590 case BIGDECIMAL:
591 case DEC:
592 case DECIMAL:
593 case NUMERIC:
594 BigDecimal bbb = new BigDecimal(operand0 + "");
595 return new FieldLiteral(bbb.multiply( (BigDecimal) result2),
596 BIGDECIMAL);
597 case REAL:
598 float s4 = ( (Float ) result2).floatValue();
599 return new FieldLiteral(new Double (operand0 * s4), DOUBLE);
600 case DOUBLE:
601 case FLOAT:
602 case DOUBLEPRECISION:
603 double s5 = ( (Double ) result2).doubleValue();
604 return new FieldLiteral(new Double (operand0 * s5), DOUBLE);
605 case CHARACTER:
606 case VARCHAR:
607 case CHAR:
608 case CHARACTERVARYING:
609 throw new DException("DSE87", new Object [] {"CHARACTER", "BYTE"});
610 case DATE:
611 case TIME:
612 case TIMESTAMP:
613 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
614 "BYTE"});
615 }
616 break;
617 case SHORT:
618 case SMALLINT:
619 short operand = ( (Short ) result1).shortValue();
620 switch (type2) {
621 case BYTE:
622 case TINYINT:
623 byte s11 = ( (Byte ) result2).byteValue();
624 return new FieldLiteral(new Integer ( (int) (operand * s11)),
625 INTEGER);
626 case SHORT:
627 case SMALLINT:
628 short s1 = ( (Short ) result2).shortValue();
629 return new FieldLiteral(new Integer ( (int) (operand * s1)),
630 INTEGER);
631 case INTEGER:
632 case INT:
633 int s2 = ( (Integer ) result2).intValue();
634 return new FieldLiteral(new Long ( (long) (operand * s2)), LONG);
635 case LONG:
636 case BIGINT:
637 long s3 = ( (Long ) result2).longValue();
638 return new FieldLiteral(new BigDecimal( (double) (operand * s3)),
639 BIGDECIMAL);
640 case BIGDECIMAL:
641 case DEC:
642 case DECIMAL:
643 case NUMERIC:
644 double b1 = ( (Short ) result1).doubleValue();
645 return new FieldLiteral( ( (BigDecimal) result2).multiply(new
646 BigDecimal(b1)), BIGDECIMAL);
647 case REAL:
648 float s4 = ( (Float ) result2).floatValue();
649 return new FieldLiteral(new Double ( (double) (operand * s4)),
650 DOUBLE);
651 case DOUBLE:
652 case FLOAT:
653 case DOUBLEPRECISION:
654 double s5 = ( (Double ) result2).doubleValue();
655 return new FieldLiteral(new BigDecimal(operand * s5), BIGDECIMAL);
656 case CHARACTER:
657 case VARCHAR:
658 case CHAR:
659 case CHARACTERVARYING:
660 throw new DException("DSE87", new Object [] {"CHARACTER", "SHORT"});
661 case DATE:
662 case TIME:
663 case TIMESTAMP:
664 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
665 "SORT"});
666 }
667 break;
668 case INTEGER:
669 case INT:
670 int operand1 = ( (Integer ) result1).intValue();
671 switch (type2) {
672 case BYTE:
673 case TINYINT:
674 byte s11 = ( (Byte ) result2).byteValue();
675 return new FieldLiteral(new Long ( (operand1 * s11)), LONG);
676 case SHORT:
677 case SMALLINT:
678 short s6 = ( (Short ) result2).shortValue();
679 return new FieldLiteral(new Long ( (long) operand1 * s6), LONG);
680 case INTEGER:
681 case INT:
682 int operand2 = ( (Integer ) result2).intValue();
683 return new FieldLiteral(new Long ( (long) operand1 * operand2),
684 LONG);
685 case LONG:
686 case BIGINT:
687 long operand3 = ( (Long ) result2).longValue();
688 return new FieldLiteral(new Double ( (double) operand1 * operand3),
689 DOUBLE);
690 case BIGDECIMAL:
691 case DEC:
692 case DECIMAL:
693 case NUMERIC:
694 double b2 = ( (Integer ) result1).doubleValue();
695 return new FieldLiteral( ( (BigDecimal) result2).multiply(new
696 BigDecimal(b2)), BIGDECIMAL);
697 case REAL:
698 float operand4 = ( (Float ) result2).floatValue();
699 return new FieldLiteral(new Double (operand1 * operand4), DOUBLE);
700 case DOUBLE:
701 case FLOAT:
702 case DOUBLEPRECISION:
703 double operand5 = ( (Double ) result2).doubleValue();
704 return new FieldLiteral(new BigDecimal(operand1 * operand5),
705 BIGDECIMAL);
706 case CHARACTER:
707 case VARCHAR:
708 case CHAR:
709 case CHARACTERVARYING:
710 throw new DException("DSE87", new Object [] {"CHARACTER", "INT"});
711 case DATE:
712 case TIME:
713 case TIMESTAMP:
714 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
715 "INT"});
716 }
717 break;
718 case LONG:
719 case BIGINT:
720 long operand11 = ( (Long ) result1).longValue();
721 switch (type2) {
722 case BYTE:
723 case TINYINT:
724 byte s11 = ( (Byte ) result2).byteValue();
725 return new FieldLiteral(new BigDecimal("" + (operand11 * s11)),
726 BIGDECIMAL);
727 case SHORT:
728 case SMALLINT:
729 short s7 = ( (Short ) result2).shortValue();
730 return new FieldLiteral(new Double ( (double) operand11 * s7),
731 DOUBLE);
732 case INTEGER:
733 case INT:
734 int operand6 = ( (Integer ) result2).intValue();
735 return new FieldLiteral(new Double ( (double) operand11 * operand6),
736 DOUBLE);
737 case LONG:
738 case BIGINT:
739 long operand7 = ( (Long ) result2).longValue();
740 return new FieldLiteral(new Double ( (double) operand11 * operand7),
741 DOUBLE);
742 case BIGDECIMAL:
743 case DEC:
744 case DECIMAL:
745 case NUMERIC:
746 double b3 = ( (Long ) result1).doubleValue();
747 return new FieldLiteral( ( (BigDecimal) result2).multiply(new
748 BigDecimal(b3)), BIGDECIMAL);
749 case REAL:
750 float operand8 = ( (Float ) result2).floatValue();
751 return new FieldLiteral(new Double ( (double) operand11 * operand8),
752 DOUBLE);
753 case DOUBLE:
754 case FLOAT:
755 case DOUBLEPRECISION:
756 double operand9 = ( (Double ) result2).doubleValue();
757 return new FieldLiteral(new BigDecimal(operand11 * operand9),
758 BIGDECIMAL);
759 case CHARACTER:
760 case VARCHAR:
761 case CHAR:
762 case CHARACTERVARYING:
763 throw new DException("DSE87", new Object [] {"CHARACTER", "LONG"});
764 case DATE:
765 case TIME:
766 case TIMESTAMP:
767 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
768 "LONG"});
769 }
770 break;
771 case BIGDECIMAL:
772 case DEC:
773 case DECIMAL:
774 case NUMERIC:
775 switch (type2) {
776 case SHORT:
777 case SMALLINT:
778 double d1 = ( (Number ) result2).doubleValue();
779 return new FieldLiteral( ( (BigDecimal) result1).multiply(new
780 BigDecimal(d1)), BIGDECIMAL);
781 case BYTE:
782 case TINYINT:
783 double s11 = ( (Byte ) result2).doubleValue();
784 return new FieldLiteral( ( (BigDecimal) result1).multiply(new
785 BigDecimal(s11)), BIGDECIMAL);
786 case INTEGER:
787 case INT:
788 double s12 = ( (Integer ) result2).doubleValue();
789 return new FieldLiteral( ( (BigDecimal) result1).multiply(new
790 BigDecimal(s12)), BIGDECIMAL);
791 case DOUBLE:
792 case FLOAT:
793 case DOUBLEPRECISION:
794 double s13 = 0.0;
795 try {
796 s13 = ( (Double ) result2).doubleValue();
797 }
798 catch (ClassCastException ex) {
799 throw ex;
800 }
801 return new FieldLiteral( ( (BigDecimal) result1).multiply(new
802 BigDecimal(s13)), BIGDECIMAL);
803 case REAL:
804 double s14 = ( (Float ) result2).doubleValue();
805 return new FieldLiteral( ( (BigDecimal) result1).multiply(new
806 BigDecimal(s14)), BIGDECIMAL);
807 case LONG:
808 case BIGINT:
809 double s15 = ( (Long ) result2).doubleValue();
810 return new FieldLiteral( ( (BigDecimal) result1).multiply(new
811 BigDecimal(s15)), BIGDECIMAL);
812 case BIGDECIMAL:
813 case DEC:
814 case DECIMAL:
815 case NUMERIC:
816 return new FieldLiteral( ( (BigDecimal) result1).multiply( (
817 BigDecimal) result2), BIGDECIMAL);
818 case CHARACTER:
819 case VARCHAR:
820 case CHAR:
821 case CHARACTERVARYING:
822 throw new DException("DSE87", new Object [] {"CHARACTER",
823 "BIGDECIMAL"});
824 case DATE:
825 case TIME:
826 case TIMESTAMP:
827 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
828 "BIGDECIMAL"});
829 }
830 break;
831 case REAL:
832 float operand111 = ( (Float ) result1).floatValue();
833 switch (type2) {
834 case SHORT:
835 case SMALLINT:
836 short s8 = ( (Short ) result2).shortValue();
837 return new FieldLiteral(new Double ( (double) operand111 * s8),
838 DOUBLE);
839 case BYTE:
840 case TINYINT:
841 byte s11 = ( (Byte ) result2).byteValue();
842 return new FieldLiteral(new Double ( (double) operand111 * s11),
843 DOUBLE);
844 case INTEGER:
845 case INT:
846 int operand12 = ( (Integer ) result2).intValue();
847 return new FieldLiteral(new Double (operand111 * operand12),
848 DOUBLE);
849 case LONG:
850 case BIGINT:
851 long operand13 = ( (Long ) result2).longValue();
852 return new FieldLiteral(new Double (operand111 * operand13),
853 DOUBLE);
854 case BIGDECIMAL:
855 case DEC:
856 case DECIMAL:
857 case NUMERIC:
858 double b4 = ( (Float ) result1).doubleValue();
859 return new FieldLiteral( ( (BigDecimal) result2).multiply(new
860 BigDecimal(b4)), BIGDECIMAL);
861 case REAL:
862 float operand14 = ( (Float ) result2).floatValue();
863 return new FieldLiteral(new Double (operand111 * operand14),
864 DOUBLE);
865 case DOUBLE:
866 case FLOAT:
867 case DOUBLEPRECISION:
868 double operand15 = ( (Double ) result2).doubleValue();
869 return new FieldLiteral(new BigDecimal(operand111 * operand15),
870 BIGDECIMAL);
871 case CHARACTER:
872 case VARCHAR:
873 case CHAR:
874 case CHARACTERVARYING:
875 throw new DException("DSE87", new Object [] {"CHARACTER", "FLOAT"});
876 case DATE:
877 case TIME:
878 case TIMESTAMP:
879 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
880 "FLOAT"});
881 }
882 break;
883 case DOUBLE:
884 case FLOAT:
885 case DOUBLEPRECISION:
886 double operand1111 = ( (Double ) result1).doubleValue();
887 switch (type2) {
888 case SHORT:
889 case SMALLINT:
890 short s9 = ( (Short ) result2).shortValue();
891 return new FieldLiteral(new BigDecimal(operand1111 * s9),
892 BIGDECIMAL);
893 case BYTE:
894 case TINYINT:
895 byte s11 = ( (Byte ) result2).byteValue();
896 return new FieldLiteral(new BigDecimal(operand1111 * s11),
897 BIGDECIMAL);
898 case INTEGER:
899 case INT:
900 int operand16 = ( (Integer ) result2).intValue();
901 return new FieldLiteral(new BigDecimal(operand1111 * operand16),
902 BIGDECIMAL);
903 case LONG:
904 case BIGINT:
905 long operand17 = ( (Long ) result2).longValue();
906 return new FieldLiteral(new BigDecimal(operand1111 * operand17),
907 BIGDECIMAL);
908 case BIGDECIMAL:
909 case DEC:
910 case DECIMAL:
911 case NUMERIC:
912 double b5 = ( (Double ) result1).doubleValue();
913 return new FieldLiteral( ( (BigDecimal) result2).multiply(new
914 BigDecimal(b5)), BIGDECIMAL);
915 case REAL:
916 float operand18 = ( (Float ) result2).floatValue();
917 return new FieldLiteral(new BigDecimal(operand1111 * operand18),
918 BIGDECIMAL);
919 case DOUBLE:
920 case FLOAT:
921 case DOUBLEPRECISION:
922 double operand19 = ( (Double ) result2).doubleValue();
923 return new FieldLiteral(new BigDecimal(operand1111 * operand19),
924 BIGDECIMAL);
925 case CHARACTER:
926 case VARCHAR:
927 case CHAR:
928 case CHARACTERVARYING:
929 throw new DException("DSE87", new Object [] {"CHARACTER", "DOUBLE"});
930 case DATE:
931 case TIME:
932 case TIMESTAMP:
933 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
934 "DOUBLE"});
935 }
936 break;
937 case CHARACTER:
938 case VARCHAR:
939 case CHAR:
940 case CHARACTERVARYING:
941 switch (type2) {
942 case SHORT:
943 case SMALLINT:
944 throw new DException("DSE87", new Object [] {"CHARACTER", "SHORT"});
945 case INTEGER:
946 case INT:
947 throw new DException("DSE87", new Object [] {"CHARACTER", "INT"});
948 case LONG:
949 case BIGINT:
950 throw new DException("DSE87", new Object [] {"CHARACTER", "LONG"});
951 case BIGDECIMAL:
952 case DEC:
953 case DECIMAL:
954 case NUMERIC:
955 throw new DException("DSE87", new Object [] {"CHARACTER",
956 "BIGDECIMAL"});
957 case REAL:
958 throw new DException("DSE87", new Object [] {"CHARACTER", "FLOAT"});
959 case DOUBLE:
960 case FLOAT:
961 case DOUBLEPRECISION:
962 throw new DException("DSE87", new Object [] {"CHARACTER", "DOUBLE"});
963 case DATE:
964 case TIME:
965 case TIMESTAMP:
966 throw new DException("DSE87", new Object [] {"CHARACTER",
967 "DATE/TIME/TIMESTAMP"});
968
969 }
970 break;
971 case DATE:
972 case TIME:
973 case TIMESTAMP:
974 switch (type2) {
975 case SHORT:
976 case SMALLINT:
977 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
978 "SHORT"});
979 case INTEGER:
980 case INT:
981 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
982 "INT"});
983 case LONG:
984 case BIGINT:
985 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
986 "LONG"});
987 case BIGDECIMAL:
988 case DEC:
989 case DECIMAL:
990 case NUMERIC:
991 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
992 "BIGDECIMAL"});
993 case REAL:
994 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
995 "FLOAT"});
996 case DOUBLE:
997 case FLOAT:
998 case DOUBLEPRECISION:
999 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
1000 "DOUBLE"});
1001 case DATE:
1002 case TIME:
1003 case TIMESTAMP:
1004 throw new DException("DSE87", new Object [] {"DATE/TIME/TIMESTAMP",
1005 "DATE/TIME/TIMESTAMP"});
1006 }
1007 }
1008 }
1009 catch (ArithmeticException ae) {
1010 throw new DException("DSE334", new Object [] {"divide by zero"});
1011 }
1012 catch (NumberFormatException ex) {
1013 throw new DException("DSE334", null);
1014 }
1015
1016 throw new DException("DSE35",
1017 new Object [] {StaticClass.getDataTypeName(type1),
1018 StaticClass.getDataTypeName(type2)});
1019 }
1020
1021 public int getDataType(Object object) throws DException {
1022 return super.getDataType(object, "MULTIPLY");
1023 }
1024
1025 public AbstractRowValueExpression[] getChilds() {
1026 AbstractRowValueExpression[] childs = new AbstractRowValueExpression[] {
1027 (AbstractRowValueExpression) _term2,
1028 (AbstractRowValueExpression) _factor0};
1029 return childs;
1030 }
1031
1032 public int getCardinality() throws DException {
1033 if (_term2.getCardinality() > 1 || _factor0.getCardinality() > 1) {
1034 throw new DException("DSE213", null);
1035 }
1036 return 1;
1037 }
1038
1039
1056 public String toString() {
1057 StringBuffer sb = new StringBuffer ();
1058 sb.append(" ");
1059 sb.append(_term2);
1060 sb.append(" ");
1061 sb.append(_Sasterisk_3446232461);
1062 sb.append(" ");
1063 sb.append(_factor0);
1064 return sb.toString();
1065 }
1066
1067 public Object clone() throws CloneNotSupportedException {
1068 termSasterisk_344623246factor tempClass = new termSasterisk_344623246factor();
1069 tempClass._factor0 = (factor) _factor0.clone();
1070 tempClass._Sasterisk_3446232461 = (Sasterisk_344623246)
1071 _Sasterisk_3446232461.clone();
1072 tempClass._term2 = (term) _term2.clone();
1073 return tempClass;
1074 }
1075
1076 public ColumnDetails[] getColumnDetails() throws DException {
1077 if (columnDetails == null) {
1078 ColumnDetails firstlistOfColumns[] = _term2.getColumnDetails();
1079 ColumnDetails secondlistOfColumns[] = _factor0.getColumnDetails();
1080 int length = firstlistOfColumns.length + secondlistOfColumns.length;
1081 columnDetails = new ColumnDetails[length];
1082 int index = 0;
1083 for (; index < firstlistOfColumns.length; ++index) {
1084 columnDetails[index] = firstlistOfColumns[index];
1085 }
1086 for (int i = 0; i < secondlistOfColumns.length; ++i, ++index) {
1087 columnDetails[index] = secondlistOfColumns[i];
1088 }
1089 }
1090
1091 if (columnDetails.length == 1)
1092 return columnDetails;
1093
1094 ColumnDetails columnDetail = new ColumnDetails();
1095 String str = toString();
1096 columnDetail.setColumn(new String [] {str});
1097 columnDetail.setType(FUNCTIONAL);
1098 columnDetail.setObject(this);
1099 columnDetail.setExpression(str);
1100 return new ColumnDetails[] {
1101 columnDetail};
1102 }
1103
1104 public ColumnDetails[] getChildColumnDetails() throws DException {
1105 return columnDetails;
1106 }
1107
1108 public ByteComparison getByteComparison(Object object) throws DException {
1109 initializeChildren();
1110
1111 return new ByteComparison(false,
1112 new int[] {dtType});
1113 }
1114
1115
1116 public ParameterInfo[] getParameterInfo() throws DException {
1117 ParameterInfo[] parameterInfo = super.getParameterInfo();
1118 for (int i = 0; i < parameterInfo.length; i++) {
1119 if (parameterInfo[i].getQuestionMark()) {
1120 parameterInfo[i].setDataType(Datatypes.BIGDECIMAL);
1121 }
1122 }
1123 return parameterInfo;
1124 }
1125
1126}
1127 |
Popular Tags |
Java API By Example, From Geeks To Geeks.