|
1 package com.daffodilwoods.daffodildb.server.sql99.expression.expressionprimary;
2 import com.daffodilwoods.database.resource.*;
3 import com.daffodilwoods.daffodildb.server.sql99.token.*;
4 import com.daffodilwoods.daffodildb.server.sql99.common.ColumnDetails;
5 import com.daffodilwoods.daffodildb.server.sql99.common.ParameterInfo;
6 import com.daffodilwoods.daffodildb.server.sql99.utils._Reference;
7 import com.daffodilwoods.daffodildb.server.serversystem._ServerSession;
8 import com.daffodilwoods.daffodildb.server.sql99.utils.ByteComparison;
9 import com.daffodilwoods.daffodildb.server.sql99.expression.*;
10 import com.daffodilwoods.daffodildb.utils.field.*;
11 import com.daffodilwoods.daffodildb.server.sql99.common.*;
12 import com.daffodilwoods.daffodildb.server.sql99.expression.rowvalueexpression.
13 AbstractRowValueExpression;
14 import com.daffodilwoods.daffodildb.utils.*;
15 import java.math.*;
16 import java.sql.*;
17 import java.sql.Date  ;
18 import java.util.*;
19 import com.daffodilwoods.database.utility.*;
20
21 public class decodefunction extends AbstractGeneralFunction implements com.daffodilwoods.daffodildb.utils.parser.StatementExecuter ,generalvaluespecification {
22
23 public Srightparen_1874859514 _Srightparen_18748595140 ;
24 public valueexpression _OptScomma94843605valueexpression1 ;
25 public decodesearchrule[] _OptRepScomma94843605decodesearchrule2 ;
26 public decodesearchrule _decodesearchrule3 ;
27 public Scomma94843605 _Scomma948436054 ;
28 public valueexpression _valueexpression5 ;
29 public Sleftparen653880241 _Sleftparen6538802416 ;
30 public SNONRESERVEDWORD136444255 _SNONRESERVEDWORD1364442557 ;
31
32
33
34
48
49 private int resultDataType = -1;
50
51
52 public Object run(Object object) throws DException{
53 if (resultDataType == -1) {
54 resultDataType = getAppropriateDatatype(object);
55 }
56 FieldBase expression = (FieldBase)_valueexpression5.run(object);
57 Object [] res = (Object [])_decodesearchrule3.run(object);
58 FieldBase search = (FieldBase)res[0];
59 FieldBase result = (FieldBase)res[1];
60 if (expression.isNull()) {
61 if (_OptScomma94843605valueexpression1 != null) {
62 return (FieldBase) _OptScomma94843605valueexpression1.run(object);
63 }
64 else
65 return FieldUtility.NULLFIELDBASE;
66 }
67 FieldBase resultToReturn = (FieldBase) getObject(expression,search,result,object);
68 Object ob =resultToReturn.getObject();
69 if(ob==null){
70 return FieldUtility.NULLFIELDBASE;
71 }
72 return getResult(ob,resultDataType);
73 }
74
75 protected Object getResult(Object object, int type ) throws DException {
76 switch (type) {
77 case BYTE:
78 case TINYINT:
79 return new FieldLiteral(new Byte ("" + object), BYTE);
80 case SHORT:
81 case SMALLINT:
82 return new FieldLiteral(new Short ("" + object), SHORT);
83 case INTEGER:
84 case INT:
85 return new FieldLiteral(new Integer ("" + object), INTEGER);
86 case LONG:
87 case BIGINT:
88 return new FieldLiteral(new Long ("" + object), LONG);
89 case REAL:
90 return new FieldLiteral(new Float ("" + object), FLOAT);
91 case DOUBLE:
92 case FLOAT:
93 case DOUBLEPRECISION:
94 return new FieldLiteral(new Double ("" + object), DOUBLE);
95 case BIGDECIMAL:
96 case DEC:
97 case DECIMAL:
98 case NUMERIC:
99 return new FieldLiteral(new BigDecimal("" + object), BIGDECIMAL);
100 case CHARACTER:
101 case VARCHAR:
102 case CHAR:
103 case CHARACTERVARYING:
104 return new FieldStringLiteral(object.toString(), CHARACTER);
105 case DATE:
106 return new FieldLiteral(Date.valueOf(object.toString()), DATE);
107 case TIME:
108 return new FieldLiteral(Time.valueOf(object.toString()), TIME);
109 case TIMESTAMP:
110 return new FieldLiteral(Timestamp.valueOf(object.toString()), TIMESTAMP);
111 default:
112 throw new DException("DSE514", new Object [] {StaticClass.getDataTypeName(type)});
113
114 }
115 }
116
117
118
119 public Object getObject(FieldBase expression, FieldBase search1,
120 FieldBase result1,Object object) throws DException {
121 int expDataType=-1,searchType=-1;
122 expDataType=getDataTypeForByte(_valueexpression5.getByteComparison(object));
123 searchType =getDataTypeForByte(_decodesearchrule3._valueexpression2.getByteComparison(object));
124 checkDatatype(expDataType, searchType);
125 if (GetByteComparator.objectComparator.compare(expression,search1)==0) {
126 return result1;
127 }
128 else if (_OptRepScomma94843605decodesearchrule2 != null) {
129 int len = _OptRepScomma94843605decodesearchrule2.length;
130 FieldBase search = null, result = null;
131 for (int i = 0; i < len; i++) {
132 searchType = getDataTypeForByte(_OptRepScomma94843605decodesearchrule2[i]._valueexpression2.getByteComparison(object));
133 checkDatatype(expDataType, searchType);
134 Object [] res1 = (Object []) _OptRepScomma94843605decodesearchrule2[i].run(object);
135 search = (FieldBase) res1[0];
136 result = (FieldBase) res1[1];
137 if (GetByteComparator.objectComparator.compare(expression,search)==0) {
138 return result;
139 }
140 }
141 }
142
143 if(_OptScomma94843605valueexpression1!=null) {
144 return (FieldBase)_OptScomma94843605valueexpression1.run(object);
145 }
146
147 return FieldUtility.NULLFIELDBASE;
148 }
149
150 private void checkDatatype(int expDataType, int searchType) throws DException{
151 try {
152 Check.checkForDatatype(expDataType, searchType);
153 }
154 catch (DException ex) {
155 if (ex.getDseCode().equalsIgnoreCase("DSE514") ||
156 ex.getDseCode().equalsIgnoreCase("DSE6001")) {
157 throw new DException("DSE8100", new Object [] {StaticClass.getDataTypeName(expDataType),
158 StaticClass.getDataTypeName(searchType)});
159 }
160 throw ex;
161 }
162 }
163
164
165 private boolean checkForVariableColumn() throws DException {
166 for (int i = 0; i < columnDetails.length; ++i) {
167 if (columnDetails[i].getColumn().equals("?")) {
168 return true;
169 }
170 }
171 return false;
172 }
173
174
175 private String getNameOfColumn(ColumnDetails[] columnDetails) throws DException {
176 String nameOfColumn = "";
177 for (int i = 0; i < columnDetails.length; ++i) {
178 nameOfColumn += columnDetails[i].getColumn();
179 }
180 return nameOfColumn;
181 }
182
183 private void syntaxCheckingForColumn(ColumnDetails[] columnDetails) throws DException {
184 if (columnDetails.length > 1) {
185 int i = 0;
186 for (; i < columnDetails.length; ++i) {
187 if (columnDetails[i].getType() == CONSTANT) {
188 break;
189 }
190 }
191 if (i == columnDetails.length) {
192 throw new DException("DSE526", null);
193 }
194 }
195 }
196
197 private ColumnDetails[] mergeColumnDetails(ColumnDetails[] columnDetails1, ColumnDetails[] columnDetails2) throws DException {
198 ColumnDetails[] objectTarget = new ColumnDetails[columnDetails1.length + columnDetails2.length];
199 int i = 0;
200 for (; i < columnDetails1.length; ++i) {
201 objectTarget[i] = columnDetails1[i];
202 }
203 for (int j = 0; j < columnDetails2.length; ++i, ++j) {
204 objectTarget[i] = columnDetails2[j];
205 }
206 return objectTarget;
207 }
208
209
210 public String toString() {
211 StringBuffer sb = new StringBuffer ();
212 sb.append(" ");
213 sb.append(_SNONRESERVEDWORD1364442557);
214 sb.append(" ");
215 sb.append(_Sleftparen6538802416);
216 sb.append(" ");
217 sb.append(_valueexpression5);
218 sb.append(" ");
219 sb.append(_Scomma948436054);
220 sb.append(" ");
221 sb.append(_decodesearchrule3);
222 sb.append(" ");
223 if(_OptRepScomma94843605decodesearchrule2 != null ) {
224 for(int i = 0 ; i < _OptRepScomma94843605decodesearchrule2.length ; i++ )
225 sb.append(",").append(_OptRepScomma94843605decodesearchrule2[i]);
226 }
227 sb.append(" ");
228 if(_OptScomma94843605valueexpression1 != null ) {
229 sb.append(",");
230 sb.append(_OptScomma94843605valueexpression1);
231 }
232 sb.append(" ");
233 sb.append(_Srightparen_18748595140);
234 return sb.toString();
235 }
236
237
242 public ParameterInfo[] getParameterInfo() throws DException{
243
274 return new ParameterInfo[0];
275 }
276
277
278
283 public _Reference[] checkSemantic(_ServerSession parent) throws DException {
284 _Reference[] ref = super.checkSemantic(parent);
285 getAppropriateDatatype(parent);
286 return ref;
287 }
288
289
290
295
296 public ByteComparison getByteComparison(Object object) throws DException{
297 int dt = resultDataType == -1 ? getAppropriateDatatype(object) : resultDataType;
298 ByteComparison byteComparison = new ByteComparison(false, new int[] {dt});
299 byteComparison.setSize(getColumnSize(object));
300 return byteComparison;
301 }
302
303
307
308 public ColumnDetails[] getChildColumnDetails() throws DException{
309 ArrayList list =new ArrayList();
310 list.addAll(Arrays.asList( _valueexpression5.getColumnDetails()));
311 list.addAll(Arrays.asList( _decodesearchrule3._valueexpression2.getColumnDetails()));
312 list.addAll(Arrays.asList( _decodesearchrule3._valueexpression0.getColumnDetails()));
313 if(_OptRepScomma94843605decodesearchrule2!=null) {
314 for (int i = 0; i < _OptRepScomma94843605decodesearchrule2.length; i++) {
315 list.addAll(Arrays.asList( _OptRepScomma94843605decodesearchrule2[i]._valueexpression2.getColumnDetails()));
316 list.addAll(Arrays.asList( _OptRepScomma94843605decodesearchrule2[i]._valueexpression0.getColumnDetails()));
317 }
318 }
319 if(_OptScomma94843605valueexpression1!=null) {
320 list.addAll(Arrays.asList( _OptScomma94843605valueexpression1.getColumnDetails()));
321 }
322 ColumnDetails[] cd =new ColumnDetails[list.size()];
323 list.toArray(cd);
324 return cd;
325 }
326
327
331 public Object clone() throws CloneNotSupportedException {
332 decodefunction tempClass = new decodefunction();
333 tempClass._Srightparen_18748595140 = (Srightparen_1874859514) _Srightparen_18748595140.clone();
334 if(_OptScomma94843605valueexpression1 != null ) {
335 tempClass._OptScomma94843605valueexpression1 = (valueexpression) _OptScomma94843605valueexpression1.clone();
336 }
337 if(_OptRepScomma94843605decodesearchrule2 != null ) {
338 for(int i = 0 ; i < _OptRepScomma94843605decodesearchrule2.length ; i++ )
339 tempClass._OptRepScomma94843605decodesearchrule2 =(decodesearchrule[])_OptRepScomma94843605decodesearchrule2[i].clone();
340 }
341 tempClass._decodesearchrule3 = (decodesearchrule) _decodesearchrule3.clone();
342 tempClass._valueexpression5 =(valueexpression)_valueexpression5.clone();
343 tempClass._Sleftparen6538802416 = (Sleftparen653880241) _Sleftparen6538802416.clone();
344 tempClass._SNONRESERVEDWORD1364442557 = (SNONRESERVEDWORD136444255) _SNONRESERVEDWORD1364442557.clone();
345 return tempClass;
346 }
347
348
349
355 private int getAppropriateDatatype(Object object) throws DException {
356 resultDataType = getDataTypeForByte(_decodesearchrule3._valueexpression0.getByteComparison(object));
357 if (_OptRepScomma94843605decodesearchrule2 != null) {
358 int len = _OptRepScomma94843605decodesearchrule2.length;
359 int[] resultType = new int[len];
360 for (int i = 0; i < len; i++) {
361 resultType[i] = getDataTypeForByte(
362 _OptRepScomma94843605decodesearchrule2[i]._valueexpression0.
363 getByteComparison(object));
364 }
365 for (int i = 0; i < resultType.length; i++) {
366 try {
367 Check.checkForDatatype(resultDataType, resultType[i]);
368 resultDataType = resultDataType > resultType[i] ? resultDataType :
369 resultType[i];
370 }
371 catch (DException ex) {
372 if (ex.getDseCode().equalsIgnoreCase("DSE514") ||
373 ex.getDseCode().equalsIgnoreCase("DSE6001")) {
374 throw new DException("DSE8100",
375 new Object [] {StaticClass.
376 getDataTypeName(resultDataType),
377 StaticClass.getDataTypeName(resultType[i])});
378 }
379 throw ex;
380 }
381 }
382 }
383 int defaultExpressionDataType = _OptScomma94843605valueexpression1 == null ? -1 :
384 getDataTypeForByte(_OptScomma94843605valueexpression1.getByteComparison(object));
385
386 resultDataType = resultDataType > defaultExpressionDataType ? resultDataType : defaultExpressionDataType;
387 return resultDataType ;
388 }
389
390
395 public AbstractRowValueExpression[] getChilds() {
396 ArrayList list = new ArrayList();
397 if (_OptRepScomma94843605decodesearchrule2 != null) {
398 if (_OptScomma94843605valueexpression1 != null) {
399 list.add( (AbstractRowValueExpression) (_valueexpression5));
400 list.add( (AbstractRowValueExpression) (_decodesearchrule3.
401 _valueexpression2));
402 list.add( (AbstractRowValueExpression) (_decodesearchrule3.
403 _valueexpression0));
404 for (int i = 0; i < _OptRepScomma94843605decodesearchrule2.length; i++) {
405 list.add( (AbstractRowValueExpression)( _OptRepScomma94843605decodesearchrule2[i]._valueexpression2));
406 list.add( (AbstractRowValueExpression)( _OptRepScomma94843605decodesearchrule2[i]._valueexpression0));
407 }
408 list.add( (AbstractRowValueExpression)
409 _OptScomma94843605valueexpression1);
410 }
411 else {
412 list.add( (AbstractRowValueExpression) (_valueexpression5));
413 list.add( (AbstractRowValueExpression) (_decodesearchrule3.
414 _valueexpression2));
415 list.add( (AbstractRowValueExpression) (_decodesearchrule3.
416 _valueexpression0));
417 for (int i = 0; i < _OptRepScomma94843605decodesearchrule2.length; i++) {
418 list.add( (AbstractRowValueExpression)( _OptRepScomma94843605decodesearchrule2[i]._valueexpression2));
419 list.add( (AbstractRowValueExpression)( _OptRepScomma94843605decodesearchrule2[i]._valueexpression0));
420 }
421 }
422 }
423 else {
424 if (_OptScomma94843605valueexpression1 != null) {
425 list.add( (AbstractRowValueExpression) (_valueexpression5));
426 list.add( (AbstractRowValueExpression) (_decodesearchrule3.
427 _valueexpression2));
428 list.add( (AbstractRowValueExpression) (_decodesearchrule3.
429 _valueexpression0));
430 list.add( (AbstractRowValueExpression)
431 _OptScomma94843605valueexpression1);
432
433 }
434 else {
435 list.add( (AbstractRowValueExpression) (_valueexpression5));
436 list.add( (AbstractRowValueExpression) (_decodesearchrule3.
437 _valueexpression2));
438 list.add( (AbstractRowValueExpression) (_decodesearchrule3.
439 _valueexpression0));
440 }
441 }
442 AbstractRowValueExpression[] child = new AbstractRowValueExpression[list.size()];
443 list.toArray(child);
444 return child;
445 }
446
447 int getColumnSize(Object object) throws DException {
448 ColumnDetails[] columnDetails = getChildColumnDetails();
449 int type =columnDetails[2].getType();
450 if(type!=TypeConstants.CONSTANT) {
451 int datatype = columnDetails[2].getDatatype();
452 switch (datatype) {
453 case BYTE:
454 case TINYINT:
455 case INTEGER:
456 case INT:
457 return INTSIZE;
458 case REAL:
459 return FLOATSIZE;
460 case DOUBLE:
461 case FLOAT:
462 case DOUBLEPRECISION:
463 return DOUBLESIZE;
464 case LONG:
465 case BIGINT:
466 return LONGSIZE;
467 case SHORT:
468 case SMALLINT:
469 return SHORTSIZE;
470 case BIGDECIMAL:
471 case DEC:
472 case DECIMAL:
473 case NUMERIC:
474 if (columnDetails[2].getSize() != -5) {
475 return columnDetails[2].getSize();
476 }
477 break;
478 case DATE :
479 return DATESIZE;
480 case TIME :
481 return TIMESIZE;
482 case TIMESTAMP :
483 return TIMESTAMPSIZE;
484 default :
485 if (columnDetails[0].getSize() != -5) {
486 return columnDetails[0].getSize();
487 }
488 }
489 } else if(columnDetails[2].getQuestion()) {
490 return 255;
491 } else {
492 Object [] res = (Object [])_decodesearchrule3.run(object);
493 FieldBase field = (FieldBase)res[1];
494 field.setDatatype(columnDetails[2].getDatatype());
495 return field.getLength();
496 }
497 return -1;
498 }
499
500
501 }
502 |
Popular Tags |
Java API By Example, From Geeks To Geeks.