Java > Open Source Codes > com > daffodilwoods > daffodildb > server > sql99 > expression > stringvalueexpression > concatfunction


1 package com.daffodilwoods.daffodildb.server.sql99.expression.
2     stringvalueexpression;
3
4 import com.daffodilwoods.daffodildb.server.sql99.common.*;
5 import com.daffodilwoods.daffodildb.server.sql99.expression.rowvalueexpression.*;
6 import com.daffodilwoods.daffodildb.server.sql99.token.*;
7 import com.daffodilwoods.daffodildb.server.sql99.utils.*;
8 import com.daffodilwoods.daffodildb.utils.*;
9 import com.daffodilwoods.daffodildb.utils.field.*;
10 import com.daffodilwoods.database.resource.*;
11 import java.util.ArrayList ;
12 import java.util.Arrays ;
13 import in.co.daffodil.db.jdbc.DatabaseProperties;
14 import com.daffodilwoods.daffodildb.server.serversystem._ServerSession;
15
16 public class concatfunction extends AbstractStringValueExpression implements charactervaluefunction {
17    public Srightparen_1874859514 _Srightparen_18748595140;
18    public charactervalueexpression _charactervalueexpression1;
19    public Scomma94843605 _Scomma948436052;
20    public charactervalueexpression _charactervalueexpression3;
21    public Sleftparen653880241 _Sleftparen6538802414;
22    public SNONRESERVEDWORD136444255 _SNONRESERVEDWORD1364442555;
23
24
25    public Object run(Object object) throws com.daffodilwoods.database.resource.
26        DException {
27       FieldBase result1 = (FieldBase) _charactervalueexpression3.run(object);
28       FieldBase result2 = (FieldBase) _charactervalueexpression1.run(object);
29       if (result1.isNull() && result2.isNull()) {
30          return new FieldStringLiteral(FieldUtility.NULLBUFFERRANGE, Datatypes.CHARACTER);
31       }
32       return result1.isNull() ? new FieldStringLiteral(result2.getObject().toString(), Datatypes.CHARACTER)
33           : result2.isNull() ? new FieldStringLiteral(result1.getObject().toString(), Datatypes.CHARACTER) :
34           new FieldStringLiteral(new StringBuffer (result1.getObject().toString()).append(result2.getObject().toString()).toString(), Datatypes.CHARACTER);
35    }
36
37    public ColumnDetails[] getChildColumnDetails() throws DException {
38       return columnDetails;
39    }
40
41    protected String getNameOfColumn(ColumnDetails[] columnDetails) throws
42        DException {
43       String nameOfColumn = "";
44       for (int i = 0; i < columnDetails.length; ++i) {
45          nameOfColumn += columnDetails[i].getColumn();
46       }
47       return nameOfColumn;
48    }
49
50    public ParameterInfo[] getParameterInfo() throws DException {
51       ArrayList list =new ArrayList ();
52       ParameterInfo[] param1 = _charactervalueexpression3.getParameterInfo();
53      for (int i = 0; i < param1.length; i++) {
54        if (param1[i].getQuestionMark()){
55            param1[i].setDataType(Datatypes.CHARACTER);
56            param1[i].setName("CONCAT Arg1");
57            list.addAll(Arrays.asList(param1));
58        }
59      }
60       ParameterInfo[] param2 = _charactervalueexpression1.getParameterInfo();
61     for (int i = 0; i < param2.length; i++) {
62       if (param2[i].getQuestionMark()) {
63         param2[i].setDataType(Datatypes.CHARACTER);
64         param2[i].setName("CONCAT Arg2");
65         list.addAll(Arrays.asList(param2));
66       }
67     }
68        ParameterInfo[] param =new ParameterInfo[list.size()];
69        list.toArray(param);
70        for (int i = 0; i < param.length; i++) {
71          if(param[i].getQuestionMark())
72            return param;
73        }
74        return getThisParameterInfo();
75
76    }
77
78    protected ParameterInfo[] getThisParameterInfo() throws DException {
79       ParameterInfo parameterInfo = new ParameterInfo();
80       parameterInfo.setName(toString());
81       parameterInfo.setDataType(columnDetails[0].getDatatype());
82       return new ParameterInfo[] {
83           parameterInfo};
84    }
85
86    /*private int getDataType(Object object) throws DException {
87      if (object instanceof Integer)
88        return INTEGER;
89      else if (object instanceof Float)
90        return FLOAT;
91      else if (object instanceof Double)
92        return DOUBLE;
93      else if (object instanceof Long)
94        return LONG;
95      else if (object instanceof String)
96        return CHARACTER;
97      else if (object instanceof Short)
98        return SHORT;
99      else if (object instanceof BigDecimal)
100        return BIGDECIMAL;
101      else if (object instanceof Byte)
102        return BYTE;
103      else if (object instanceof Character)
104        return CHARACTER;
105      else
106             throw new DException("DSE514",new Object[] {object});
107       }
108       private Object getResult(int type1, int type2, Object result1, Object result2) throws
109        DException {
110      GregorianCalendar gg = null;
111      switch (type1) {
112        case BYTE : case TINYINT :
113          switch (type2) {
114            case BYTE : case TINYINT :
115              return new FieldLiteral( new Byte( (byte) ( ( (Byte) result1).byteValue() +
116                  ( (Byte) result2).byteValue())),Datatype.BYTE);
117                case SHORT : case SMALLINT :
118                  short a1 = ( (Short) result2).shortValue();
119                  return new FieldLiteral( new Short( (short) ( ( (Byte) result1).shortValue() + a1)),Datatype.SHORT );
120                case INTEGER : case INT :
121                  int a2 = ( (Integer) result2).intValue();
122                  return new FieldLiteral( new Integer( ( (Byte) result1).intValue() + a2), Datatype.INTEGER);
123                case LONG : case BIGINT :
124                  long a3 = ( (Long) result2).longValue();
125                  return new FieldLiteral( new Long( ( (Byte) result1).longValue() + a3), Datatype.LONG);
126                case BIGDECIMAL : case DEC : case DECIMAL : case NUMERIC :
127                  return new FieldLiteral(( (BigDecimal) result2).add(new BigDecimal( ( (Byte) result1).
128                      doubleValue())),Datatype.BIGDECIMAL);
129                    case REAL:
130                      float a4 = ( (Float) result2).floatValue();
131                      return new FieldLiteral( new Float( ( (Byte) result1).floatValue() + a4),Datatype.FLOAT);
132                    case DOUBLE : case FLOAT : case DOUBLEPRECISION :
133                      double a5 = ( (Double) result2).doubleValue();
134                      return new FieldLiteral(new Double( ( (Byte) result1).doubleValue() + a5),Datatype.DOUBLE);
135            case DATE:
136              Date a6 = (Date) result2;
137              gg.setTime(a6);
138              gg.add(Calendar.DATE, ( (Byte) result1).intValue());
139              return new FieldLiteral(gg.getTime(),Datatype.DATE);
140            case CHARACTER :case VARCHAR: case CHAR: case CHARACTERVARYING:
141              throw new DException("DSE40", new Object[] {"CHARACTER", "BYTE"});
142          }
143        case SHORT : case SMALLINT :
144          short operand = ( (Short) result1).shortValue();
145          switch (type2) {
146            case BYTE : case TINYINT :
147              return new FieldLiteral( new Short( (short) ( ( (Byte) result2).shortValue() +
148                                         operand)),Datatype.SHORT);
149                                       case SHORT : case SMALLINT :
150              short s1 = ( (Short) result2).shortValue();
151              return new FieldLiteral( new Short( (short) (operand + s1)),Datatype.SHORT);
152            case INTEGER : case INT :
153              int s2 = ( (Integer) result2).intValue();
154              return new FieldLiteral(new Integer(operand + s2),Datatype.INTEGER);
155            case LONG : case BIGINT :
156              long s3 = ( (Long) result2).longValue();
157              return new FieldLiteral(new Long(operand + s3),Datatype.LONG);
158            case BIGDECIMAL : case DEC : case DECIMAL : case NUMERIC :
159              double b1 = ( (Short) result1).doubleValue();
160              return new FieldLiteral(( (BigDecimal) result2).add(new BigDecimal(b1)),Datatype.BIGDECIMAL);
161            case REAL:
162              float s4 = ( (Float) result2).floatValue();
163              return new FieldLiteral(new Float(operand + s4),Datatype.FLOAT);
164            case DOUBLE : case FLOAT : case DOUBLEPRECISION :
165              double s5 = ( (Double) result2).doubleValue();
166              return new FieldLiteral(new Double(operand + s5),Datatype.DOUBLE);
167            case DATE:
168              Date dd1 = (Date) result2;
169              gg.setTime(dd1);
170              gg.add(Calendar.DATE, (int) operand);
171              return new FieldLiteral(gg.getTime(),Datatype.DATE);
172            case CHARACTER :case VARCHAR: case CHAR: case CHARACTERVARYING:
173              StringBuffer result = new StringBuffer(result1.toString());
174              result.append(result2.toString());
175              return new FieldLiteral(result.toString(),Datatype.CHARACTER);
176          }
177        case INTEGER : case INT :
178          int operand1 = ( (Integer) result1).intValue();
179          switch (type2) {
180            case BYTE : case TINYINT :
181              return new FieldLiteral(new Integer( ( (Byte) result2).intValue() + operand1),Datatype.INTEGER);
182            case SHORT : case SMALLINT :
183              short s6 = ( (Short) result2).shortValue();
184              return new FieldLiteral(new Integer(operand1 + s6),Datatype.INTEGER);
185            case INTEGER : case INT :
186              int operand2 = ( (Integer) result2).intValue();
187              return new FieldLiteral(new Integer(operand1 + operand2),Datatype.INTEGER);
188            case LONG : case BIGINT :
189              long operand3 = ( (Long) result2).longValue();
190              return new FieldLiteral(new Long(operand1 + operand3),Datatype.LONG);
191            case BIGDECIMAL : case DEC : case DECIMAL : case NUMERIC :
192              double b2 = ( (Integer) result1).doubleValue();
193              return new FieldLiteral(( (BigDecimal) result2).add(new BigDecimal(b2)),Datatype.BIGDECIMAL);
194            case REAL:
195              float operand4 = ( (Float) result2).floatValue();
196              return new FieldLiteral(new Float(operand1 + operand4),Datatype.FLOAT);
197            case DOUBLE : case FLOAT : case DOUBLEPRECISION :
198              double operand5 = ( (Double) result2).doubleValue();
199              return new FieldLiteral(new Double(operand1 + operand5),Datatype.DOUBLE);
200            case DATE:
201              Date dd2 = (Date) result2;
202              gg.setTime(dd2);
203              gg.add(Calendar.DATE, (int) operand1);
204              return new FieldLiteral(gg.getTime(),Datatype.DATE);
205            case CHARACTER :case VARCHAR: case CHAR: case CHARACTERVARYING:
206              StringBuffer result = new StringBuffer(result1.toString());
207              result.append(result2.toString());
208              return new FieldLiteral(result.toString(),Datatype.CHARACTER);
209          }
210        case LONG : case BIGINT :
211          long operand11 = ( (Long) result1).longValue();
212          switch (type2) {
213            case BYTE : case TINYINT :
214              return new FieldLiteral(new Integer( (int) ( ( (Byte) result2).longValue() +
215                                         operand11)),Datatype.INTEGER);
216                                       case SHORT : case SMALLINT :
217              short s7 = ( (Short) result2).shortValue();
218              return new FieldLiteral(new Long(operand11 + s7),Datatype.LONG);
219            case INTEGER : case INT :
220              int operand6 = ( (Integer) result2).intValue();
221              return new FieldLiteral(new Long(operand11 + operand6),Datatype.LONG);
222            case LONG : case BIGINT :
223              long operand7 = ( (Long) result2).longValue();
224              return new FieldLiteral(new Long(operand11 + operand7),Datatype.LONG);
225            case BIGDECIMAL : case DEC : case DECIMAL : case NUMERIC :
226              double b3 = ( (Long) result1).doubleValue();
227              return new FieldLiteral(( (BigDecimal) result2).add(new BigDecimal(b3)),Datatype.BIGDECIMAL);
228            case REAL:
229              float operand8 = ( (Float) result2).floatValue();
230              return new FieldLiteral(new Float(operand11 + operand8),Datatype.FLOAT);
231            case DOUBLE : case FLOAT : case DOUBLEPRECISION :
232              double operand9 = ( (Double) result2).doubleValue();
233              return new FieldLiteral(new Double(operand11 + operand9),Datatype.DOUBLE);
234            case DATE:
235              Date dd3 = (Date) result2;
236              gg.setTime(dd3);
237              gg.add(Calendar.DATE, (int) operand11);
238              return new FieldLiteral(gg.getTime(),Datatype.DATE);
239            case CHARACTER :case VARCHAR: case CHAR: case CHARACTERVARYING:
240              StringBuffer result = new StringBuffer(result1.toString());
241              result.append(result2.toString());
242              return new FieldLiteral(result.toString(),Datatype.CHARACTER);
243          }
244        case BIGDECIMAL : case DEC : case DECIMAL : case NUMERIC :
245          switch (type2) {
246            case BYTE : case TINYINT :
247              return new FieldLiteral(( (BigDecimal) result1).add(new BigDecimal( ( (Byte) result2).
248                  doubleValue())),Datatype.BIGDECIMAL);
249                case SHORT : case SMALLINT :
250              double d1 = ( (Short) result2).doubleValue();
251              return new FieldLiteral(( (BigDecimal) result1).add(new BigDecimal(d1)),Datatype.BIGDECIMAL);
252            case INTEGER : case INT :
253              double d2 = ( (Integer) result2).doubleValue();
254              return new FieldLiteral(( (BigDecimal) result1).add(new BigDecimal(d2)),Datatype.BIGDECIMAL);
255            case LONG : case BIGINT :
256              double d3 = ( (Long) result2).doubleValue();
257              return new FieldLiteral(( (BigDecimal) result1).add(new BigDecimal(d3)),Datatype.BIGDECIMAL);
258            case BIGDECIMAL : case DEC : case DECIMAL : case NUMERIC :
259              return new FieldLiteral(( (BigDecimal) result1).add( (BigDecimal) result2),Datatype.BIGDECIMAL);
260            case REAL:
261              double d4 = ( (Float) result2).doubleValue();
262              return new FieldLiteral(( (BigDecimal) result1).add(new BigDecimal(d4)),Datatype.BIGDECIMAL);
263            case DOUBLE : case FLOAT : case DOUBLEPRECISION :
264              double d5 = ( (Double) result2).doubleValue();
265              return new FieldLiteral(( (BigDecimal) result1).add(new BigDecimal(d5)),Datatype.BIGDECIMAL);
266            case DATE:
267              Date dd3 = (Date) result2;
268              gg.setTime(dd3);
269              gg.add(Calendar.DATE, ( (BigDecimal) result1).intValue());
270              return new FieldLiteral(gg.getTime(),Datatype.DATE);
271            case CHARACTER :case VARCHAR: case CHAR: case CHARACTERVARYING:
272              StringBuffer result = new StringBuffer(result1.toString());
273              result.append(result2.toString());
274              return new FieldLiteral(result.toString(),Datatype.CHARACTER);
275          }
276        case REAL:
277          float operand111 = ( (Float) result1).floatValue();
278          switch (type2) {
279            case BYTE : case TINYINT :
280              return new FieldLiteral(new Float( ( (Byte) result2).floatValue() + operand111),Datatype.FLOAT);
281            case SHORT : case SMALLINT :
282              short s8 = ( (Short) result2).shortValue();
283              return new FieldLiteral(new Float(operand111 + s8),Datatype.FLOAT);
284            case INTEGER : case INT :
285              int operand12 = ( (Integer) result2).intValue();
286              return new FieldLiteral(new Float(operand111 + operand12),Datatype.FLOAT);
287            case LONG : case BIGINT :
288              long operand13 = ( (Long) result2).longValue();
289              return new FieldLiteral(new Float(operand111 + operand13),Datatype.FLOAT);
290            case BIGDECIMAL : case DEC : case DECIMAL : case NUMERIC :
291              double b4 = ( (Float) result1).doubleValue();
292              return new FieldLiteral(( (BigDecimal) result2).add(new BigDecimal(b4)),Datatype.BIGDECIMAL);
293            case REAL:
294              float operand14 = ( (Float) result2).floatValue();
295              return new FieldLiteral(new Float(operand111 + operand14),Datatype.FLOAT);
296            case DOUBLE : case FLOAT : case DOUBLEPRECISION :
297              double operand15 = ( (Double) result2).doubleValue();
298              return new FieldLiteral(new Double(operand111 + operand15),Datatype.DOUBLE);
299            case CHARACTER :case VARCHAR: case CHAR: case CHARACTERVARYING:
300              StringBuffer result = new StringBuffer(result1.toString());
301              result.append(result2.toString());
302              return new FieldLiteral(result.toString(),Datatype.CHARACTER);
303            case DATE:
304              Date dd4 = (Date) result2;
305              gg.setTime(dd4);
306              gg.add(Calendar.DATE, (int) operand111);
307              return new FieldLiteral(gg.getTime(),Datatype.DATE);
308          }
309        case DOUBLE : case FLOAT : case DOUBLEPRECISION :
310          double operand1111 = ( (Double) result1).doubleValue();
311          switch (type2) {
312            case BYTE : case TINYINT :
313              return new FieldLiteral(new Double( ( (Byte) result2).doubleValue() + operand1111),Datatype.DOUBLE);
314            case SHORT : case SMALLINT :
315              short s9 = ( (Short) result2).shortValue();
316              return new FieldLiteral(new Double(operand1111 + s9),Datatype.DOUBLE);
317            case INTEGER : case INT :
318              int operand16 = ( (Integer) result2).intValue();
319              return new FieldLiteral(new Double(operand1111 + operand16),Datatype.DOUBLE);
320            case LONG : case BIGINT :
321              long operand17 = ( (Long) result2).longValue();
322              return new FieldLiteral(new Double(operand1111 + operand17),Datatype.DOUBLE);
323            case BIGDECIMAL : case DEC : case DECIMAL : case NUMERIC :
324              double b5 = ( (Double) result1).doubleValue();
325              return new FieldLiteral(( (BigDecimal) result2).add(new BigDecimal(b5)),Datatype.BIGDECIMAL);
326            case REAL:
327              float operand18 = ( (Float) result2).floatValue();
328              return new FieldLiteral(new Double(operand1111 + operand18),Datatype.DOUBLE);
329            case DOUBLE : case FLOAT : case DOUBLEPRECISION :
330              double operand19 = ( (Double) result2).doubleValue();
331              return new FieldLiteral(new Double(operand1111 + operand19),Datatype.DOUBLE);
332            case CHARACTER :case VARCHAR: case CHAR: case CHARACTERVARYING:
333              throw new DException("DSE87", new Object[] {"CHARACTER", "DOUBLE"});
334            case DATE:
335              Date dd5 = (Date) result2;
336              gg.setTime(dd5);
337              gg.add(Calendar.DATE, ( (Double) result1).intValue());
338              return new FieldLiteral(gg.getTime(),Datatype.DATE);
339          }
340        case CHARACTER :case VARCHAR: case CHAR: case CHARACTERVARYING:
341          switch (type2) {
342            case BYTE : case TINYINT :
343            case SHORT : case SMALLINT :
344            case INTEGER : case INT :
345            case LONG : case BIGINT :
346            case BIGDECIMAL : case DEC : case DECIMAL : case NUMERIC :
347            case REAL:
348            case DOUBLE : case FLOAT : case DOUBLEPRECISION :
349            case CHARACTER :case VARCHAR: case CHAR: case CHARACTERVARYING:
350              StringBuffer result = new StringBuffer(result1.toString());
351              result.append(result2.toString());
352              return new FieldLiteral(result.toString(),Datatype.CHARACTER);
353            case DATE:
354              throw new DException("DSE87", new Object[] {"CHARACTER", "DATE"});
355          }
356        case DATE:
357          Date dateVar = (Date) result1;
358          gg.setTime(dateVar);
359          switch (type2) {
360            case BYTE : case TINYINT :
361              int value0 = ( (Byte) result2).intValue();
362              gg.add(Calendar.DATE, value0);
363              return new FieldLiteral(gg.getTime(),Datatype.DATE);
364            case SHORT : case SMALLINT :
365              int value1 = ( (Short) result2).intValue();
366              gg.add(Calendar.DATE, value1);
367              return new FieldLiteral(gg.getTime(),Datatype.DATE);
368            case INTEGER : case INT :
369              int value2 = ( (Integer) result2).intValue();
370              gg.add(Calendar.DATE, value2);
371              return new FieldLiteral(gg.getTime(),Datatype.DATE);
372            case LONG : case BIGINT :
373              int value3 = ( (Long) result2).intValue();
374              gg.add(Calendar.DATE, value3);
375              return new FieldLiteral(gg.getTime(),Datatype.DATE);
376            case BIGDECIMAL : case DEC : case DECIMAL : case NUMERIC :
377              int value4 = ( (BigDecimal) result2).intValue();
378              gg.add(Calendar.DATE, value4);
379              return new FieldLiteral(gg.getTime(),Datatype.DATE);
380            case REAL:
381              int value5 = ( (Float) result2).intValue();
382              gg.add(Calendar.DATE, value5);
383              return new FieldLiteral(gg.getTime(),Datatype.DATE);
384            case DOUBLE : case FLOAT : case DOUBLEPRECISION :
385              int value6 = ( (Double) result2).intValue();
386              gg.add(Calendar.DATE, value6);
387              return new FieldLiteral(gg.getTime(),Datatype.DATE);
388            case CHARACTER :case VARCHAR: case CHAR: case CHARACTERVARYING:
389              int value7 = ( (Double) result2).intValue();
390              gg.add(Calendar.DATE, value7);
391              return new FieldLiteral(gg.getTime(),Datatype.DATE);
392            case DATE:
393              throw new DException("DSE103", null);
394          }
395        default:
396          throw new DException("DSE4108",new Object[]{StaticClass.getDataTypeName(type2),"concat"});
397      }
398       }*/
399
400    public AbstractRowValueExpression[] getChilds() {
401       AbstractRowValueExpression[] childs = new AbstractRowValueExpression[] {
402           (AbstractRowValueExpression) (_charactervalueexpression3),
403           (AbstractRowValueExpression) (_charactervalueexpression1)};
404       return childs;
405    }
406
407    public String getType() throws DException {
408       return (String ) _SNONRESERVEDWORD1364442555.run(null);
409    }
410
411    public String toString() {
412       StringBuffer sb = new StringBuffer ();
413       sb.append(" ");
414       sb.append(_SNONRESERVEDWORD1364442555);
415       sb.append(" ");
416       sb.append(_Sleftparen6538802414);
417       sb.append(" ");
418       sb.append(_charactervalueexpression3);
419       sb.append(" ");
420       sb.append(_Scomma948436052);
421       sb.append(" ");
422       sb.append(_charactervalueexpression1);
423       sb.append(" ");
424       sb.append(_Srightparen_18748595140);
425       return sb.toString();
426    }
427
428    public Object clone() throws CloneNotSupportedException {
429       concatfunction tempClass = new concatfunction();
430       tempClass._Srightparen_18748595140 = (Srightparen_1874859514)
431           _Srightparen_18748595140.clone();
432       tempClass._charactervalueexpression1 = (charactervalueexpression)
433           _charactervalueexpression1.clone();
434       tempClass._Scomma948436052 = (Scomma94843605) _Scomma948436052.clone();
435       tempClass._charactervalueexpression3 = (charactervalueexpression)
436           _charactervalueexpression3.clone();
437       tempClass._Sleftparen6538802414 = (Sleftparen653880241)
438           _Sleftparen6538802414.clone();
439       tempClass._SNONRESERVEDWORD1364442555 = (SNONRESERVEDWORD136444255)
440           _SNONRESERVEDWORD1364442555.clone();
441       return tempClass;
442    }
443
444    public ByteComparison getByteComparison(Object object) throws DException {
445      ByteComparison byteComparison =new ByteComparison(false, new int[] {Datatypes.CHARACTER});
446      int columnSize=getColumnSize(object);
447      byteComparison.setSize(columnSize);
448      return byteComparison;
449    }
450
451     public int getColumnSize(Object object) throws DException {
452        ColumnDetails[] columnDetails = getChildColumnDetails();
453        int size=0;
454        if(columnDetails[0].getQuestion()||columnDetails[1].getQuestion()){
455          return DatabaseProperties.maxCharLiteralLength;
456        }
457        if(columnDetails[0].getType()!=TypeConstants.CONSTANT||columnDetails[0].getSize()!=-5){
458          size+=columnDetails[0].getSize();
459        } else {
460          FieldBase field1 = (FieldBase) _charactervalueexpression3.run(object);
461          field1.setDatatype(columnDetails[0].getDatatype());
462          size+=field1.getLength();
463        }
464
465        if(columnDetails[1].getType()!=TypeConstants.CONSTANT||columnDetails[1].getSize()!=-5){
466         size+=columnDetails[1].getSize();
467       } else {
468         FieldBase field2 = (FieldBase) _charactervalueexpression1.run(object);
469         field2.setDatatype(columnDetails[1].getDatatype());
470         size+=field2.getLength();
471       }
472        return size;
473      }
474
475      public _Reference[] checkSemantic(_ServerSession parent) throws DException {
476           _Reference[] ref = super.checkSemantic(parent);
477           if(ref!=null) {
478             return ref;
479           }
480           int type1 = _charactervalueexpression1.getByteComparison(parent).getDataTypes()[0];
481           int type2 = _charactervalueexpression3.getByteComparison(parent).getDataTypes()[0];
482           switch (type1) {
483              case -1:
484              case CHARACTER:
485              case VARCHAR:
486              case CHAR:
487              case CHARACTERVARYING:
488                 switch (type2) {
489                    case -1:
490                    case CHARACTER:
491                    case VARCHAR:
492                    case CHAR:
493                    case CHARACTERVARYING:
494                       return ref;
495                    default:
496                       throw new DException("DSE419", new Object [] {StaticClass.getDataTypeName(type2), "CONCAT"});
497                 }
498           }
499           throw new DException("DSE419", new Object [] {StaticClass.getDataTypeName(type1), "CONCAT"});
500        }
501
502
503
504    /* private int getDatatype(Object object) throws DException {
505        int type1 = getDataTypeForByte(_charactervalueexpression3.getByteComparison(object));
506        int type2 = getDataTypeForByte(_charactervalueexpression1.getByteComparison(object));
507        switch (type1) {
508          case BYTE : case TINYINT :
509            switch (type2) {
510              case BYTE : case TINYINT :
511                return BYTE;
512              case SHORT : case SMALLINT :
513                return SHORT;
514              case INTEGER : case INT :
515                return INTEGER;
516              case LONG : case BIGINT :
517                return LONG;
518              case BIGDECIMAL : case DEC : case DECIMAL : case NUMERIC :
519                return BIGDECIMAL;
520              case REAL:
521                return FLOAT;
522              case DOUBLE : case FLOAT : case DOUBLEPRECISION :
523                return DOUBLE;
524              case DATE:
525                return DATE;
526              case CHARACTER :case VARCHAR: case CHAR: case CHARACTERVARYING:
527                throw new DException("DSE40", new Object[] {"CHARACTER", "BYTE"});
528            }
529          case SHORT : case SMALLINT :
530            switch (type2) {
531              case BYTE : case TINYINT :
532              case SHORT : case SMALLINT :
533                return Datatype.SHORT;
534              case INTEGER : case INT :
535                return INTEGER;
536              case LONG : case BIGINT :
537                return LONG;
538              case BIGDECIMAL : case DEC : case DECIMAL : case NUMERIC :
539                return BIGDECIMAL;
540              case REAL:
541                return FLOAT;
542              case DOUBLE : case FLOAT : case DOUBLEPRECISION :
543                return DOUBLE;
544              case DATE:
545                return DATE;
546              case CHARACTER :case VARCHAR: case CHAR: case CHARACTERVARYING:
547                return CHARACTER;
548              default:
549                      throw new DException("DSE87",new Object[]{"CHARACTER","SHORT"});
550            }
551          case INTEGER : case INT :
552            switch (type2) {
553              case BYTE : case TINYINT :
554              case SHORT : case SMALLINT :
555              case INTEGER : case INT :
556                return INTEGER;
557              case LONG : case BIGINT :
558                return LONG;
559              case BIGDECIMAL : case DEC : case DECIMAL : case NUMERIC :
560                return BIGDECIMAL;
561              case REAL:
562                return FLOAT;
563              case DOUBLE : case FLOAT : case DOUBLEPRECISION :
564                return DOUBLE;
565              case DATE:
566                return DATE;
567              case CHARACTER :case VARCHAR: case CHAR: case CHARACTERVARYING:
568                return CHARACTER;
569              default:
570                throw new DException("DSE87",new Object[]{"CHARACTER","INT"});
571            }
572          case LONG : case BIGINT :
573            switch (type2) {
574              case BYTE : case TINYINT :
575                return INTEGER;
576              case SHORT : case SMALLINT :
577              case INTEGER : case INT :
578              case LONG : case BIGINT :
579                return LONG;
580              case BIGDECIMAL : case DEC : case DECIMAL : case NUMERIC :
581                return BIGDECIMAL;
582              case REAL:
583                return FLOAT;
584              case DOUBLE : case FLOAT : case DOUBLEPRECISION :
585                return DOUBLE;
586              case DATE:
587                return DATE;
588              case CHARACTER :case VARCHAR: case CHAR: case CHARACTERVARYING:
589                return CHARACTER;
590                default:
591                  throw new DException("DSE87",new Object[]{"CHARACTER","LONG"});
592            }
593          case BIGDECIMAL : case DEC : case DECIMAL : case NUMERIC :
594            switch (type2) {
595              case BYTE : case TINYINT :
596              case SHORT : case SMALLINT :
597              case INTEGER : case INT :
598              case LONG : case BIGINT :
599              case BIGDECIMAL : case DEC : case DECIMAL : case NUMERIC :
600              case REAL:
601              case DOUBLE : case FLOAT : case DOUBLEPRECISION :
602                return BIGDECIMAL;
603              case DATE:
604                return DATE;
605              case CHARACTER :case VARCHAR: case CHAR: case CHARACTERVARYING:
606                return CHARACTER;
607                default:
608                  throw new DException("DSE87",new Object[]{"CHARACTER","BIGDECIMAL"});
609            }
610          case REAL:
611            switch (type2) {
612              case BYTE : case TINYINT :
613              case SHORT : case SMALLINT :
614              case INTEGER : case INT :
615              case LONG : case BIGINT :
616              case REAL:
617                return FLOAT;
618              case BIGDECIMAL : case DEC : case DECIMAL : case NUMERIC :
619                return BIGDECIMAL;
620              case DOUBLE : case FLOAT : case DOUBLEPRECISION :
621                return DOUBLE;
622              case DATE:
623                return DATE;
624              case CHARACTER :case VARCHAR: case CHAR: case CHARACTERVARYING:
625                return CHARACTER;
626              default:
627                throw new DException("DSE87",new Object[]{"CHARACTER","FLOAT"});
628            }
629          case DOUBLE : case FLOAT : case DOUBLEPRECISION :
630            switch (type2) {
631              case BYTE : case TINYINT :
632              case SHORT : case SMALLINT :
633              case INTEGER : case INT :
634              case LONG : case BIGINT :
635              case REAL:
636              case DOUBLE : case FLOAT : case DOUBLEPRECISION :
637                return DOUBLE;
638              case BIGDECIMAL : case DEC : case DECIMAL : case NUMERIC :
639                return BIGDECIMAL;
640              case CHARACTER :case VARCHAR: case CHAR: case CHARACTERVARYING:
641                throw new DException("DSE87", new Object[] {"CHARACTER", "DOUBLE"});
642              case DATE:
643                return DATE;
644            }
645          case CHARACTER :case VARCHAR: case CHAR: case CHARACTERVARYING:
646            switch (type2) {
647              case SHORT : case SMALLINT :
648              case INTEGER : case INT :
649              case LONG : case BIGINT :
650              case BIGDECIMAL : case DEC : case DECIMAL : case NUMERIC :
651              case REAL:
652              case DOUBLE : case FLOAT : case DOUBLEPRECISION :
653              case CHARACTER :case VARCHAR: case CHAR: case CHARACTERVARYING:
654                return CHARACTER;
655              case DATE:
656                throw new DException("DSE87", new Object[] {"CHARACTER", "DATE"});
657            }
658          case DATE:
659            switch (type2) {
660              case BYTE : case TINYINT :
661              case SHORT : case SMALLINT :
662              case INTEGER : case INT :
663              case LONG : case BIGINT :
664              case BIGDECIMAL : case DEC : case DECIMAL : case NUMERIC :
665              case REAL:
666              case DOUBLE : case FLOAT : case DOUBLEPRECISION :
667                return DATE;
668              case DATE:
669                throw new DException("DSE103", null);
670            }
671          default:
672            throw new DException("DSE4108",new Object[]{StaticClass.getDataTypeName(type2),"concat"});
673        }
674      }*/
675 }
676

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags