KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > daffodilwoods > daffodildb > server > sql99 > expression > datetimevalueexpression > monthnamefunction


1 package com.daffodilwoods.daffodildb.server.sql99.expression.datetimevalueexpression;
2
3 import java.sql.*;
4 import java.sql.Date JavaDoc;
5 import java.util.*;
6
7 import com.daffodilwoods.daffodildb.server.datasystem.interfaces.*;
8 import com.daffodilwoods.daffodildb.server.serversystem.*;
9 import com.daffodilwoods.daffodildb.server.sql99.common.*;
10 import com.daffodilwoods.daffodildb.server.sql99.expression.rowvalueexpression.*;
11 import com.daffodilwoods.daffodildb.server.sql99.token.*;
12 import com.daffodilwoods.daffodildb.server.sql99.utils.*;
13 import com.daffodilwoods.daffodildb.utils.*;
14 import com.daffodilwoods.daffodildb.utils.field.*;
15 import com.daffodilwoods.database.resource.*;
16 import com.daffodilwoods.daffodildb.server.sql99.expression.stringvalueexpression.charactervaluefunction;
17 import com.daffodilwoods.daffodildb.server.sql99.expression.stringvalueexpression.AbstractStringValueExpression;
18
19 public class monthnamefunction extends AbstractStringValueExpression /*AbstractDateTimeValueFunction*/ implements com.daffodilwoods.daffodildb.utils.parser.StatementExecuter,/* datetimevaluefunction*/charactervaluefunction , TypeConstants, Datatypes {
20    public Srightparen_1874859514 _Srightparen_18748595140;
21    public datetimevalueexpression _datetimevalueexpression1;
22    public Sleftparen653880241 _Sleftparen6538802412;
23    public SNONRESERVEDWORD136444255 _SNONRESERVEDWORD1364442553;
24    private String JavaDoc[] MONTHNAMES = {"JANUARY", "FEBURARY", "MARCH", "APRIL", "MAY", "JUNE", "JULY", "AUGUST", "SEPTEMBER",
25        "OCTOBER", "NOVEMBER", "DECEMBER"};
26
27      public Object JavaDoc run(Object JavaDoc object) throws com.daffodilwoods.database.resource.DException{
28        FieldBase result = (FieldBase) _datetimevalueexpression1.run(object);
29        return (result.isNull()) ?
30            new FieldLiteral(FieldUtility.NULLBUFFERRANGE, CHARACTER)
31            : getResult(getDataType(result), result.getObject());
32     }
33
34    protected ParameterInfo[] getThisParameterInfo() throws DException {
35       ParameterInfo parameterInfo = new ParameterInfo();
36       parameterInfo.setName(toString());
37       parameterInfo.setDataType(CHARACTER);
38       return new ParameterInfo[] {parameterInfo};
39    }
40
41    protected Object JavaDoc getResult(int type, Object JavaDoc object) throws DException {
42       if (object == null) {
43          return new FieldStringLiteral(FieldUtility.NULLBUFFERRANGE, Datatype.CHARACTER);
44       }
45       GregorianCalendar calendar = new GregorianCalendar();
46       switch (type) {
47          case BYTE:
48          case TINYINT:
49          case INTEGER:
50          case INT:
51          case SHORT:
52          case SMALLINT:
53             Number JavaDoc operand = (Number JavaDoc) object;
54             calendar.set(Calendar.DAY_OF_YEAR, operand.intValue());
55             return new FieldStringLiteral(new String JavaDoc(MONTHNAMES[calendar.get(Calendar.MONTH)]), Datatype.CHARACTER);
56          case REAL:
57          case DOUBLE:
58          case FLOAT:
59          case DOUBLEPRECISION:
60          case LONG:
61          case BIGINT:
62          case BIGDECIMAL:
63          case DEC:
64          case DECIMAL:
65          case NUMERIC:
66             throw new DException("DSE8106", new Object JavaDoc[] {StaticClass.getDataTypeName(type)});
67          case CHARACTER:
68          case VARCHAR:
69          case CHAR:
70          case CHARACTERVARYING:
71            String JavaDoc string = (String JavaDoc) object;
72            try {
73              Timestamp timestamp = TypeValidityHandler.getTimestamp(string);
74              Date JavaDoc d1 = new com.daffodilwoods.daffodildb.utils.DBDate(timestamp.getTime());
75              calendar.setTime(d1);
76              return new FieldStringLiteral(new String JavaDoc(MONTHNAMES[calendar.get(Calendar.MONTH)]), Datatype.CHARACTER);
77            }
78            catch (DException ex) {
79              try {
80                Object JavaDoc dateObj = TypeValidityHandler.getDBDate(string);
81                Date JavaDoc d2 = (Date JavaDoc)dateObj;
82                calendar.setTime(d2);
83                return new FieldStringLiteral(new String JavaDoc(MONTHNAMES[calendar.get(Calendar.MONTH)]), Datatype.CHARACTER);
84              }
85              catch (DException ex1) {
86                try {
87                  Time time = TypeValidityHandler.getTime(string);
88                  Date JavaDoc d = new com.daffodilwoods.daffodildb.utils.DBDate(time.getTime());
89                  calendar.setTime(d);
90                  return new FieldStringLiteral(new String JavaDoc(MONTHNAMES[calendar.get(Calendar.MONTH)]), Datatype.CHARACTER);
91                }
92                catch (DException ex2) {
93                  try {
94                    calendar.set(Calendar.DAY_OF_YEAR, new Integer JavaDoc(string).intValue());
95                    return new FieldStringLiteral(new String JavaDoc(MONTHNAMES[calendar.get(Calendar.MONTH)]), Datatype.CHARACTER);
96                  }
97                  catch (Exception JavaDoc ex3) {
98                    throw new DException("DSE419", new Object JavaDoc[]{string});
99                  }
100                }
101              }
102            }
103          case DATE:
104             Date JavaDoc d2 = (Date JavaDoc) object;
105             calendar.setTime(d2);
106             return new FieldStringLiteral(new String JavaDoc(MONTHNAMES[calendar.get(Calendar.MONTH)]), Datatype.CHARACTER);
107          case TIME:
108             Time time = (Time) object;
109             Date JavaDoc d = new com.daffodilwoods.daffodildb.utils.DBDate(time.getTime());
110             calendar.setTime(d);
111             return new FieldStringLiteral(new String JavaDoc(MONTHNAMES[calendar.get(Calendar.MONTH)]), Datatype.CHARACTER);
112          case TIMESTAMP:
113             Timestamp time1 = (Timestamp) object;
114             Date JavaDoc d1 = new com.daffodilwoods.daffodildb.utils.DBDate(time1.getTime());
115             calendar.setTime(d1);
116             return new FieldStringLiteral(new String JavaDoc(MONTHNAMES[calendar.get(Calendar.MONTH)]), Datatype.CHARACTER);
117          default:
118             throw new DException("DSE4108", new Object JavaDoc[] {StaticClass.getDataTypeName(type), "MONTHNAME"});
119       }
120    }
121
122    /* protected Object getResult(int type,Object object) throws DException {
123        if(object == null)
124          return new FieldStringLiteral(FieldUtility.NULLBUFFERRANGE,Datatype.CHARACTER);
125          GregorianCalendar calendar = new GregorianCalendar();
126          switch(type){
127            case BYTE : case TINYINT :
128              calendar.set(Calendar.DATE,((Byte)object).intValue());
129              return new FieldStringLiteral(new String(MONTHNAMES[calendar.get(Calendar.MONTH)]),Datatype.CHARACTER);
130            case INTEGER : case INT :
131              Integer integer = (Integer)object;
132              calendar.set(Calendar.DATE,integer.intValue());
133              return new FieldStringLiteral(new String(MONTHNAMES[calendar.get(Calendar.MONTH)]),Datatype.CHARACTER);
134            case REAL :
135              Float floatV = (Float)object;
136              calendar.set(Calendar.DATE,floatV.intValue());
137              return new FieldStringLiteral(new String(MONTHNAMES[calendar.get(Calendar.MONTH)]),Datatype.CHARACTER);
138            case DOUBLE : case FLOAT : case DOUBLEPRECISION :
139              Double doubleV = (Double)object;
140              calendar.set(Calendar.DATE,doubleV.intValue());
141              return new FieldStringLiteral(new String(MONTHNAMES[calendar.get(Calendar.DAY_OF_WEEK) -1]),Datatype.CHARACTER);
142            case LONG : case BIGINT :
143              Long longV = (Long)object;
144              calendar.set(Calendar.DATE,longV.intValue());
145              return new FieldStringLiteral(new String(MONTHNAMES[calendar.get(Calendar.MONTH)]),Datatype.CHARACTER);
146            case SHORT : case SMALLINT :
147              Short shortV = (Short)object;
148              calendar.set(Calendar.DATE,shortV.intValue());
149              return new FieldStringLiteral(new String(MONTHNAMES[calendar.get(Calendar.MONTH)]),Datatype.CHARACTER);
150            case BIGDECIMAL : case DEC : case DECIMAL : case NUMERIC :
151              BigDecimal bigDecimal = (BigDecimal)object;
152              calendar.set(Calendar.DATE,bigDecimal.intValue());
153              return new FieldStringLiteral(new String(MONTHNAMES[calendar.get(Calendar.MONTH)]),Datatype.CHARACTER);
154            case CHARACTER :case VARCHAR: case CHAR: case CHARACTERVARYING:
155              throw new DException("DSE537",null);
156            case DATE :
157              Date d2 = (Date)object;
158                                  calendar.setTime(d2);
159              return new FieldStringLiteral(new String(MONTHNAMES[calendar.get(Calendar.MONTH)]),Datatype.CHARACTER);
160              case TIME :
161                                  Time time = (Time)object;
162                                  Date d = new com.daffodilwoods.daffodildb.utils.DBDate(time.getTime());
163                                  calendar.setTime(d);
164              return new FieldStringLiteral(new String(MONTHNAMES[calendar.get(Calendar.MONTH)]),Datatype.CHARACTER);
165              case TIMESTAMP :
166                                  Timestamp time1 = (Timestamp)object;
167                                  Date d1 = new com.daffodilwoods.daffodildb.utils.DBDate(time1.getTime());
168                                  calendar.setTime(d1);
169              return new FieldStringLiteral(new String(MONTHNAMES[calendar.get(Calendar.MONTH)]),Datatype.CHARACTER);
170              default :
171                         throw new DException("DSE4108",new Object[]{StaticClass.getDataTypeName(type),"MONTHNAME"});
172          }
173      } */

174
175    public AbstractRowValueExpression[] getChilds() {
176       AbstractRowValueExpression[] childs = new AbstractRowValueExpression[] { (AbstractRowValueExpression) (_datetimevalueexpression1)};
177       return childs;
178
179    }
180
181
182    public String JavaDoc toString() {
183       StringBuffer JavaDoc sb = new StringBuffer JavaDoc();
184       sb.append(" ");
185       sb.append(_SNONRESERVEDWORD1364442553);
186       sb.append(" ");
187       sb.append(_Sleftparen6538802412);
188       sb.append(" ");
189       sb.append(_datetimevalueexpression1);
190       sb.append(" ");
191       sb.append(_Srightparen_18748595140);
192       return sb.toString();
193    }
194
195    public Object JavaDoc clone() throws CloneNotSupportedException JavaDoc {
196       monthnamefunction tempClass = new monthnamefunction();
197       tempClass._Srightparen_18748595140 = (Srightparen_1874859514) _Srightparen_18748595140.clone();
198       tempClass._datetimevalueexpression1 = (datetimevalueexpression) _datetimevalueexpression1.clone();
199       tempClass._Sleftparen6538802412 = (Sleftparen653880241) _Sleftparen6538802412.clone();
200       tempClass._SNONRESERVEDWORD1364442553 = (SNONRESERVEDWORD136444255) _SNONRESERVEDWORD1364442553.clone();
201       return tempClass;
202    }
203
204    public ByteComparison getByteComparison(Object JavaDoc object) throws DException {
205    ByteComparison byteComparison = new ByteComparison(false, new int[] {CHARACTER});
206    byteComparison.setSize(getColumnSize(object));
207    return byteComparison;
208    }
209
210    public String JavaDoc getType() throws DException {
211       return (String JavaDoc) _SNONRESERVEDWORD1364442553.run(null);
212    }
213
214    public _Reference[] checkSemantic(_ServerSession parent) throws DException {
215       _Reference[] ref = super.checkSemantic(parent);
216       if(ref!=null) {
217         return ref;
218        }
219       int type = _datetimevalueexpression1.getByteComparison(parent).getDataTypes()[0];
220       switch (type) {
221          case -1:
222          case BYTE:
223          case TINYINT:
224          case INTEGER:
225          case INT:
226          case REAL:
227          case DOUBLE:
228          case FLOAT:
229          case DOUBLEPRECISION:
230          case LONG:
231          case BIGINT:
232          case SHORT:
233          case SMALLINT:
234          case BIGDECIMAL:
235          case DEC:
236          case DECIMAL:
237          case NUMERIC:
238          case DATE:
239          case TIME:
240          case TIMESTAMP:
241             return ref;
242          case CHARACTER:
243          case VARCHAR:
244          case CHAR:
245          case CHARACTERVARYING:
246          default:
247             throw new DException("DSE419", new Object JavaDoc[] {StaticClass.getDataTypeName(type), "MONTH"});
248       }
249    }
250    public ParameterInfo[] getParameterInfo() throws DException {
251      ParameterInfo[] paramInfo = super.getParameterInfo();
252      for (int i = 0; i < paramInfo.length; i++) {
253        if (paramInfo[i].getQuestionMark()) {
254          paramInfo[i].setDataType(Datatypes.DATE);
255          paramInfo[i].setName("MONTHNAME Arg");
256        }
257      }
258      return paramInfo;
259    }
260
261    public int getColumnSize(Object JavaDoc object) throws DException {
262    int maxLengthOfName =9;
263    return maxLengthOfName;
264    }
265
266    public ColumnDetails[] getChildColumnDetails() throws DException {
267       return columnDetails;
268     }
269
270 }
271
Popular Tags