KickJava   Java API By Example, From Geeks To Geeks.

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


1 package com.daffodilwoods.daffodildb.server.sql99.expression.datetimevalueexpression;
2
3 import java.sql.*;
4 import java.util.*;
5
6 import com.daffodilwoods.daffodildb.server.serversystem.*;
7 import com.daffodilwoods.daffodildb.server.sql99.common.*;
8 import com.daffodilwoods.daffodildb.server.sql99.expression.rowvalueexpression.*;
9 import com.daffodilwoods.daffodildb.server.sql99.token.*;
10 import com.daffodilwoods.daffodildb.server.sql99.utils.*;
11 import com.daffodilwoods.daffodildb.utils.*;
12 import com.daffodilwoods.daffodildb.utils.field.*;
13 import com.daffodilwoods.database.resource.*;
14 import com.daffodilwoods.daffodildb.server.datasystem.interfaces.*;
15 import com.daffodilwoods.database.utility.P;
16 import java.util.ArrayList JavaDoc;
17 import java.util.Arrays JavaDoc;
18
19 public class timestampaddfunction extends AbstractDateTimeValueFunction implements com.daffodilwoods.daffodildb.utils.parser.StatementExecuter, datetimevaluefunction, TypeConstants, Datatypes, TimeStampDenometersInterface {
20
21    public Srightparen_1874859514 _Srightparen_18748595140;
22    public datetimevalueexpression _datetimevalueexpression1;
23    public Scomma94843605 _Scomma948436052;
24    public datetimevalueexpression _datetimevalueexpression3;
25    public Scomma94843605 _Scomma948436054;
26    public timestampdenometers _timestampdenometers5;
27    public Sleftparen653880241 _Sleftparen6538802416;
28    public SNONRESERVEDWORD136444255 _SNONRESERVEDWORD1364442557;
29
30    public Object JavaDoc run(Object JavaDoc object) throws com.daffodilwoods.database.resource.DException {
31       FieldBase result1 = (FieldBase) _datetimevalueexpression3.run(object); //count
32
if (result1.isNull()) {
33          return new FieldTimeStampLiteral(FieldUtility.NULLBUFFERRANGE);
34       }
35       FieldBase result2 = (FieldBase) _datetimevalueexpression1.run(object); //timestamp
36
if (result2.isNull()) {
37          return new FieldTimeStampLiteral(FieldUtility.NULLBUFFERRANGE);
38       }
39       int type1 = result1.getDatatype();
40       int type2 = result2.getDatatype();
41       if (type1 == -1) {
42          result1.setDatatype( -1);
43          type1 = result1.getDatatype();
44       }
45       if (type2 == -1) {
46          result2.setDatatype( -1);
47          type2 = result2.getDatatype();
48       }
49       Object JavaDoc result3 = _timestampdenometers5.run(object); //interval
50
int type3 = getType(result3);
51       return getResult(type1, type2, result1.getObject(), result2.getObject(), type3);
52    }
53
54    public ParameterInfo[] getParameterInfo() throws DException {
55
56       ArrayList JavaDoc list =new ArrayList JavaDoc();
57       ParameterInfo[] parameterInfo2 = _datetimevalueexpression3.getParameterInfo();
58       for (int i = 0; i < parameterInfo2.length; i++){
59         if (parameterInfo2[i].getQuestionMark()) {
60           parameterInfo2[i].setDataType(Datatype.INTEGER);
61           parameterInfo2[i].setName("TIMESTAMPADD Arg1");
62           list.addAll(Arrays.asList(parameterInfo2));
63         }
64       }
65       ParameterInfo[] parameterInfo3 = _datetimevalueexpression1.getParameterInfo();
66       for (int i = 0; i < parameterInfo3.length; i++) {
67         if (parameterInfo3[i].getQuestionMark()) {
68           parameterInfo3[i].setDataType(Datatype.TIMESTAMP);
69           parameterInfo3[i].setName("TIMESTAMPADD Arg2");
70           list.addAll(Arrays.asList(parameterInfo3));
71         }
72       }
73       ParameterInfo[] param4 = new ParameterInfo[list.size()];
74       list.toArray(param4);
75       for (int i = 0; i < param4.length; i++) {
76         if(param4[i].getQuestionMark())
77           return param4;
78       }
79       return getThisParameterInfo();
80    }
81
82
83    protected ParameterInfo[] getThisParameterInfo() throws DException {
84       ParameterInfo parameterInfo = new ParameterInfo();
85       parameterInfo.setName(toString());
86       parameterInfo.setDataType(TIMESTAMP);
87       return new ParameterInfo[] {parameterInfo};
88    }
89
90    protected String JavaDoc getNameOfColumn(ColumnDetails[] columnDetails) throws DException {
91       String JavaDoc nameOfColumn = "";
92       for (int i = 0; i < columnDetails.length; ++i) {
93          nameOfColumn += columnDetails[i].getColumn();
94       }
95       return nameOfColumn;
96    }
97
98    /*private int getDataType(Object object) throws DException {
99       if(object instanceof Integer)
100          return INTEGER;
101       else if(object instanceof Float)
102          return FLOAT;
103       else if(object instanceof Double)
104          return DOUBLE;
105       else if(object instanceof Long)
106          return LONG;
107       else if(object instanceof String)
108          return CHARACTER;
109       else if(object instanceof Short)
110          return SHORT;
111       else if(object instanceof BigDecimal)
112          return BIGDECIMAL;
113       else if (object instanceof Date )
114          return DATE;
115       else if (object instanceof Time )
116          return TIME;
117       else if (object instanceof Timestamp )
118          return TIMESTAMP;
119       else
120          throw new DException("DSE419",new Object[]{"TIMESTAMPADD"});
121        }*/

122
123    public ColumnDetails[] getChildColumnDetails() throws DException {
124       return columnDetails;
125    }
126
127    /*private Timestamp timeStampAdd(int field,int count,Timestamp timeStamp) throws DException {
128       long sourceTime = timeStamp.getTime();
129       GregorianCalendar source = new GregorianCalendar();
130       source.setLenient(false);
131       source.setTime(new com.daffodilwoods.daffodildb.utils.DBDate(sourceTime));
132       if ( field == -1 ){
133          int i = source.get(SQL_TSI_MONTH);
134          i = i + (count * 3);
135          source.set(SQL_TSI_MONTH,i);
136       }else
137          source.add(field,count);
138       try {
139         long t1 = source.getTime().getTime();
140         long t2 = (new Timestamp(99998099, 12, 31, 23, 59, 59, 999)).getTime();
141         if (t1 > t2) {
142           throw new DException("DSE5549", null);
143         }
144       }
145       catch (IllegalArgumentException ex) {
146         throw new DException("DSE5549",null);
147       }
148       return new Timestamp(source.getTime().getTime());
149    }*/

150
151
152   private Timestamp timeStampAdd(int field, int count, Timestamp timeStamp) throws DException {
153     long sourceTime = timeStamp.getTime();
154     GregorianCalendar source = new GregorianCalendar();
155     source.setLenient(false);
156     source.setTime(new com.daffodilwoods.daffodildb.utils.DBDate(sourceTime));
157     if (field == -1) {
158        int year=source.get(SQL_TSI_YEAR);
159        int i = source.get(SQL_TSI_MONTH);
160        i = i + (count * 3);
161        if(i >= 12){
162          int x = 0;
163          while(i>12){
164          i=i-12;
165          x++;
166          }
167          source.set(SQL_TSI_YEAR,year+x);
168          source.set(SQL_TSI_MONTH, i);
169        }
170           source.set(SQL_TSI_MONTH, i);
171     } else {
172        source.add(field, count);
173     }
174     try {
175
176       long t1 = source.getTime().getTime();
177       long maxSupportedLongTime = (new Timestamp(99998099, 11, 31, 23, 59, 59, 999000000)).getTime();
178       if (t1 > maxSupportedLongTime) {
179         throw new DException("DSE5549", null);
180       }
181     }
182     catch (IllegalArgumentException JavaDoc ex) {
183       throw new DException("DSE5549",null);
184     }
185     Timestamp t2 = new Timestamp(source.getTime().getTime());
186     return t2;
187   }
188
189    private Object JavaDoc getResult(int type1, int type2, Object JavaDoc result1, Object JavaDoc result2, int field) throws DException {
190       switch (type2) {
191         case CHARACTER:
192         case VARCHAR:
193         case CHAR:
194         case CHARACTERVARYING:
195           String JavaDoc string = (String JavaDoc)result2;
196             try {
197               Timestamp timestamp = TypeValidityHandler.getTimestamp(string);
198               switch (type1) {
199                 case DATE:
200                   throw new DException("DSE419", new Object JavaDoc[] {"TIMESTAMPADD"});
201                 case TIME:
202                   throw new DException("DSE419", new Object JavaDoc[] {"TIMESTAMPADD"});
203                 case TIMESTAMP:
204                   throw new DException("DSE419", new Object JavaDoc[] {"TIMESTAMPADD"});
205                 default:
206                   int count = getCount(result1, type1).intValue();
207                   return new FieldTimeStampLiteral(timeStampAdd(field, count,
208                       timestamp));
209               }
210             }
211             catch (DException ex) {
212               throw new DException("DSE419", new Object JavaDoc[] {"TIMESTAMPADD"});
213             }
214          case TIMESTAMP:
215             Timestamp timestamp = (Timestamp) result2;
216               switch (type1) {
217                 case DATE:
218                   throw new DException("DSE419", new Object JavaDoc[] {"timestampadd"});
219                 case TIME:
220                   throw new DException("DSE419", new Object JavaDoc[] {"timestampadd"});
221                 case TIMESTAMP:
222                   throw new DException("DSE419", new Object JavaDoc[] {"TIMESTAMPADD"});
223                 default:
224                   int count = getCount(result1, type1).intValue();
225                   return new FieldTimeStampLiteral(timeStampAdd(field, count,
226                       timestamp));
227               }
228          default:
229             throw new DException("DSE4108", new Object JavaDoc[] {StaticClass.getDataTypeName(type2), "timestampadd"});
230       }
231    }
232
233    private Integer JavaDoc getCount(Object JavaDoc object, int type) throws DException {
234       switch (type) {
235          case BYTE:
236          case TINYINT:
237          case INTEGER:
238          case INT:
239          case REAL:
240          case DOUBLE:
241          case FLOAT:
242          case DOUBLEPRECISION:
243          case LONG:
244          case BIGINT:
245          case SHORT:
246          case SMALLINT:
247          case BIGDECIMAL:
248          case DEC:
249          case DECIMAL:
250          case NUMERIC:
251             Number JavaDoc operand = (Number JavaDoc) object;
252             return new Integer JavaDoc(operand.intValue());
253          case CHARACTER:
254          case VARCHAR:
255          case CHAR:
256          case CHARACTERVARYING:
257             String JavaDoc string = (String JavaDoc) object;
258             Double JavaDoc d = null;
259             try {
260                d = new Double JavaDoc(string);
261             } catch (Exception JavaDoc e) {
262                throw new DException("DSE35", new Object JavaDoc[] {"character string", "double"});
263             }
264             return new Integer JavaDoc(d.intValue());
265          default:
266             throw new DException("DSE4108", new Object JavaDoc[] {StaticClass.getDataTypeName(type), "COUNT"});
267       }
268    }
269
270    /* private Integer getCount(Object object, int type) throws DException {
271       switch(type){
272          case BYTE : case TINYINT :
273             Byte byteV = (Byte)object;
274             return new Integer(byteV.intValue());
275          case INTEGER : case INT :
276             Integer integer = (Integer)object;
277             return new Integer(integer.intValue());
278          case REAL :
279             Float floatV = (Float)object;
280             return new Integer(floatV.intValue());
281          case DOUBLE : case FLOAT : case DOUBLEPRECISION :
282             Double doubleV = (Double)object;
283             return new Integer(doubleV.intValue());
284          case LONG : case BIGINT :
285             Long longV = (Long)object;
286             return new Integer(longV.intValue());
287          case SHORT : case SMALLINT :
288             Short shortV = (Short)object;
289             return new Integer(shortV.intValue());
290          case BIGDECIMAL : case DEC : case DECIMAL : case NUMERIC :
291             BigDecimal bigDecimal = (BigDecimal)object;
292             return new Integer(bigDecimal.intValue());
293          case CHARACTER :case VARCHAR: case CHAR: case CHARACTERVARYING:
294             String string = (String)object;
295             Double d = null;
296             try{
297                d = new Double(string);
298             }catch(Exception e){
299                throw new DException("DSE35",new Object[]{"character string","double"});
300             }
301             return new Integer(d.intValue());
302          default :
303             throw new DException("DSE4108",new Object[]{StaticClass.getDataTypeName(type),"COUNT"});
304       }
305      } */

306
307    private int getType(Object JavaDoc result3) throws DException {
308       String JavaDoc fieldName = (String JavaDoc) result3;
309       if (fieldName.equalsIgnoreCase("SQL_TSI_FRAC_SECOND")) {
310          return SQL_TSI_FRAC_SECOND;
311       }
312       if (fieldName.equalsIgnoreCase("SQL_TSI_SECOND")) {
313          return SQL_TSI_SECOND;
314       }
315       if (fieldName.equalsIgnoreCase("SQL_TSI_MINUTE")) {
316          return SQL_TSI_MINUTE;
317       }
318       if (fieldName.equalsIgnoreCase("SQL_TSI_HOUR")) {
319          return SQL_TSI_HOUR;
320       }
321       if (fieldName.equalsIgnoreCase("SQL_TSI_DAY")) {
322          return SQL_TSI_DAY;
323       }
324       if (fieldName.equalsIgnoreCase("SQL_TSI_WEEK")) {
325          return SQL_TSI_WEEK;
326       }
327       if (fieldName.equalsIgnoreCase("SQL_TSI_MONTH")) {
328          return SQL_TSI_MONTH;
329       }
330       if (fieldName.equalsIgnoreCase("SQL_TSI_YEAR")) {
331          return SQL_TSI_YEAR;
332       }
333       if (fieldName.equalsIgnoreCase("SQL_TSI_QUARTER")) {
334          return SQL_TSI_QUARTER;
335       }
336       throw new DException("DSE413", new Object JavaDoc[] {fieldName});
337    }
338
339    public AbstractRowValueExpression[] getChilds() {
340       AbstractRowValueExpression[] childs = new AbstractRowValueExpression[] { (AbstractRowValueExpression) (_datetimevalueexpression1), (AbstractRowValueExpression) (_datetimevalueexpression3)};
341       return childs;
342
343    }
344
345    public int getFunctionType() {
346       return TIMESTAMPFUNCTION;
347    }
348
349    public String JavaDoc toString() {
350       StringBuffer JavaDoc sb = new StringBuffer JavaDoc();
351       sb.append(" ");
352       sb.append(_SNONRESERVEDWORD1364442557);
353       sb.append(" ");
354       sb.append(_Sleftparen6538802416);
355       sb.append(" ");
356       sb.append(_timestampdenometers5);
357       sb.append(" ");
358       sb.append(_Scomma948436054);
359       sb.append(" ");
360       sb.append(_datetimevalueexpression3);
361       sb.append(" ");
362       sb.append(_Scomma948436052);
363       sb.append(" ");
364       sb.append(_datetimevalueexpression1);
365       sb.append(" ");
366       sb.append(_Srightparen_18748595140);
367       return sb.toString();
368    }
369
370    public Object JavaDoc clone() throws CloneNotSupportedException JavaDoc {
371       timestampaddfunction tempClass = new timestampaddfunction();
372       tempClass._Srightparen_18748595140 = (Srightparen_1874859514) _Srightparen_18748595140.clone();
373       tempClass._datetimevalueexpression1 = (datetimevalueexpression) _datetimevalueexpression1.clone();
374       tempClass._Scomma948436052 = (Scomma94843605) _Scomma948436052.clone();
375       tempClass._datetimevalueexpression3 = (datetimevalueexpression) _datetimevalueexpression3.clone();
376       tempClass._Scomma948436054 = (Scomma94843605) _Scomma948436054.clone();
377       tempClass._timestampdenometers5 = (timestampdenometers) _timestampdenometers5.clone();
378       tempClass._Sleftparen6538802416 = (Sleftparen653880241) _Sleftparen6538802416.clone();
379       tempClass._SNONRESERVEDWORD1364442557 = (SNONRESERVEDWORD136444255) _SNONRESERVEDWORD1364442557.clone();
380       return tempClass;
381    }
382
383    public ByteComparison getByteComparison(Object JavaDoc object) throws DException {
384      ByteComparison byteComparison = new ByteComparison(false, new int[] {TIMESTAMP});
385      byteComparison.setSize(getColumnSize(object));
386      return byteComparison;
387    }
388
389    public String JavaDoc getType() throws DException {
390       return (String JavaDoc) _SNONRESERVEDWORD1364442557.run(null);
391     }
392
393
394
395    public _Reference[] checkSemantic(_ServerSession parent) throws DException {
396       _Reference[] ref = super.checkSemantic(parent);
397       if(ref!=null) {
398         return ref;
399        }
400       int type1 = _datetimevalueexpression3.getByteComparison(parent).getDataTypes()[0];
401       int type2 = _datetimevalueexpression1.getByteComparison(parent).getDataTypes()[0];
402
403       switch (type2) {
404          case -1:
405          case TIMESTAMP:
406             switch (type1) {
407                case DATE:
408                   throw new DException("DSE419", new Object JavaDoc[] {"timestampadd"});
409                case TIME:
410                   throw new DException("DSE419", new Object JavaDoc[] {"timestampadd"});
411                case TIMESTAMP:
412                   throw new DException("DSE419", new Object JavaDoc[] {"TIMESTAMPADD"});
413                case -1:
414                default:
415                   return ref;
416             }
417          default:
418             throw new DException("DSE4108", new Object JavaDoc[] {StaticClass.getDataTypeName(type2), "timestampadd"});
419
420       }
421    }
422
423 /* public ColumnDetails[] getColumnDetails() throws DException {
424        initializeChildren();
425        if (columnDetails != null) {
426           return columnDetails;
427        }
428        ColumnDetails[][] details = new ColumnDetails[childs.length][];
429        int length = 0;
430        for (int i = 0; i < childs.length; i++) {
431           details[i] = childs[i] == null ? new ColumnDetails[0] : childs[i].getColumnDetails();
432           length += details[i].length;
433        }
434        columnDetails = new ColumnDetails[length];
435        int index = 0;
436        for (int i = 0; i < details.length; i++) {
437           ColumnDetails[] cds = (ColumnDetails[]) details[i];
438           for (int j = 0; j < cds.length; j++) {
439              columnDetails[index++] = cds[j];
440           }
441        }
442        return columnDetails;
443     } */

444
445
446     public ColumnDetails[] getColumnDetails() throws DException {
447          initializeChildren();
448          int len = childs.length;
449          column = new ColumnDetails();
450          String JavaDoc type = getType();
451          StringBuffer JavaDoc str = new StringBuffer JavaDoc();
452          str.append(type);
453          str.append("(");
454          ColumnDetails[][] cds = new ColumnDetails[len][];
455          String JavaDoc[] namesOfColumn = new String JavaDoc[len];
456          for (int i = 0; i < childs.length; i++) {
457             cds[i] = childs[i].getColumnDetails();
458             namesOfColumn[i] = getNameOfColumn(cds[i]);
459             this.columnDetails = StaticClass.mergeColumnDetails(this.columnDetails, cds[i]);
460             str.append(namesOfColumn[i]);
461             str.append(",");
462          }
463          str.deleteCharAt(str.length() - 1);
464          str.append(")");
465
466          column.setFunctionType(type);
467          column.setType(SCALARFUNCTION);
468          column.setColumnName(new String JavaDoc[] {str.toString()});
469          column.setObject(this);
470          return new ColumnDetails[] {column};
471       }
472
473       public int getColumnSize( Object JavaDoc object) throws DException {
474             return Datatypes.TIMESTAMPSIZE;
475        }
476
477
478    /*
479    public static void main(String[] args) {
480      Timestamp t = null;
481     try {
482       t = TypeValidityHandler.getTimestamp("99999999-12-31 23:59:59.999");
483     }
484     catch (DException ex1) {
485       ex1.printStackTrace();
486     }
487     try {
488       Timestamp t2 = timeStampAdd1(SQL_TSI_YEAR, 1, t);
489     }
490     catch (DException ex) {
491     }
492    }
493
494    private static Timestamp timeStampAdd1(int field, int count, Timestamp timeStamp) throws DException {
495           long sourceTime = timeStamp.getTime();
496           GregorianCalendar source = new GregorianCalendar();
497           source.setLenient(false);
498           source.setTime(new com.daffodilwoods.daffodildb.utils.DBDate(sourceTime));
499           if (field == -1) {
500              int i = source.get(SQL_TSI_MONTH);
501              i = i + (count * 3);
502              source.set(SQL_TSI_MONTH, i);
503           } else {
504              source.add(field, count);
505           }
506           try {
507             long t1 = source.getTime().getTime();
508             long maxSupportedLongTime = (new Timestamp(99998099, 11, 31, 23, 59, 59, 999000000)).getTime();
509             if (t1 > maxSupportedLongTime) {
510               throw new DException("DSE5549", null);
511             }
512           }
513           catch (IllegalArgumentException ex) {
514             throw new DException("DSE5549",null);
515           }
516           Timestamp t2 = new Timestamp(source.getTime().getTime());
517           return t2;
518    }*/

519 }
520
Popular Tags