@Override public Date getDate( Object object ) throws KettleValueException { Timestamp timestamp = getTimestamp( object ); if ( timestamp == null ) { return null; } return timestamp; }
@Override public byte[] getBinaryString( Object object ) throws KettleValueException { if ( object == null ) { return null; } if ( isStorageBinaryString() && identicalFormat ) { return (byte[]) object; // shortcut it directly for better performance. } switch ( storageType ) { case STORAGE_TYPE_NORMAL: return convertStringToBinaryString( getString( object ) ); case STORAGE_TYPE_BINARY_STRING: return convertStringToBinaryString( (String) convertBinaryStringToNativeType( (byte[]) object ) ); case STORAGE_TYPE_INDEXED: return convertStringToBinaryString( getString( index[( (Integer) object ).intValue()] ) ); default: throw new KettleValueException( toString() + " : Unknown storage type " + storageType + " specified." ); } }
case STORAGE_TYPE_NORMAL: Timestamp timestamp = convertDateToTimestamp( (Date) object ); writeBinaryString( outputStream, (byte[]) object ); break; writeInteger( outputStream, (Integer) object ); // just an index break; throw new KettleFileException( toString() + " : Unknown storage type " + getStorageType() ); throw new RuntimeException( toString() + " : There was a data type error: the data type of " + object.getClass().getName() + " object [" + object + "] does not correspond to value meta [" + toStringMeta() + "]" ); } catch ( IOException e ) { throw new KettleFileException( toString() + " : Unable to write value timestamp data to output stream", e ); } catch ( KettleValueException e ) { throw new RuntimeException( toString() + " : There was a data type error: the data type of " + object.getClass().getName() + " object [" + object + "] does not correspond to value meta [" + toStringMeta() + "]" );
@Override public String getString( Object object ) throws KettleValueException { return convertTimestampToString( getTimestamp( object ) ); }
public int compare( Object data1, Object data2 ) throws KettleValueException { Timestamp timestamp1 = getTimestamp( data1 ); Timestamp timestamp2 = getTimestamp( data2 ); int cmp = 0; if ( timestamp1 == null ) { if ( timestamp2 == null ) { cmp = 0; } else { cmp = -1; } } else if ( timestamp2 == null ) { cmp = 1; } else { cmp = timestamp1.compareTo( timestamp2 ); } if ( isSortedDescending() ) { return -cmp; } else { return cmp; } }
/** * Convert the specified data to the data type specified in this object. * * @param meta2 * the metadata of the object to be converted * @param data2 * the data of the object to be converted * @return the object in the data type of this value metadata object * @throws KettleValueException * in case there is a data conversion error */ @Override public Object convertData( ValueMetaInterface meta2, Object data2 ) throws KettleValueException { switch ( meta2.getType() ) { case TYPE_TIMESTAMP: return ( (ValueMetaTimestamp) meta2 ).getTimestamp( data2 ); case TYPE_STRING: return convertStringToTimestamp( meta2.getString( data2 ) ); case TYPE_INTEGER: return convertIntegerToTimestamp( meta2.getInteger( data2 ) ); case TYPE_NUMBER: return convertNumberToTimestamp( meta2.getNumber( data2 ) ); case TYPE_DATE: return convertDateToTimestamp( meta2.getDate( data2 ) ); case TYPE_BIGNUMBER: return convertBigNumberToTimestamp( meta2.getBigNumber( data2 ) ); default: throw new KettleValueException( meta2.toStringMeta() + " : can't be converted to a timestamp" ); } }
@Test public void getTimestamp_Test() throws Exception { ValueMetaTimestamp v = new ValueMetaTimestamp( "TS" ); RowMetaInterface row = mock( RowMetaInterface.class ); doReturn( v ).when( row ).searchValueMeta( anyString() ); doReturn( 0 ).when( row ).indexOfValue( anyString() ); assertEquals( Timestamp.valueOf( "2018-07-23 12:40:55" ), new FieldHelper( row, "TS" ).getTimestamp( new Object[] { Timestamp.valueOf( "2018-07-23 12:40:55" ) } ) ); }
return (Timestamp) object; case STORAGE_TYPE_BINARY_STRING: return (Timestamp) convertBinaryStringToNativeType( (byte[]) object ); case STORAGE_TYPE_INDEXED: return (Timestamp) index[( (Integer) object ).intValue()]; default: throw new KettleValueException( toString() + " : Unknown storage type " + storageType + " specified." ); return convertStringToTimestamp( (String) object ); case STORAGE_TYPE_BINARY_STRING: return convertStringToTimestamp( (String) convertBinaryStringToNativeType( (byte[]) object ) ); case STORAGE_TYPE_INDEXED: return convertStringToTimestamp( (String) index[( (Integer) object ).intValue()] ); default: throw new KettleValueException( toString() + " : Unknown storage type " + storageType + " specified." ); return convertNumberToTimestamp( (Double) object ); case STORAGE_TYPE_BINARY_STRING: return convertNumberToTimestamp( (Double) convertBinaryStringToNativeType( (byte[]) object ) ); case STORAGE_TYPE_INDEXED: return convertNumberToTimestamp( (Double) index[( (Integer) object ).intValue()] ); default: throw new KettleValueException( toString() + " : Unknown storage type " + storageType + " specified." ); return convertIntegerToTimestamp( (Long) object ); case STORAGE_TYPE_BINARY_STRING: return convertIntegerToTimestamp( (Long) convertBinaryStringToNativeType( (byte[]) object ) ); case STORAGE_TYPE_INDEXED: return convertIntegerToTimestamp( (Long) index[( (Integer) object ).intValue()] );
@Override public void setPreparedStatementValue( DatabaseMeta databaseMeta, PreparedStatement preparedStatement, int index, Object data ) throws KettleDatabaseException { try { if ( data != null ) { preparedStatement.setTimestamp( index, getTimestamp( data ) ); } else { preparedStatement.setNull( index, java.sql.Types.TIMESTAMP ); } } catch ( Exception e ) { throw new KettleDatabaseException( toStringMeta() + " : Unable to set value on prepared statement on index " + index, e ); } }
@Override public ValueMetaInterface getValueFromSQLType( DatabaseMeta databaseMeta, String name, ResultSetMetaData rm, int index, boolean ignoreLength, boolean lazyConversion ) throws KettleDatabaseException { try { int type = rm.getColumnType( index ); if ( type == java.sql.Types.TIMESTAMP ) { int length = rm.getScale( index ); ValueMetaInterface valueMeta; if ( databaseMeta.supportsTimestampDataType() ) { valueMeta = new ValueMetaTimestamp( name ); } else { valueMeta = new ValueMetaDate( name ); } valueMeta.setLength( length ); // Also get original column details, comment, etc. // getOriginalColumnMetadata( valueMeta, rm, index, ignoreLength ); return valueMeta; } return null; } catch ( Exception e ) { throw new KettleDatabaseException( "Error evaluating timestamp value metadata", e ); } }
protected Timestamp convertNumberToTimestamp( Double d ) { if ( d == null ) { return null; } long nanos = d.longValue(); return convertIntegerToTimestamp( nanos ); }
return convertData( convertMeta, pol );
valueMeta = new ValueMetaBinary(); } else if ( type.equals( "Timestamp" ) ) { valueMeta = new ValueMetaTimestamp(); } else if ( type.equals( "Internet Address" ) ) { valueMeta = new ValueMetaInternetAddress();
protected Timestamp convertBigNumberToTimestamp( BigDecimal bd ) { if ( bd == null ) { return null; } return convertIntegerToTimestamp( bd.longValue() ); }
@Test public void getNativeDataTypeSimpleName_Timestamp() { ValueMetaTimestamp v = new ValueMetaTimestamp(); assertEquals( "Timestamp", FieldHelper.getNativeDataTypeSimpleName( v ) ); }
public Timestamp getTimestamp( Object[] dataRow ) throws KettleValueException { return ( (ValueMetaTimestamp) meta ).getTimestamp( dataRow[index] ); }
@Test public void getGetSignature_Timestamp() { ValueMetaTimestamp v = new ValueMetaTimestamp( "TS" ); String accessor = FieldHelper.getAccessor( true, "TS" ); assertEquals( "Timestamp TS = get(Fields.In, \"TS\").getTimestamp(r);", FieldHelper.getGetSignature( accessor, v ) ); assertNotNull( getMethod( FieldHelper.class, "getTimestamp", Object[].class ) ); }
@Override public Long getInteger( Object object ) throws KettleValueException { Timestamp timestamp = getTimestamp( object ); if ( timestamp == null ) { return null; } long ms = timestamp.getTime(); return ms; }
@Override public ValueMetaInterface getMetadataPreview( DatabaseMeta databaseMeta, ResultSet rs ) throws KettleDatabaseException { try { if ( java.sql.Types.TIMESTAMP == rs.getInt( "COLUMN_TYPE" ) ) { ValueMetaInterface vmi = super.getMetadataPreview( databaseMeta, rs ); ValueMetaInterface valueMeta; if ( databaseMeta.supportsTimestampDataType() ) { valueMeta = new ValueMetaTimestamp( name ); } else { valueMeta = new ValueMetaDate( name ); } valueMeta.setLength( vmi.getLength() ); valueMeta.setOriginalColumnType( vmi.getOriginalColumnType() ); valueMeta.setOriginalColumnTypeName( vmi.getOriginalColumnTypeName() ); valueMeta.setOriginalNullable( vmi.getOriginalNullable() ); valueMeta.setOriginalPrecision( vmi.getOriginalPrecision() ); valueMeta.setOriginalScale( vmi.getOriginalScale() ); valueMeta.setOriginalSigned( vmi.getOriginalSigned() ); return valueMeta; } } catch ( SQLException e ) { throw new KettleDatabaseException( e ); } return null; }
@Override public Double getNumber( Object object ) throws KettleValueException { Timestamp timestamp = getTimestamp( object ); if ( timestamp == null ) { return null; } long ms = timestamp.getTime(); return Long.valueOf( ms ).doubleValue(); }