KickJava   Java API By Example, From Geeks To Geeks.

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


1 package com.daffodilwoods.daffodildb.server.sql99.expression.
2     stringvalueexpression;
3
4 import com.daffodilwoods.daffodildb.server.datasystem.interfaces.*;
5 import com.daffodilwoods.daffodildb.server.serversystem.*;
6 import com.daffodilwoods.daffodildb.server.sql99.common.*;
7 import com.daffodilwoods.daffodildb.server.sql99.expression.rowvalueexpression.*;
8 import com.daffodilwoods.daffodildb.server.sql99.token.*;
9 import com.daffodilwoods.daffodildb.server.sql99.utils.*;
10 import com.daffodilwoods.daffodildb.utils.*;
11 import com.daffodilwoods.daffodildb.utils.field.*;
12 import com.daffodilwoods.database.resource.*;
13 import in.co.daffodil.db.jdbc.DatabaseProperties;
14 import com.daffodilwoods.daffodildb.server.sql99.expression.stringvalueexpression.lcasename;
15
16 public class lcasefunction extends AbstractStringValueExpression implements charactervaluefunction {
17
18    public Srightparen_1874859514 _Srightparen_18748595140;
19    public charactervalueexpression _charactervalueexpression1;
20    public Sleftparen653880241 _Sleftparen6538802412;
21      public lcasename _lcasename3 ;
22
23
24    public Object JavaDoc run(Object JavaDoc object) throws com.daffodilwoods.database.resource.
25
       DException {
26       FieldBase result = (FieldBase) _charactervalueexpression1.run(object);
27       return (result.isNull()) ?
28           new FieldStringLiteral(FieldUtility.NULLBUFFERRANGE, CHARACTER)
29           : getResult(result);
30    }
31
32    public ParameterInfo[] getParameterInfo() throws DException {
33       ParameterInfo[] param=_charactervalueexpression1.getParameterInfo();
34      for (int i = 0; i < param.length; i++) {
35        if (param[i].getQuestionMark()) {
36          param[i].setDataType(Datatypes.CHARACTER);
37          param[i].setName("LCASE Arg1");
38          return param;
39        }
40      }
41      return getThisParameterInfo();
42    }
43
44    protected ParameterInfo[] getThisParameterInfo() throws DException {
45       ParameterInfo parameterInfo = new ParameterInfo();
46       parameterInfo.setName(toString());
47       parameterInfo.setDataType(Datatypes.CHARACTER);
48       return new ParameterInfo[] {parameterInfo};
49    }
50
51
52    public ColumnDetails[] getChildColumnDetails() throws DException {
53       return columnDetails;
54    }
55
56    protected String JavaDoc getNameOfColumn(ColumnDetails[] columnDetails) throws
57        DException {
58       String JavaDoc nameOfColumn = "";
59       for (int i = 0; i < columnDetails.length; ++i) {
60          nameOfColumn += columnDetails[i].getColumn();
61       }
62       return nameOfColumn;
63    }
64
65    /*private int getDataType(Object object) throws DException {
66      if (object instanceof Integer)
67        return INTEGER;
68      else if (object instanceof Float)
69        return FLOAT;
70      else if (object instanceof Double)
71        return DOUBLE;
72      else if (object instanceof Long)
73        return LONG;
74      else if (object instanceof String)
75        return CHARACTER;
76      else if (object instanceof Short)
77        return SHORT;
78      else if (object instanceof BigDecimal)
79        return BIGDECIMAL;
80      else if (object instanceof Byte)
81        return BYTE;
82      else
83        throw new DException("DSE419",new Object[]{"LCASE"});
84       }
85       private Object getResult(int type, Object object) throws DException {
86      switch (type) {
87        case BYTE : case TINYINT :
88          return new FieldLiteral(new Byte(toLowerCase( ( (Byte) object).toString())),Datatype.BYTE);
89        case INTEGER : case INT :
90          Integer integer = (Integer) object;
91          return new FieldLiteral(new Integer(toLowerCase(integer.toString())),Datatype.INTEGER);
92        case REAL:
93          Float floatV = (Float) object;
94          return new FieldLiteral(new Float(toLowerCase(floatV.toString())),Datatype.FLOAT);
95        case DOUBLE : case FLOAT : case DOUBLEPRECISION :
96          Double doubleV = (Double) object;
97          return new FieldLiteral(new Double(toLowerCase(doubleV.toString())),Datatype.DOUBLE);
98        case LONG : case BIGINT :
99          Long longV = (Long) object;
100          return new FieldLiteral(new Long(toLowerCase(longV.toString())),Datatype.LONG);
101        case SHORT : case SMALLINT :
102          Short shortV = (Short) object;
103          return new FieldLiteral(new Short(toLowerCase(shortV.toString())),Datatype.SHORT);
104        case BIGDECIMAL : case DEC : case DECIMAL : case NUMERIC :
105          BigDecimal bigDecimal = (BigDecimal) object;
106          return new FieldLiteral(new BigDecimal(toLowerCase(bigDecimal.toString())),Datatype.BIGDECIMAL);
107        case CHARACTER :case VARCHAR: case CHAR: case CHARACTERVARYING:
108          String string = (String) object;
109          return new FieldStringLiteral(toLowerCase(string),Datatype.CHARACTER);
110        default:
111          throw new DException("DSE4108",new Object[]{StaticClass.getDataTypeName(type),"LCASE"});
112      }
113       }*/

114
115    private Object JavaDoc getResult(FieldBase result) throws DException {
116       int type = getDataType(result);
117       Object JavaDoc object = result.getObject();
118       switch (type) {
119          case BYTE:
120          case TINYINT:
121          case INTEGER:
122          case INT:
123          case REAL:
124          case DOUBLE:
125          case FLOAT:
126          case DOUBLEPRECISION:
127          case LONG:
128          case BIGINT:
129          case SHORT:
130          case SMALLINT:
131          case BIGDECIMAL:
132          case DEC:
133          case DECIMAL:
134          case NUMERIC:
135             Number JavaDoc operand = (Number JavaDoc) object;
136             return toLowerCase(operand.toString());
137          case CHARACTER:
138          case VARCHAR:
139          case CHAR:
140          case CHARACTERVARYING:
141             return toLowerCase( (String JavaDoc) object);
142          default:
143             throw new DException("DSE4108", new Object JavaDoc[] {StaticClass.getDataTypeName(type), "LCASE"});
144       }
145    }
146
147    /* private Object getResult(FieldBase result) throws DException {
148        int type = getDataType(result);
149        Object object = result.getObject();
150        switch (type) {
151          case BYTE : case TINYINT :
152            return toLowerCase( ( (Byte) object).toString());
153          case INTEGER : case INT :
154            return toLowerCase(((Integer) object).toString());
155          case REAL:
156            return toLowerCase(((Float) object).toString());
157          case DOUBLE : case FLOAT : case DOUBLEPRECISION :
158            return toLowerCase(((Double) object).toString());
159          case LONG : case BIGINT :
160            Long longV = (Long) object;
161            return toLowerCase(longV.toString());
162          case SHORT : case SMALLINT :
163            Short shortV = (Short) object;
164            return toLowerCase(shortV.toString());
165          case BIGDECIMAL : case DEC : case DECIMAL : case NUMERIC :
166            return toLowerCase(((BigDecimal) object).toString());
167          case CHARACTER :case VARCHAR: case CHAR: case CHARACTERVARYING:
168            return toLowerCase((String) object);
169          default:
170            throw new DException("DSE4108",new Object[]{StaticClass.getDataTypeName(type),"LCASE"});
171        }
172     } */

173    private Object JavaDoc toLowerCase(String JavaDoc string) throws DException {
174       return new FieldStringLiteral(string.toLowerCase(), Datatype.CHARACTER);
175    }
176
177
178    public AbstractRowValueExpression[] getChilds() {
179       AbstractRowValueExpression[] childs = new AbstractRowValueExpression[] {
180           (AbstractRowValueExpression) (_charactervalueexpression1)};
181       return childs;
182
183    }
184
185    public String JavaDoc getType() throws DException {
186       return (String JavaDoc) _lcasename3.run(null);
187    }
188
189    public String JavaDoc toString() {
190       StringBuffer JavaDoc sb = new StringBuffer JavaDoc();
191       sb.append(" ");
192       sb.append(_lcasename3);
193       sb.append(" ");
194       sb.append(_Sleftparen6538802412);
195       sb.append(" ");
196       sb.append(_charactervalueexpression1);
197       sb.append(" ");
198       sb.append(_Srightparen_18748595140);
199       return sb.toString();
200    }
201
202    public Object JavaDoc clone() throws CloneNotSupportedException JavaDoc {
203       lcasefunction tempClass = new lcasefunction();
204       tempClass._Srightparen_18748595140 = (Srightparen_1874859514)
205           _Srightparen_18748595140.clone();
206       tempClass._charactervalueexpression1 = (charactervalueexpression)
207           _charactervalueexpression1.clone();
208       tempClass._Sleftparen6538802412 = (Sleftparen653880241)
209           _Sleftparen6538802412.clone();
210       tempClass._lcasename3 = (lcasename)
211           _lcasename3.clone();
212       return tempClass;
213    }
214
215    public ByteComparison getByteComparison(Object JavaDoc object) throws DException {
216      ByteComparison byteComparison =new ByteComparison(false, new int[] {Datatypes.CHARACTER});
217      int columnSize=getColumnSize(object);
218      byteComparison.setSize(columnSize);
219      return byteComparison;
220    }
221
222    /*private int getDatatype(Object object) throws DException {
223      int type = getDataTypeForByte(_charactervalueexpression1.getByteComparison(object));
224      switch (type) {
225        case BYTE : case TINYINT :
226          return BYTE;
227        case INTEGER : case INT :
228          return INTEGER;
229        case REAL:
230          return FLOAT;
231        case DOUBLE : case FLOAT : case DOUBLEPRECISION :
232          return DOUBLE;
233        case LONG : case BIGINT :
234          return Datatype.LONG;
235        case SHORT : case SMALLINT :
236          return SHORT;
237        case BIGDECIMAL : case DEC : case DECIMAL : case NUMERIC :
238          return BIGDECIMAL;
239        case CHARACTER :case VARCHAR: case CHAR: case CHARACTERVARYING:
240          return CHARACTER;
241        default:
242          throw new DException("DSE4108",new Object[]{StaticClass.getDataTypeName(type),"LCASE"});
243      }
244       }*/

245
246    public _Reference[] checkSemantic(_ServerSession parent) throws DException {
247       _Reference[] ref = super.checkSemantic(parent);
248       if(ref!=null) {
249           return ref;
250         }
251       int type = _charactervalueexpression1.getByteComparison(parent).getDataTypes()[0];
252       switch (type) {
253          case -1:
254          case BYTE:
255          case TINYINT:
256          case INTEGER:
257          case INT:
258          case REAL:
259          case DOUBLE:
260          case FLOAT:
261          case DOUBLEPRECISION:
262          case LONG:
263          case BIGINT:
264          case SHORT:
265          case SMALLINT:
266          case BIGDECIMAL:
267          case DEC:
268          case DECIMAL:
269          case NUMERIC:
270          case CHARACTER:
271          case VARCHAR:
272          case CHAR:
273          case CHARACTERVARYING:
274             return ref;
275          default:
276             throw new DException("DSE4108", new Object JavaDoc[] {StaticClass.getDataTypeName(type), "LCASE"});
277       }
278
279    }
280
281    public int getColumnSize(Object JavaDoc object) throws DException {
282      ColumnDetails[] columnDetails = getChildColumnDetails();
283      if (columnDetails[0].getQuestion()) {
284        return DatabaseProperties.maxCharLiteralLength;
285      }
286      else if (columnDetails[0].getType() != TypeConstants.CONSTANT ||
287               columnDetails[0].getSize() != -5) {
288        return columnDetails[0].getSize();
289      } else {
290        FieldBase field = (FieldBase) _charactervalueexpression1.run(object);
291        field.setDatatype(columnDetails[0].getDatatype());
292        return field.getLength();
293      }
294
295    }
296
297
298 }
299
Popular Tags