public boolean isClob( ValueMetaInterface v ) { boolean retval = true; if ( v == null || v.getLength() < DatabaseMeta.CLOB_LENGTH ) { retval = false; } else { return true; } return retval; }
private String pad( ValueMetaInterface valueMetaInterface, String data ) { StringBuilder padding = new StringBuilder( data ); int padLength = valueMetaInterface.getLength() - data.length(); int currentPadLength = 0; while ( currentPadLength < padLength ) { padding.append( " " ); currentPadLength++; } return padding.toString(); }
public boolean tableItemInserted( TableItem tableItem, ValueMetaInterface v ) { if ( v.isNumber() ) { if ( v.getLength() > 0 ) { int le = v.getLength(); int pr = v.getPrecision(); if ( v.getPrecision() <= 0 ) { pr = 0; } String mask = " "; for ( int m = 0; m < le - pr; m++ ) { mask += "0"; } if ( pr > 0 ) { mask += "."; } for ( int m = 0; m < pr; m++ ) { mask += "0"; } tableItem.setText( 4, mask ); } } return true; } } );
public boolean tableItemInserted( TableItem tableItem, ValueMetaInterface v ) { if ( v.isNumber() ) { if ( v.getLength() > 0 ) { int le = v.getLength(); int pr = v.getPrecision(); if ( v.getPrecision() <= 0 ) { pr = 0; } String mask = " "; for ( int m = 0; m < le - pr; m++ ) { mask += "0"; } if ( pr > 0 ) { mask += "."; } for ( int m = 0; m < pr; m++ ) { mask += "0"; } tableItem.setText( 4, mask ); } } return true; } } );
@Override public boolean tableItemInserted( TableItem tableItem, ValueMetaInterface v ) { if ( v.isNumber() ) { if ( v.getLength() > 0 ) { int le = v.getLength(); int pr = v.getPrecision(); if ( v.getPrecision() <= 0 ) { pr = 0; } String mask = ""; for ( int m = 0; m < le - pr; m++ ) { mask += "0"; } if ( pr > 0 ) { mask += "."; } for ( int m = 0; m < pr; m++ ) { mask += "0"; } tableItem.setText( 3, mask ); } } return true; } };
@Override public boolean tableItemInserted( TableItem tableItem, ValueMetaInterface v ) { if ( v.isNumber() ) { if ( v.getLength() > 0 ) { int le = v.getLength(); int pr = v.getPrecision(); if ( v.getPrecision() <= 0 ) { pr = 0; } String mask = ""; for ( int m = 0; m < le - pr; m++ ) { mask += "0"; } if ( pr > 0 ) { mask += "."; } for ( int m = 0; m < pr; m++ ) { mask += "0"; } tableItem.setText( 3, mask ); } } return true; } };
@Override public boolean tableItemInserted( TableItem tableItem, ValueMetaInterface v ) { if ( v.isNumber() ) { if ( v.getLength() > 0 ) { int le = v.getLength(); int pr = v.getPrecision(); if ( v.getPrecision() <= 0 ) { pr = 0; } String mask = ""; for ( int m = 0; m < le - pr; m++ ) { mask += "0"; } if ( pr > 0 ) { mask += "."; } for ( int m = 0; m < pr; m++ ) { mask += "0"; } tableItem.setText( 3, mask ); } } return true; } };
public boolean tableItemInserted( TableItem tableItem, ValueMetaInterface v ) { tableItem.setText( 3, ContentType.Element.name() ); if ( v.isNumber() ) { if ( v.getLength() > 0 ) { int le = v.getLength(); int pr = v.getPrecision(); if ( v.getPrecision() <= 0 ) { pr = 0; } String mask = " "; for ( int m = 0; m < le - pr; m++ ) { mask += "0"; } if ( pr > 0 ) { mask += "."; } for ( int m = 0; m < pr; m++ ) { mask += "0"; } tableItem.setText( 4, mask ); } } return true; } };
protected Object[] writeToTable( RowMetaInterface rowMeta, Object[] r ) throws KettleException { // see if we need to truncate any string fields try { int index = 0; List<ValueMetaInterface> valueMetas = rowMeta.getValueMetaList(); for ( ValueMetaInterface valueMeta : valueMetas ) { Object valueData = r[index]; if ( valueData != null ) { if ( valueMeta.getType() == ValueMetaInterface.TYPE_STRING ) { String str = valueMeta.getString( valueData ); int len = valueMeta.getLength(); if ( len < 1 ) { len = MonetDBDatabaseMeta.DEFAULT_VARCHAR_LENGTH; } if ( str.length() > len ) { // TODO log this event str = str.substring( 0, len ); } r[index] = str; } } index++; } } catch ( Exception e ) { throw new KettleException( "Error serializing rows of data to the psql command", e ); } return super.writeToTable( rowMeta, r ); }
/** * Produce the XML representation of this value. * * @return a String containing the XML to represent this Value. * @throws KettleValueException * in case there is a data conversion error, only throws in case of lazy conversion */ public String getXML() throws KettleValueException { ValueMetaInterface meta = valueMeta.clone(); meta.setDecimalSymbol( "." ); meta.setGroupingSymbol( null ); meta.setCurrencySymbol( null ); StringBuilder retval = new StringBuilder( 128 ); retval.append( "<" + XML_TAG + ">" ); retval.append( XMLHandler.addTagValue( "name", meta.getName(), false ) ); retval.append( XMLHandler.addTagValue( "type", meta.getTypeDesc(), false ) ); try { retval.append( XMLHandler.addTagValue( "text", meta.getCompatibleString( valueData ), false ) ); } catch ( KettleValueException e ) { // LogWriter.getInstance().logError(toString(), Const.getStackTracker(e)); retval.append( XMLHandler.addTagValue( "text", "", false ) ); } retval.append( XMLHandler.addTagValue( "length", meta.getLength(), false ) ); retval.append( XMLHandler.addTagValue( "precision", meta.getPrecision(), false ) ); retval.append( XMLHandler.addTagValue( "isnull", meta.isNull( valueData ), false ) ); retval.append( XMLHandler.addTagValue( "mask", meta.getConversionMask(), false ) ); retval.append( "</" + XML_TAG + ">" ); return retval.toString(); }
public static ValueMetaInterface cloneValueMeta( ValueMetaInterface source, int targetType ) throws KettlePluginException { ValueMetaInterface target = null; // If we're Cloneable and not changing types, call clone() if ( source.getType() == targetType ) { target = source.clone(); } else { target = createValueMeta( source.getName(), targetType, source.getLength(), source.getPrecision() ); } cloneInfo( source, target ); return target; }
@Override public boolean tableItemInserted( TableItem tableItem, ValueMetaInterface v ) { if ( Const.indexOfString( v.getName(), groupingFields ) < 0 ) { // Not a grouping field if ( !wKeyField.getText().equalsIgnoreCase( v.getName() ) ) { // Not the key field int nr = tableItem.getParent().indexOf( tableItem ) + 1; tableItem.setText( 1, BaseMessages.getString( PKG, "DenormaliserDialog.TargetFieldname.Label" ) + nr ); // the target fieldname tableItem.setText( 2, v.getName() ); tableItem.setText( 4, v.getTypeDesc() ); if ( v.getLength() >= 0 ) { tableItem.setText( 6, "" + v.getLength() ); } if ( v.getPrecision() >= 0 ) { tableItem.setText( 7, "" + v.getPrecision() ); } } } return true; } } );
private byte[] formatField( ValueMetaInterface v, Object valueData ) throws KettleValueException { if ( v.isString() ) { if ( v.isStorageBinaryString() && v.getTrimType() == ValueMetaInterface.TRIM_TYPE_NONE && v.getLength() < 0 && Utils.isEmpty( v.getStringEncoding() ) ) { return (byte[]) valueData; } else { String svalue = ( valueData instanceof String ) ? (String) valueData : v.getString( valueData ); return convertStringToBinaryString( v, Const.trimToType( svalue, v.getTrimType() ) ); } } else { return v.getBinaryString( valueData ); } }
@Override public ValueMetaInterface getMetadataPreview( DatabaseMeta databaseMeta, ResultSet rs ) throws KettleDatabaseException { try { if ( "INET".equalsIgnoreCase( rs.getString( "TYPE_NAME" ) ) ) { ValueMetaInterface vmi = super.getMetadataPreview( databaseMeta, rs ); ValueMetaInterface valueMeta = new ValueMetaInternetAddress( 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; }
private void createStepFieldNodes() { if ( this.rowMetaInterface == null ) { String theSql = this.databaseMeta.getSQLQueryFields( this.schemaTableCombo ); GetQueryFieldsProgressDialog theProgressDialog = new GetQueryFieldsProgressDialog( this.shell, this.databaseMeta, theSql ); this.rowMetaInterface = theProgressDialog.open(); } this.model.setStepName( "Step name:" + this.schemaTableCombo ); if ( this.rowMetaInterface != null ) { StepFieldNode theStep = null; for ( int i = 0; i < this.rowMetaInterface.size(); i++ ) { theStep = new StepFieldNode(); ValueMetaInterface theMetaInterface = this.rowMetaInterface.getValueMeta( i ); theStep.setFieldName( theMetaInterface.getName() ); theStep.setType( theMetaInterface.getTypeDesc() ); theStep.setLength( Integer.toString( theMetaInterface.getLength() ) ); theStep.setPrecision( Integer.toString( theMetaInterface.getPrecision() ) ); theStep.setOrigin( theMetaInterface.getOrigin() ); theStep.setStorageType( Integer.toString( theMetaInterface.getStorageType() ) ); theStep.setConversionMask( theMetaInterface.getConversionMask() ); theStep.setDecimalSymbol( theMetaInterface.getDecimalSymbol() ); theStep.setGroupingSymbol( theMetaInterface.getGroupingSymbol() ); theStep.setTrimType( Integer.toString( theMetaInterface.getTrimType() ) ); theStep.setComments( theMetaInterface.getComments() ); this.model.addStepField( theStep ); } } }
@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 void saveRep( Repository rep, ObjectId id_transformation, ObjectId id_step ) throws KettleException { try { rep.saveStepAttribute( id_transformation, id_step, "value_name", value.getValueMeta().getName() ); rep.saveStepAttribute( id_transformation, id_step, 0, "value_type", value.getValueMeta().getTypeDesc() ); rep.saveStepAttribute( id_transformation, id_step, 0, "value_text", value.getValueMeta().getString( value.getValueData() ) ); rep.saveStepAttribute( id_transformation, id_step, 0, "value_null", value.getValueMeta().isNull( value.getValueData() ) ); rep.saveStepAttribute( id_transformation, id_step, 0, "value_length", value.getValueMeta().getLength() ); rep.saveStepAttribute( id_transformation, id_step, 0, "value_precision", value.getValueMeta().getPrecision() ); } catch ( KettleDatabaseException dbe ) { throw new KettleException( "Unable to save step information to the repository, id_step=" + id_step, dbe ); } }
@Override public void getFields( RowMetaInterface inputRowMeta, String name, RowMetaInterface[] info, StepMeta nextStep, VariableSpace space, Repository repository, IMetaStore metaStore ) throws KettleStepException { // Add new field? for ( int i = 0; i < fieldOutStream.length; i++ ) { if ( !Utils.isEmpty( fieldOutStream[i] ) ) { int index = inputRowMeta.indexOfValue( fieldInStream[i] ); if ( index >= 0 ) { ValueMetaInterface in = inputRowMeta.getValueMeta( index ); try { ValueMetaInterface v = ValueMetaFactory.createValueMeta( space.environmentSubstitute( fieldOutStream[i] ), in.getType() ); v.setName( space.environmentSubstitute( fieldOutStream[i] ) ); v.setLength( in.getLength() ); v.setPrecision( in.getPrecision() ); v.setConversionMask( in.getConversionMask() ); v.setOrigin( name ); inputRowMeta.addValueMeta( v ); } catch ( Exception e ) { throw new KettleStepException( e ); } } } } }
/** * Copy information from the meta-data input to the dialog fields. */ public void getData() { int i; for ( i = 0; i < input.size(); i++ ) { TableItem item = wFields.table.getItem( i ); ValueMetaInterface v = input.getValueMeta( i ); int idx = 1; if ( v.getName() != null ) { item.setText( idx++, v.getName() ); } item.setText( idx++, v.getTypeDesc() ); item.setText( idx++, v.getLength() < 0 ? "-" : "" + v.getLength() ); item.setText( idx++, v.getPrecision() < 0 ? "-" : "" + v.getPrecision() ); item.setText( idx++, Const.NVL( v.getOrigin(), "" ) ); item.setText( idx++, ValueMetaBase.getStorageTypeCode( v.getStorageType() ) ); item.setText( idx++, Const.NVL( v.getConversionMask(), "" ) ); item.setText( idx++, Const.NVL( v.getCurrencySymbol(), "" ) ); item.setText( idx++, Const.NVL( v.getDecimalSymbol(), "" ) ); item.setText( idx++, Const.NVL( v.getGroupingSymbol(), "" ) ); item.setText( idx++, ValueMetaBase.getTrimTypeDesc( v.getTrimType() ) ); item.setText( idx++, Const.NVL( v.getComments(), "" ) ); } wFields.optWidth( true ); }
static StepMeta getInjectorStepMeta( RowMetaInterface outputRowMeta ) { InjectorMeta zeroMeta = new InjectorMeta(); // Sets output fields for cases when no rows are sent to the test step, but metadata is still needed if ( outputRowMeta != null && outputRowMeta.size() > 0 ) { String[] fieldName = new String[outputRowMeta.size()]; int[] fieldLength = new int[outputRowMeta.size()]; int[] fieldPrecision = new int[outputRowMeta.size()]; int[] fieldType = new int[outputRowMeta.size()]; for ( int i = 0; i < outputRowMeta.size(); i++ ) { ValueMetaInterface field = outputRowMeta.getValueMeta( i ); fieldName[i] = field.getName(); fieldLength[i] = field.getLength(); fieldPrecision[i] = field.getPrecision(); fieldType[i] = field.getType(); } zeroMeta.setFieldname( fieldName ); zeroMeta.setLength( fieldLength ); zeroMeta.setPrecision( fieldPrecision ); zeroMeta.setType( fieldType ); } StepMeta zero = new StepMeta( registry.getPluginId( StepPluginType.class, zeroMeta ), INJECTOR_STEPNAME, zeroMeta ); zero.setLocation( 50, 50 ); zero.setDraw( true ); return zero; }