|
1 package com.daffodilwoods.daffodildb.server.sql99.expression.expressionprimary;
2
3 import java.math.*;
4 import java.util.*;
5
6 import com.daffodilwoods.daffodildb.server.sql99.common.*;
7 import com.daffodilwoods.daffodildb.server.sql99.expression.*;
8 import com.daffodilwoods.daffodildb.server.sql99.expression.booleanvalueexpression.predicates.*;
9 import com.daffodilwoods.daffodildb.server.sql99.expression.rowvalueexpression.*;
10 import com.daffodilwoods.daffodildb.server.sql99.token.*;
11 import com.daffodilwoods.daffodildb.server.sql99.utils.*;
12 import com.daffodilwoods.daffodildb.utils.*;
13 import com.daffodilwoods.daffodildb.utils.comparator.*;
14 import com.daffodilwoods.daffodildb.utils.field.*;
15 import com.daffodilwoods.database.resource.*;
16
17 public class simplecase extends AbstractValueExpression implements casespecification, Datatypes, _sortspecificationAndselectSubList, TypeConstants {
18 public SRESERVEDWORD1206543922 _SRESERVEDWORD12065439220;
19 public elseclause _Optelseclause1;
20 public simplewhenclause[] _Repsimplewhenclause2;
21 public caseoperand _caseoperand3;
22 public SRESERVEDWORD1206543922 _SRESERVEDWORD12065439224;
23 private int datatype = -1;
24 private int datatype1 = -1;
25 private int[] datatype2;
26 private int datatype3 = -1;
27 private int size = -1;
28 private int size1 = -1;
29 private int[] size2;
30 private int size3 = -1;
31 public Object  run(Object object) throws com.daffodilwoods.database.resource.DException {
32 if (datatype == -1) {
33 datatype = getAppropriateDatatype(object);
34 size = getAppropriateSize(object);
35 }
36 Object oper1 = _caseoperand3.run(object);
37 int type1 = getDataTypeForByte(_caseoperand3.getByteComparison(object));
38 isDatatypeCompatible(type1, object);
39 FieldBase result;
40 int index = getIndexOfWhenClauseSatisfyingCondition(oper1, object);
41 if (index != -1) {
42 result = (FieldBase) _Repsimplewhenclause2[index].run(object);
43 return result.isNull() ? result : FieldUtility.convertToAppropriateType(result,
44 datatype,size,result.getCollator());
45 }
46 if (_Optelseclause1 != null) {
47 result = (FieldBase) _Optelseclause1.run(object);
48 return result.isNull() ? result : FieldUtility.convertToAppropriateType(result,
49 datatype,size,result.getCollator());
50 }
51 return new FieldLiteral(FieldUtility.NULLBUFFERRANGE, datatype);
52 }
53
54 public void isDatatypeCompatible(int caseOperandType, Object object) throws DException {
55 for (int i = 0; i < _Repsimplewhenclause2.length; i++) {
56 _Repsimplewhenclause2[i].isDatatypeCompatible(caseOperandType, object);
57 }
58 }
59
60 private ColumnDetails column;
61
62 public ParameterInfo[] getParameterInfo() throws DException {
63 ArrayList list = new ArrayList();
64 for (int i = 0; i < _Repsimplewhenclause2.length; ++i) {
65 ParameterInfo[] temp = _Repsimplewhenclause2[i].getParameterInfo();
66 if (temp != null) {
67 list.addAll(Arrays.asList(temp));
68 }
69 }
70 return (ParameterInfo[]) list.toArray(new ParameterInfo[list.size()]);
71 }
72
73 public AbstractRowValueExpression[] getChilds() {
74 int length = _Repsimplewhenclause2.length;
75 AbstractRowValueExpression[] childs = new AbstractRowValueExpression[length];
76 for (int i = 0; i < length; ++i) {
77 childs[i] = (AbstractRowValueExpression) _Repsimplewhenclause2[i];
78 }
79 return childs;
80 }
81
82 public ColumnDetails[] getColumnDetails() throws DException {
83 ColumnDetails[] columnDetails1;
84 ColumnDetails[][] details = new ColumnDetails[_Repsimplewhenclause2.length][];
85 int length = 0;
86 for (int i = 0; i < _Repsimplewhenclause2.length; i++) {
87 details[i] = _Repsimplewhenclause2[i] == null ? new ColumnDetails[0] : _Repsimplewhenclause2[i].getColumnDetails();
88 length += details[i].length;
89 }
90 columnDetails1 = new ColumnDetails[length];
91 int index = 0;
92 for (int i = 0; i < details.length; i++) {
93 ColumnDetails[] cds = (ColumnDetails[]) details[i];
94 for (int j = 0; j < cds.length; j++) {
95 columnDetails1[index++] = cds[j];
96 }
97 }
98 ColumnDetails[] columnDetails2 = null;
99 if (_Optelseclause1 != null) {
100 columnDetails2 = _Optelseclause1.getColumnDetails();
101 }
102 column = new ColumnDetails();
103 column.setColumn(new String [] {toString()});
104 column.setType(CASEEXPRESSION);
105 column.setObject(this);
106 this.columnDetails = columnDetails2 != null ? StaticClass.mergeColumnDetails(columnDetails1, columnDetails2) : columnDetails1;
107 columnDetails = StaticClass.mergeColumnDetails(_caseoperand3.getColumnDetails(), columnDetails);
108
109 for (int i = 0, len = _Repsimplewhenclause2.length; i < len; i++) {
110 _Repsimplewhenclause2[i].comparator = new CPckfduDpnqbsbups(true);
111 }
112 return new ColumnDetails[] {column};
113 }
114
115 private int getAppropriateDatatype(Object object) throws DException {
116 int max = -1;
117 datatype1 = _caseoperand3.getByteComparison(object).getDataTypes()[0];
118 int length = _Repsimplewhenclause2.length;
119 datatype2 = new int[length];
120 for (int i = 0; i < length; i++) {
121 try {
122 datatype2[i] = _Repsimplewhenclause2[i].getByteComparison(object).
123 getDataTypes()[0];
124 } catch (NullPointerException ex) {
125 throw ex;
126 }
127 max = datatype2[i] > max ? datatype2[i] : max;
128
129 }
130 if (_Optelseclause1 != null) {
131 datatype3 = _Optelseclause1.getByteComparison(object).getDataTypes()[0];
132 size = ( (max == CHAR || max == CHARACTER) && (datatype3 == CHAR || max == CHARACTER )) ? 255 : -1 ;
133 max = datatype3 > max ? datatype3 : max;
134 }
135 return max;
136 }
137
138
139
140 public com.daffodilwoods.daffodildb.server.sql99.utils._Reference[] checkSemantic(com.daffodilwoods.daffodildb.server.serversystem._ServerSession parent) throws DException {
141 _Reference[] ref = _caseoperand3.checkSemantic(parent);
142 int length = _Repsimplewhenclause2.length;
143 for (int i = 0; i < length; i++) {
144 ref = GeneralPurposeStaticClass.getJointReferences(ref, _Repsimplewhenclause2[i].checkSemantic(parent));
145 }
146 if (_Optelseclause1 != null) {
147 ref = GeneralPurposeStaticClass.getJointReferences(ref, _Optelseclause1.checkSemantic(parent));
148 }
149 getAppropriateDatatype(parent); Check.checkForDatatype(datatype1, _Repsimplewhenclause2[0].getByteComparisonForWhenOperand(parent).getDataTypes()[0]);
151 for (int i = 1; i < length; i++) {
152 Check.checkForDatatype(datatype2[0], datatype2[i]);
153 Check.checkForDatatype(datatype1, _Repsimplewhenclause2[i].getByteComparisonForWhenOperand(parent).getDataTypes()[0]);
154 }
155 if (_Optelseclause1 != null) {
156 Check.checkForDatatype(datatype2[0], datatype3);
157 }
158 return ref;
159 }
160
161 private FieldBase getResult(FieldBase fBase) throws DException {
162 Object object = fBase.getObject();
163 switch(datatype){
164 case BYTE : case TINYINT :
165 return new FieldLiteral( new Byte ("" + object) , BYTE);
166 case SHORT : case SMALLINT :
167 return new FieldLiteral( new Short ("" + object ) , SHORT);
168 case INTEGER : case INT :
169 return new FieldLiteral( new Integer ("" + object ) , INTEGER);
170 case LONG : case BIGINT :
171 return new FieldLiteral( new Long ("" + object) , LONG);
172 case REAL :
173 return new FieldLiteral( new Float ("" + object ) , REAL);
174 case DOUBLE : case FLOAT : case DOUBLEPRECISION :
175 return new FieldLiteral( new Double ("" + object ) , DOUBLE);
176 case BIGDECIMAL : case DEC : case DECIMAL : case NUMERIC :
177 return new FieldLiteral( new BigDecimal("" + object ) , BIGDECIMAL);
178 case CHARACTER :case VARCHAR: case CHAR: case CHARACTERVARYING:
179 return new FieldStringLiteral( object.toString() , CHARACTER ) ;
180 default :
181 throw new DException("DSE514",new Object []{new Integer (datatype)});
182 }
183 }
184
185 public String toString() {
186 StringBuffer sb = new StringBuffer ();
187 sb.append(" ");
188 sb.append(_SRESERVEDWORD12065439224);
189 sb.append(" ");
190 sb.append(_caseoperand3);
191 sb.append(" ");
192 for (int i = 0; i < _Repsimplewhenclause2.length; i++) {
193 sb.append(_Repsimplewhenclause2[i]);
194 }
195 sb.append(" ");
196 if (_Optelseclause1 != null) {
197 sb.append(_Optelseclause1);
198 }
199 sb.append(" ");
200 sb.append(_SRESERVEDWORD12065439220);
201 return sb.toString();
202 }
203
204 public Object clone() throws CloneNotSupportedException {
205 simplecase tempClass = new simplecase();
206 tempClass._SRESERVEDWORD12065439220 = (SRESERVEDWORD1206543922) _SRESERVEDWORD12065439220.clone();
207 if (_Optelseclause1 != null) {
208 tempClass._Optelseclause1 = (elseclause) _Optelseclause1.clone();
209 }
210 simplewhenclause[] temp_Repsimplewhenclause2 = new simplewhenclause[_Repsimplewhenclause2.length];
211 for (int i = 0; i < _Repsimplewhenclause2.length; i++) {
212 temp_Repsimplewhenclause2[i] = (simplewhenclause) _Repsimplewhenclause2[i].clone();
213 }
214 tempClass._Repsimplewhenclause2 = temp_Repsimplewhenclause2;
215 tempClass._caseoperand3 = (caseoperand) _caseoperand3.clone();
216 tempClass._SRESERVEDWORD12065439224 = (SRESERVEDWORD1206543922) _SRESERVEDWORD12065439224.clone();
217 return tempClass;
218 }
219
220 private int getIndexOfWhenClauseSatisfyingCondition(Object oper1, Object object) throws DException {
221 for (int i = 0; i < _Repsimplewhenclause2.length; i++) {
222 if (_Repsimplewhenclause2[i].isWhenOperandSatisfiesCaseOperand(oper1, object) == 0) {
223 return i;
224 }
225 }
226 return -1;
227
228 }
229
230 public ByteComparison getByteComparison(Object object) throws DException {
231 ByteComparison bc = new ByteComparison(false, new int[] {getAppropriateDatatype(object)});
232 bc.setSize(getAppropriateSize(object));
233 return bc;
234 }
235
236 public ColumnDetails[] getChildColumnDetails() throws DException {
237 return columnDetails;
238 }
239
240 private int getAppropriateSize(Object object) throws DException {
241 int max = -1;
242 size1 = _caseoperand3.getByteComparison(object).getSize();
243 int length = _Repsimplewhenclause2.length;
244 size2 = new int[length];
245 for (int i = 0; i < length; i++) {
246 try {
247 size2[i] = _Repsimplewhenclause2[i].getByteComparison(object).
248 getSize();
249 } catch (NullPointerException ex) {
250 throw ex;
251 }
252 max = size2[i] > max ? size2[i] : max;
253 max = size1 > max ? size1 : max;
254 }
255 if (_Optelseclause1 != null) {
256 size3 = _Optelseclause1.getByteComparison(object).getSize();
257 max = size3 > max ? size3 : max;
258 }
259 if (datatype == DEC || datatype == NUMERIC || datatype == DECIMAL ||
260 datatype == BIGDECIMAL) {
261 size = 38;
262 }
263 return max > size ? max : size ;
264 }
265 }
266 |
Popular Tags |
Java API By Example, From Geeks To Geeks.