Java ValueMetaInterface.convertData方法代码示例

import org.pentaho.di.core.row.ValueMetaInterface; //导入方法依赖的package包/类
@Override
public Row getRow() {
    final DataSetHeader header = getHeader();
    final Object[] values = new Object[header.size()];

    if (row != null) {
        for (int i = 0; i < header.size(); i++) {
            final Column column = header.getSelectItem(i).getColumn();
            final int kettleIndex = rowMeta.indexOfValue(column.getName());
            final Object rawValue = row[kettleIndex];
            try {
                final ValueMetaInterface valueMeta = rowMeta.getValueMeta(kettleIndex);
                values[i] = valueMeta.convertData(valueMeta, rawValue);
            } catch (KettleValueException e) {
                throw new MetaModelException(e);
            }
        }
    }

    return new DefaultRow(header, values);
}
 

import org.pentaho.di.core.row.ValueMetaInterface; //导入方法依赖的package包/类
private void getSessionVariablesData() throws KettleException {
  data.outputRowMeta = data.inputRowMeta.clone();
  meta.getFields( data.outputRowMeta, getStepname(), null, null, this, repository, metaStore );

  // convert the data to the desired data type
  data.conversionMeta = data.outputRowMeta.cloneToType( ValueMetaInterface.TYPE_STRING );
  data.extraData = new Object[ meta.getFieldName().length ];
  for ( int i = 0; i < meta.getFieldName().length; i++ ) {
    ValueMetaInterface targetMeta = data.outputRowMeta.getValueMeta( data.inputRowMeta.size() + i );
    ValueMetaInterface sourceMeta = data.conversionMeta.getValueMeta( data.inputRowMeta.size() + i );
    data.extraData[ i ] =
      targetMeta.convertData( sourceMeta, getValue( meta.getVariableName()[ i ], getRowDefaultValue( i ) ) );
  }
}
 

import org.pentaho.di.core.row.ValueMetaInterface; //导入方法依赖的package包/类
private void setValueToRow(String value, int fieldnr) throws KettleValueException {
	
	XMLInputSaxField xmlInputField = (XMLInputSaxField) fields.get(fieldnr);

	switch (xmlInputField.getTrimType())
	{
	case XMLInputSaxField.TYPE_TRIM_LEFT:
		value = Const.ltrim(value);
		break;
	case XMLInputSaxField.TYPE_TRIM_RIGHT:
		value = Const.rtrim(value);
		break;
	case XMLInputSaxField.TYPE_TRIM_BOTH:
		value = Const.trim(value);
		break;
	default:
		break;
	}

	// DO CONVERSIONS...
	ValueMetaInterface targetValueMeta = data.outputRowMeta.getValueMeta(fieldnr);
	ValueMetaInterface sourceValueMeta = data.convertRowMeta.getValueMeta(fieldnr);
	row[fieldnr] = targetValueMeta.convertData(sourceValueMeta, value);

	// Do we need to repeat this field if it is null?
	if (xmlInputField.isRepeated())
	{
		if (row[fieldnr]==null && data.previousRow != null)
		{
			Object previous = data.previousRow[fieldnr];
			row[fieldnr] = previous;
		}
	}
}
 

import org.pentaho.di.core.row.ValueMetaInterface; //导入方法依赖的package包/类
private void updateField(Object[] r) throws Exception
{
	// Loop through fields
	for(int i=0;i<data.fieldnr;i++)
	{		
		// DO CONVERSION OF THE DEFAULT VALUE ...
		// Entered by user
		ValueMetaInterface targetValueMeta = data.outputRowMeta.getValueMeta(i);
		ValueMetaInterface sourceValueMeta = data.convertRowMeta.getValueMeta(i);
		if(!Const.isEmpty(meta.getReplaceMask()[i])) sourceValueMeta.setConversionMask(meta.getReplaceMask()[i]);
		r[i] = targetValueMeta.convertData(sourceValueMeta, data.realReplaceByvalues[i]);
	}
}
 

import org.pentaho.di.core.row.ValueMetaInterface; //导入方法依赖的package包/类
public void replaceNull(Object[] row, int i) throws Exception
{
	if(row[i]==null) 
	{
		// DO CONVERSION OF THE DEFAULT VALUE ...
		// Entered by user
		ValueMetaInterface targetValueMeta = data.outputRowMeta.getValueMeta(i);
		ValueMetaInterface sourceValueMeta = data.convertRowMeta.getValueMeta(i);
		if(!Const.isEmpty(data.realconversionMask)) sourceValueMeta.setConversionMask(data.realconversionMask);
		row[i] = targetValueMeta.convertData(sourceValueMeta, data.realReplaceByValue);
	 }
}
 

import org.pentaho.di.core.row.ValueMetaInterface; //导入方法依赖的package包/类
private void updateField(Object[] r) throws Exception
{
	// Loop through fields
	for(int i=0;i<data.fieldnr;i++)
	{		
		// DO CONVERSION OF THE DEFAULT VALUE ...
		// Entered by user
		ValueMetaInterface targetValueMeta = data.outputRowMeta.getValueMeta(data.fieldnrs[i]);
		ValueMetaInterface sourceValueMeta = data.convertRowMeta.getValueMeta(data.fieldnrs[i]);
		if(!Const.isEmpty(meta.getReplaceMask()[i])) sourceValueMeta.setConversionMask(meta.getReplaceMask()[i]);
		r[data.fieldnrs[i]] = targetValueMeta.convertData(sourceValueMeta, data.realReplaceByvalues[i]);
	}
}
 

import org.pentaho.di.core.row.ValueMetaInterface; //导入方法依赖的package包/类
public void replaceNull(Object[] row, ValueMetaInterface sourceValueMeta, int i, String realReplaceByValue, String realconversionMask) throws Exception
{
	// DO CONVERSION OF THE DEFAULT VALUE ...
	// Entered by user
	ValueMetaInterface targetValueMeta = data.outputRowMeta.getValueMeta(i);
	if(!Const.isEmpty(realconversionMask)) sourceValueMeta.setConversionMask(realconversionMask);
	row[i] = targetValueMeta.convertData(sourceValueMeta, realReplaceByValue);
}
 

import org.pentaho.di.core.row.ValueMetaInterface; //导入方法依赖的package包/类
/**
 * Generate some random rows to send to python in the case where a single variable (data frame) is being extracted
 * and we want to try and determine the types of the output fields
 *
 * @param inputMeta incoming row meta
 * @param r         Random instance to use
 * @return a list of randomly generated rows with types matching the incoming row types.
 * @throws KettleException if a problem occurs
 */
protected static List<Object[]> generateRandomRows( RowMetaInterface inputMeta, Random r ) throws KettleException {
  List<Object[]> rows = new ArrayList<Object[]>( NUM_RANDOM_ROWS );
  // ValueMetaInterface numericVM = new ValueMeta( "num", ValueMetaInterface.TYPE_NUMBER ); //$NON-NLS-1$
  ValueMetaInterface numericVM = ValueMetaFactory.createValueMeta( "num", ValueMetaInterface.TYPE_NUMBER ); //$NON-NLS-1$

  for ( int i = 0; i < NUM_RANDOM_ROWS; i++ ) {
    Object[] currentRow = new Object[inputMeta.size()];
    for ( int j = 0; j < inputMeta.size(); j++ ) {
      ValueMetaInterface vm = inputMeta.getValueMeta( j );

      ValueMetaInterface tempVM = vm.clone();
      tempVM.setStorageType( ValueMetaInterface.STORAGE_TYPE_NORMAL );

      Object newVal;
      double d = r.nextDouble();
      switch ( vm.getType() ) {
        case ValueMetaInterface.TYPE_NUMBER:
        case ValueMetaInterface.TYPE_INTEGER:
        case ValueMetaInterface.TYPE_BIGNUMBER:
          d *= 100.0;
          newVal = d;
          if ( vm.getStorageType() == ValueMetaInterface.STORAGE_TYPE_BINARY_STRING ) {
            newVal = tempVM.convertData( numericVM, newVal );
          }
          currentRow[j] =
              vm.getStorageType() == ValueMetaInterface.STORAGE_TYPE_NORMAL ? vm.convertData( numericVM, newVal ) :
                  tempVM.convertToBinaryStringStorageType( newVal );
          break;
        case ValueMetaInterface.TYPE_DATE:
          newVal = new Date( new Date().getTime() + (long) ( d * 100000 ) );
          currentRow[j] =
              vm.getStorageType() == ValueMetaInterface.STORAGE_TYPE_NORMAL ? newVal :
                  tempVM.convertToBinaryStringStorageType( newVal );
          break;
        case ValueMetaInterface.TYPE_TIMESTAMP:
          newVal = new Timestamp( new Date().getTime() + (long) ( d * 100000 ) );
          currentRow[j] =
              vm.getStorageType() == ValueMetaInterface.STORAGE_TYPE_NORMAL ? newVal :
                  tempVM.convertToBinaryStringStorageType( newVal );
          break;
        case ValueMetaInterface.TYPE_BOOLEAN:
          newVal = r.nextBoolean();
          currentRow[j] =
              vm.getStorageType() == ValueMetaInterface.STORAGE_TYPE_NORMAL ? newVal :
                  tempVM.convertToBinaryStringStorageType( newVal );
          break;
        default:
          newVal = d < 0.5 ? "value1" : "value2";
          currentRow[j] =
              vm.getStorageType() == ValueMetaInterface.STORAGE_TYPE_NORMAL ? newVal :
                  tempVM.convertToBinaryStringStorageType( newVal );
      }
    }
    rows.add( currentRow );
  }
  return rows;
}
 

import org.pentaho.di.core.row.ValueMetaInterface; //导入方法依赖的package包/类
private Object getRowDataValue(final String fieldName, final ValueMetaInterface targetValueMeta, final ValueMetaInterface sourceValueMeta, final Object value, final DateFormat df) throws KettleException
{
    if (value == null) {
        return value;
    }

    if (ValueMetaInterface.TYPE_STRING == targetValueMeta.getType()) {
        return targetValueMeta.convertData(sourceValueMeta, value.toString());
    }
    
    if (ValueMetaInterface.TYPE_NUMBER == targetValueMeta.getType()) {
        return targetValueMeta.convertData(sourceValueMeta, Double.valueOf(value.toString()));
    }
    
    if (ValueMetaInterface.TYPE_INTEGER == targetValueMeta.getType()) {
        return targetValueMeta.convertData(sourceValueMeta, Long.valueOf(value.toString()));
    }
    
    if (ValueMetaInterface.TYPE_BIGNUMBER == targetValueMeta.getType()) {
        return targetValueMeta.convertData(sourceValueMeta, new BigDecimal(value.toString()));
    }
    
    if (ValueMetaInterface.TYPE_BOOLEAN == targetValueMeta.getType()) {
        return targetValueMeta.convertData(sourceValueMeta, Boolean.valueOf(value.toString()));
    }
    
    if (ValueMetaInterface.TYPE_BINARY == targetValueMeta.getType()) {
        return targetValueMeta.convertData(sourceValueMeta, value);
    }

    if (ValueMetaInterface.TYPE_DATE == targetValueMeta.getType()) {
        try {
            return targetValueMeta.convertData(sourceValueMeta, df.parse(value.toString()));
        } catch (final ParseException e) {
            throw new KettleValueException("Unable to convert data type of value");
        }
    }

    if (value instanceof JSONObject || value instanceof JSONArray) {
        return targetValueMeta.convertData(targetValueMeta, "{" + fieldName + ":" + value.toString() + "}");
    }

    throw new KettleValueException("Unable to convert data type of value");
}
 

import org.pentaho.di.core.row.ValueMetaInterface; //导入方法依赖的package包/类
public boolean processRow(StepMetaInterface smi, StepDataInterface sdi) throws KettleException
{
	Object[] rowData;
	
	if (data.readsRows)
	{
		rowData = getRow();
		if (rowData==null)
		{
			setOutputDone();
			return false;
		}
	}
	else
	{
		rowData=RowDataUtil.allocateRowData(0);
		incrementLinesRead();
	}
	
	// initialize 
	if (first && rowData!=null)
	{
		first=false;
		
           
           // Make output meta data
		//
		if (data.readsRows) {
			data.inputRowMeta = getInputRowMeta();
		}
		else {
			data.inputRowMeta = new RowMeta();
		}
           data.outputRowMeta = data.inputRowMeta.clone();
           meta.getFields(data.outputRowMeta, getStepname(), null, null, this);
           
           // Create a copy of the output row metadata to do the data conversion...
           //
           data.conversionMeta = data.outputRowMeta.clone();
           for (ValueMetaInterface valueMeta : data.conversionMeta.getValueMetaList()) {
           	valueMeta.setType(ValueMetaInterface.TYPE_STRING);
           }

           // Add the variables to the row...
           //
           // Keep the Object[] for speed.  Although this step will always be used in "small" amounts, there's always going to be those cases where performance is required.
           // 
           data.extraData = new Object[meta.getFieldName().length];
           for (int i=0;i<meta.getFieldName().length;i++)
           {
           	String newValue = environmentSubstitute(meta.getVariableString()[i]);
           	if (log.isDetailed()) logDetailed("field ["+meta.getFieldName()[i]+"] has value ["+newValue+"]");
           	
           	// Convert the data to the desired data type...
           	//
           	ValueMetaInterface targetMeta = data.outputRowMeta.getValueMeta(data.inputRowMeta.size()+i);
           	ValueMetaInterface sourceMeta = data.conversionMeta.getValueMeta(data.inputRowMeta.size()+i); // String type + conversion masks, symbols, trim type, etc
           	data.extraData[i] = targetMeta.convertData(sourceMeta, newValue);
           }
	}
	
       rowData = RowDataUtil.addRowData(rowData, data.inputRowMeta.size(), data.extraData);
       
       putRow(data.outputRowMeta, rowData);		     
				
       if (!data.readsRows) // Just one row and then stop!
       {
           setOutputDone();
           return false;
       }
       
	return true;
}
 

import org.pentaho.di.core.row.ValueMetaInterface; //导入方法依赖的package包/类
public void loadXML( Node stepnode, List<DatabaseMeta> databases, IMetaStore metaStore ) throws KettleXMLException {

    List<FieldMetadataBean> fieldBeans = getMetaFields();
    Node fields = XMLHandler.getSubNode( stepnode, "fields" );
    int nrfields = XMLHandler.countNodes( fields, "field" );
    HashMap<String, FieldMetadataBean> fieldMap = StepPluginUtils.getFieldMetadataBeansAsMap( fieldBeans );
    if ( fieldMap != null ) {
      for ( int i = 0; i < nrfields; i++ ) {

        Node fnode = XMLHandler.getSubNodeByNr( fields, "field", i );
        final String name = XMLHandler.getTagValue( fnode, "name" );
        FieldMetadataBean fieldBean = fieldMap.get( name );
        if ( fieldBean != null ) {
          try {
            Field field = fieldBean.getField();
            ValueMetaInterface valueMeta = fieldBean.getValueMeta();
            String valueString = XMLHandler.getTagValue( fnode, "value" );
            if ( valueString != null ) {
              Object convertedValue = valueMeta.convertData( new ValueMetaString(), valueString );
              System.out.println( "Converted value from " + valueString + " to " + convertedValue );
              // Check for Integer (java.Long) -> java int
              if ( ValueMetaInteger.class.isAssignableFrom( valueMeta.getClass() ) ) {
                if ( Integer.TYPE.isAssignableFrom( field.getType() ) ) {
                  convertedValue = ( (Long) convertedValue ).intValue();
                } else if ( Short.TYPE.isAssignableFrom( field.getType() ) ) {
                  convertedValue = ( (Long) convertedValue ).shortValue();
                }
              }
              // TODO Dates/times?

              StepPluginUtils.setValueOfFieldToObject( this, field, convertedValue );
            } else {
              System.out.println( "No value in XML for " + field.getName() + ", using default" );
            }
          } catch ( KettleException e ) {
            throw new KettleXMLException( "No such field: " + name, e );
          }
        } else {
          System.out.println( "No such field: " + name + ", ignoring..." );
        }
      }
    }
  }
 

import org.pentaho.di.core.row.ValueMetaInterface; //导入方法依赖的package包/类
private Object getAttributeValue(LDAPInputField field,Attribute attr, int i, Object outputRowData) throws Exception {

		if(field.getType() ==  ValueMetaInterface.TYPE_BINARY) {
			// It's a binary field
			// no need to convert, just return the value as it
			try  {
				return (byte[])attr.get();
			}catch(java.lang.ClassCastException e){
				return attr.get().toString().getBytes();
			}
		}
		
		String retval=null;
		if(field.getReturnType() == LDAPInputField.FETCH_ATTRIBUTE_AS_BINARY && field.getType() ==  ValueMetaInterface.TYPE_STRING) {
			// Convert byte[] to string
			return LDAPConnection.extractBytesAndConvertToString(attr, field.isObjectSid());
		}
		
		// extract as string
		retval=extractString(attr); 	
		
		// DO Trimming!
		switch (field.getTrimType()) {
			case LDAPInputField.TYPE_TRIM_LEFT:
				retval = Const.ltrim(retval);
			break;
			case LDAPInputField.TYPE_TRIM_RIGHT:
				retval = Const.rtrim(retval);
			break;
			case LDAPInputField.TYPE_TRIM_BOTH:
				retval = Const.trim(retval);
			break;
			default:
			break;
		}
		
		// DO CONVERSIONS...
		//
		ValueMetaInterface targetValueMeta = data.outputRowMeta.getValueMeta(i);
		ValueMetaInterface sourceValueMeta = data.convertRowMeta.getValueMeta(i);
		return targetValueMeta.convertData(sourceValueMeta, retval);
		
	}