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 ; 17 import java.util.Arrays ; 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 run(Object object) throws com.daffodilwoods.database.resource.DException { 31 FieldBase result1 = (FieldBase) _datetimevalueexpression3.run(object); if (result1.isNull()) { 33 return new FieldTimeStampLiteral(FieldUtility.NULLBUFFERRANGE); 34 } 35 FieldBase result2 = (FieldBase) _datetimevalueexpression1.run(object); 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 result3 = _timestampdenometers5.run(object); 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 list =new ArrayList (); 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 getNameOfColumn(ColumnDetails[] columnDetails) throws DException { 91 String nameOfColumn = ""; 92 for (int i = 0; i < columnDetails.length; ++i) { 93 nameOfColumn += columnDetails[i].getColumn(); 94 } 95 return nameOfColumn; 96 } 97 98 122 123 public ColumnDetails[] getChildColumnDetails() throws DException { 124 return columnDetails; 125 } 126 127 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 ex) { 183 throw new DException("DSE5549",null); 184 } 185 Timestamp t2 = new Timestamp(source.getTime().getTime()); 186 return t2; 187 } 188 189 private Object getResult(int type1, int type2, Object result1, Object result2, int field) throws DException { 190 switch (type2) { 191 case CHARACTER: 192 case VARCHAR: 193 case CHAR: 194 case CHARACTERVARYING: 195 String string = (String )result2; 196 try { 197 Timestamp timestamp = TypeValidityHandler.getTimestamp(string); 198 switch (type1) { 199 case DATE: 200 throw new DException("DSE419", new Object [] {"TIMESTAMPADD"}); 201 case TIME: 202 throw new DException("DSE419", new Object [] {"TIMESTAMPADD"}); 203 case TIMESTAMP: 204 throw new DException("DSE419", new Object [] {"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 [] {"TIMESTAMPADD"}); 213 } 214 case TIMESTAMP: 215 Timestamp timestamp = (Timestamp) result2; 216 switch (type1) { 217 case DATE: 218 throw new DException("DSE419", new Object [] {"timestampadd"}); 219 case TIME: 220 throw new DException("DSE419", new Object [] {"timestampadd"}); 221 case TIMESTAMP: 222 throw new DException("DSE419", new Object [] {"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 [] {StaticClass.getDataTypeName(type2), "timestampadd"}); 230 } 231 } 232 233 private Integer getCount(Object 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 operand = (Number ) object; 252 return new Integer (operand.intValue()); 253 case CHARACTER: 254 case VARCHAR: 255 case CHAR: 256 case CHARACTERVARYING: 257 String string = (String ) object; 258 Double d = null; 259 try { 260 d = new Double (string); 261 } catch (Exception e) { 262 throw new DException("DSE35", new Object [] {"character string", "double"}); 263 } 264 return new Integer (d.intValue()); 265 default: 266 throw new DException("DSE4108", new Object [] {StaticClass.getDataTypeName(type), "COUNT"}); 267 } 268 } 269 270 306 307 private int getType(Object result3) throws DException { 308 String fieldName = (String ) 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 [] {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 toString() { 350 StringBuffer sb = new StringBuffer (); 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 clone() throws CloneNotSupportedException { 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 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 getType() throws DException { 390 return (String ) _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 [] {"timestampadd"}); 409 case TIME: 410 throw new DException("DSE419", new Object [] {"timestampadd"}); 411 case TIMESTAMP: 412 throw new DException("DSE419", new Object [] {"TIMESTAMPADD"}); 413 case -1: 414 default: 415 return ref; 416 } 417 default: 418 throw new DException("DSE4108", new Object [] {StaticClass.getDataTypeName(type2), "timestampadd"}); 419 420 } 421 } 422 423 444 445 446 public ColumnDetails[] getColumnDetails() throws DException { 447 initializeChildren(); 448 int len = childs.length; 449 column = new ColumnDetails(); 450 String type = getType(); 451 StringBuffer str = new StringBuffer (); 452 str.append(type); 453 str.append("("); 454 ColumnDetails[][] cds = new ColumnDetails[len][]; 455 String [] namesOfColumn = new String [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 [] {str.toString()}); 469 column.setObject(this); 470 return new ColumnDetails[] {column}; 471 } 472 473 public int getColumnSize( Object object) throws DException { 474 return Datatypes.TIMESTAMPSIZE; 475 } 476 477 478 519 } 520 | Popular Tags |