KickJava   Java API By Example, From Geeks To Geeks.

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


1 package com.daffodilwoods.daffodildb.server.sql99.expression.stringvalueexpression;
2
3 import com.daffodilwoods.daffodildb.server.serversystem.*;
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 in.co.daffodil.db.jdbc.DatabaseProperties;
12
13 public class ucasefunction extends AbstractStringValueExpression implements charactervaluefunction, Datatypes, TypeConstants {
14
15    public Srightparen_1874859514 _Srightparen_18748595140;
16    public charactervalueexpression _charactervalueexpression1;
17    public Sleftparen653880241 _Sleftparen6538802412;
18    public SNONRESERVEDWORD136444255 _SNONRESERVEDWORD1364442553;
19
20
21    public Object JavaDoc run(Object JavaDoc object) throws com.daffodilwoods.database.resource.
22
       DException {
23       FieldBase result = (FieldBase) _charactervalueexpression1.run(object);
24       if (result.isNull()) {
25          return new FieldStringLiteral(FieldUtility.NULLBUFFERRANGE, CHARACTER);
26       }
27       return getResult(getDataType(result), result.getObject());
28    }
29
30    public ColumnDetails[] getChildColumnDetails() throws DException {
31       return columnDetails;
32    }
33
34    protected String JavaDoc getNameOfColumn(ColumnDetails[] columnDetails) throws
35        DException {
36       String JavaDoc nameOfColumn = "";
37       for (int i = 0; i < columnDetails.length; ++i) {
38          nameOfColumn += columnDetails[i].getColumn();
39       }
40       return nameOfColumn;
41    }
42
43    public String JavaDoc getType() throws DException {
44       return (String JavaDoc) _SNONRESERVEDWORD1364442553.run(null);
45    }
46
47    public ParameterInfo[] getParameterInfo() throws DException {
48       ParameterInfo[] param =_charactervalueexpression1.getParameterInfo();
49       for (int i = 0; i < param.length; i++) {
50         if (param[i].getQuestionMark()) {
51           param[i].setDataType(Datatypes.CHARACTER);
52           param[i].setName("UCASE Arg");
53           return param;
54         }
55       }
56       return getThisParameterInfo();
57    }
58
59    protected ParameterInfo[] getThisParameterInfo() throws DException {
60       ParameterInfo parameterInfo = new ParameterInfo();
61       parameterInfo.setName(toString());
62       parameterInfo.setDataType(Datatypes.CHARACTER);
63       return new ParameterInfo[] {
64           parameterInfo};
65    }
66
67
68    /*private int getDataType(Object object) throws DException {
69      if (object instanceof Integer)
70        return INTEGER;
71      else if (object instanceof Float)
72        return FLOAT;
73      else if (object instanceof Double)
74        return DOUBLE;
75      else if (object instanceof Long)
76        return LONG;
77      else if (object instanceof String)
78        return CHARACTER;
79      else if (object instanceof Short)
80        return SHORT;
81      else if (object instanceof BigDecimal)
82        return BIGDECIMAL;
83      else if (object instanceof Byte)
84        return BYTE;
85      else
86       throw new DException("DSE4108",new Object[] {object.getClass(),"ucase"});
87       }*/

88
89    private Object JavaDoc getResult(int type, Object JavaDoc object) throws DException {
90       switch (type) {
91          case BYTE:
92          case TINYINT:
93          case INTEGER:
94          case INT:
95          case REAL:
96          case DOUBLE:
97          case FLOAT:
98          case DOUBLEPRECISION:
99          case LONG:
100          case BIGINT:
101          case SHORT:
102          case SMALLINT:
103          case BIGDECIMAL:
104          case DEC:
105          case DECIMAL:
106          case NUMERIC:
107             Number JavaDoc operand = (Number JavaDoc) object;
108             return toUpperCase(operand.toString());
109          case CHARACTER:
110          case VARCHAR:
111          case CHAR:
112          case CHARACTERVARYING:
113             String JavaDoc string = (String JavaDoc) object;
114             return toUpperCase(string);
115          default:
116             throw new DException("DSE514", new Object JavaDoc[] {StaticClass.getDataTypeName(type)});
117       }
118    }
119
120    /* private Object getResult(int type, Object object) throws DException {
121         switch (type) {
122           case BYTE : case TINYINT :
123             return toUpperCase( ( (Byte) object).toString());
124           case INTEGER : case INT :
125             Integer integer = (Integer) object;
126             return toUpperCase(integer.toString());
127           case REAL:
128             Float floatV = (Float) object;
129             return toUpperCase(floatV.toString());
130           case DOUBLE : case FLOAT : case DOUBLEPRECISION :
131             Double doubleV = (Double) object;
132             return toUpperCase(doubleV.toString());
133           case LONG : case BIGINT :
134             Long longV = (Long) object;
135             return toUpperCase(longV.toString());
136           case SHORT : case SMALLINT :
137             Short shortV = (Short) object;
138             return toUpperCase(shortV.toString());
139           case BIGDECIMAL : case DEC : case DECIMAL : case NUMERIC :
140             BigDecimal bigDecimal = (BigDecimal) object;
141             return toUpperCase(bigDecimal.toString());
142           case CHARACTER :case VARCHAR: case CHAR: case CHARACTERVARYING:
143             String string = (String) object;
144             return toUpperCase(string);
145           default:
146             throw new DException("DSE514",new Object[]{StaticClass.getDataTypeName(type)});
147         }
148       } */

149
150    private Object JavaDoc toUpperCase(String JavaDoc string) throws DException {
151       return new FieldStringLiteral(string.toUpperCase(), CHARACTER);
152    }
153
154
155    public AbstractRowValueExpression[] getChilds() {
156       AbstractRowValueExpression[] childs = new AbstractRowValueExpression[] {
157           (AbstractRowValueExpression) (_charactervalueexpression1)};
158       return childs;
159
160    }
161
162    public String JavaDoc toString() {
163       StringBuffer JavaDoc sb = new StringBuffer JavaDoc();
164       sb.append(" ");
165       sb.append(_SNONRESERVEDWORD1364442553);
166       sb.append(" ");
167       sb.append(_Sleftparen6538802412);
168       sb.append(" ");
169       sb.append(_charactervalueexpression1);
170       sb.append(" ");
171       sb.append(_Srightparen_18748595140);
172       return sb.toString();
173    }
174
175    public Object JavaDoc clone() throws CloneNotSupportedException JavaDoc {
176       ucasefunction tempClass = new ucasefunction();
177       tempClass._Srightparen_18748595140 = (Srightparen_1874859514)
178           _Srightparen_18748595140.clone();
179       tempClass._charactervalueexpression1 = (charactervalueexpression)
180           _charactervalueexpression1.clone();
181       tempClass._Sleftparen6538802412 = (Sleftparen653880241)
182           _Sleftparen6538802412.clone();
183       tempClass._SNONRESERVEDWORD1364442553 = (SNONRESERVEDWORD136444255)
184           _SNONRESERVEDWORD1364442553.clone();
185       return tempClass;
186    }
187    public ByteComparison getByteComparison(Object JavaDoc object) throws DException {
188      ByteComparison byteComparison =new ByteComparison(false, new int[] {CHARACTER});
189      int columnSize= getColumnSize(object);
190      byteComparison.setSize(columnSize);
191      return byteComparison;
192    }
193
194    /*private int getDatatype(Object object) throws DException {
195      int type = getDataTypeForByte(_charactervalueexpression1.getByteComparison(object));
196      switch (type) {
197        case BYTE : case TINYINT :
198          return BYTE;
199        case INTEGER : case INT :
200          return INTEGER;
201        case REAL:
202          return FLOAT;
203        case DOUBLE : case FLOAT : case DOUBLEPRECISION :
204          return DOUBLE;
205        case LONG : case BIGINT :
206          return Datatype.LONG;
207        case SHORT : case SMALLINT :
208          return SHORT;
209        case BIGDECIMAL : case DEC : case DECIMAL : case NUMERIC :
210          return BIGDECIMAL;
211        case CHARACTER :case VARCHAR: case CHAR: case CHARACTERVARYING:
212          return CHARACTER;
213        default:
214          throw new DException("DSE514",new Object[]{StaticClass.getDataTypeName(type)});
215      }
216       }*/

217
218    public _Reference[] checkSemantic(_ServerSession parent) throws DException {
219       _Reference[] ref = super.checkSemantic(parent);
220        if(ref!=null) {
221           return ref;
222         }
223         int type = _charactervalueexpression1.getByteComparison(parent).
224             getDataTypes()[0];
225         switch (type) {
226           case -1:
227           case BYTE:
228           case TINYINT:
229           case INTEGER:
230           case INT:
231           case REAL:
232           case DOUBLE:
233           case FLOAT:
234           case DOUBLEPRECISION:
235           case LONG:
236           case BIGINT:
237           case SHORT:
238           case SMALLINT:
239           case BIGDECIMAL:
240           case DEC:
241           case DECIMAL:
242           case NUMERIC:
243           case CHARACTER:
244           case VARCHAR:
245           case CHAR:
246           case CHARACTERVARYING:
247             return ref;
248           default:
249             throw new DException("DSE514",
250                                  new Object JavaDoc[] {StaticClass.getDataTypeName(type),
251                                  "UCASE"});
252         }
253    }
254
255    public int getColumnSize(Object JavaDoc object) throws DException {
256      ColumnDetails[] columnDetails = getChildColumnDetails();
257      if (columnDetails[0].getQuestion()) {
258        return DatabaseProperties.maxCharLiteralLength;
259      }
260      else if (columnDetails[0].getType() != TypeConstants.CONSTANT ||
261               columnDetails[0].getSize() != -5) {
262        return columnDetails[0].getSize();
263      } else {
264        FieldBase field = (FieldBase) _charactervalueexpression1.run(object);
265        field.setDatatype(columnDetails[0].getDatatype());
266        return field.getLength();
267      }
268
269    }
270
271
272 }
273
Popular Tags