Java ValueMetaInterface.setCurrencySymbol方法代码示例

import org.pentaho.di.core.row.ValueMetaInterface; //导入方法依赖的package包/类
/**
 * This method is called to determine the changes the step is making to the row-stream.
 * To that end a RowMetaInterface object is passed in, containing the row-stream structure as it is when entering
 * the step. This method must apply any changes the step makes to the row stream. Usually a step adds fields to the
 * row-stream.
 * 
 * @param inputRowMeta		the row structure coming in to the step
 * @param name 				the name of the step making the changes
 * @param info				row structures of any info steps coming in
 * @param nextStep			the description of a step this step is passing rows to
 * @param space				the variable space for resolving variables
 * @param repository		the repository instance optionally read from
 * @param metaStore			the metaStore to optionally read from
 */
 @Override
public void getFields(RowMetaInterface inputRowMeta, String name, RowMetaInterface[] info, StepMeta nextStep, VariableSpace space, Repository repository, IMetaStore metaStore) throws KettleStepException{

   for ( int i = 0; i < fields.length; i++ ) {
     int type = fields[i].getType();
     if ( type == ValueMetaInterface.TYPE_NONE) type = ValueMetaInterface.TYPE_STRING;

     try {
       ValueMetaInterface v = ValueMetaFactory.createValueMeta( fields[i].getName(), type );
       v.setConversionMask( fields[i].getFormat() );
       v.setLength( fields[i].getLength() );
       v.setPrecision( fields[i].getPrecision() );
       v.setCurrencySymbol( fields[i].getCurrencySymbol() );
       v.setDecimalSymbol( fields[i].getDecimalSymbol() );
       v.setGroupingSymbol( fields[i].getGroupSymbol() );
       v.setTrimType( fields[i].getTrimType() );

       v.setOrigin( name );

       inputRowMeta.addValueMeta( v );
     } catch (KettlePluginException e) {
       throw new KettleStepException( e );
     }
   }
}
 

import org.pentaho.di.core.row.ValueMetaInterface; //导入方法依赖的package包/类
@Override
public void getFields(RowMetaInterface r, String name, RowMetaInterface[] info, StepMeta nextStep, VariableSpace space)
{
    // Remove the field to parse
    final int idx = r.indexOfValue(fieldToParse);

    if (idx<0) {
        throw new RuntimeException(BaseMessages.getString(PKG, "ParseJsonString.Log.CouldNotFindFieldToParse",fieldToParse));
    }

    // Add the new fields at the place of the index --> replace!
    for (int i = 0; i < fieldName.length; i++)
    {
        final ValueMetaInterface v = new ValueMeta(fieldName[i], fieldType[i]);
        v.setLength(fieldLength[i], fieldPrecision[i]);
        v.setOrigin(name);
        v.setConversionMask(fieldFormat[i]);
        v.setDecimalSymbol(fieldDecimal[i]);
        v.setGroupingSymbol(fieldGroup[i]);
        v.setCurrencySymbol(fieldCurrency[i]);
        v.setTrimType(fieldTrimType[i]);
        r.addValueMeta(v);
    }
}
 

import org.pentaho.di.core.row.ValueMetaInterface; //导入方法依赖的package包/类
public void getFields(RowMetaInterface inputRowMeta, String name, RowMetaInterface[] info, StepMeta nextStep, VariableSpace space, Repository repository, IMetaStore metaStore)
		throws KettleStepException
{

	for (int i = 0; i < outputField.length; i++)
	{
		ValueMetaInterface valueMeta = new ValueMeta(outputField[i], outputType[i]);
		valueMeta.setLength(outputLength[i]);
		valueMeta.setPrecision(outputPrecision[i]);
		valueMeta.setCurrencySymbol(outputCurrency[i]);
		valueMeta.setConversionMask(outputFormat[i]);
		valueMeta.setDecimalSymbol(outputDecimal[i]);
		valueMeta.setGroupingSymbol(outputGroup[i]);
		valueMeta.setOrigin(name);
		inputRowMeta.addValueMeta(valueMeta);
	}

}
 

import org.pentaho.di.core.row.ValueMetaInterface; //导入方法依赖的package包/类
public void getFields(RowMetaInterface rowMeta, String name, RowMetaInterface[] info, StepMeta nextStep, VariableSpace space) throws KettleStepException
{
	for (int i=0;i<fieldName.length;i++) {
		if (!Const.isEmpty(fieldName[i])) {
			int type=ValueMeta.getType(fieldType[i]);
			if (type==ValueMetaInterface.TYPE_NONE) type=ValueMetaInterface.TYPE_STRING;
			ValueMetaInterface v=new ValueMeta(fieldName[i], type);
			v.setLength(fieldLength[i]);
               v.setPrecision(fieldPrecision[i]);
			v.setOrigin(name);
			v.setConversionMask(fieldFormat[i]);
			v.setCurrencySymbol(currency[i]);
			v.setGroupingSymbol(group[i]);
			v.setDecimalSymbol(decimal[i]);
			
			rowMeta.addValueMeta(v);
		}
	}
}
 

import org.pentaho.di.core.row.ValueMetaInterface; //导入方法依赖的package包/类
public void getFields( RowMetaInterface inputRowMeta, String name, RowMetaInterface[] info, StepMeta nextStep,
                       VariableSpace space, Repository repository, IMetaStore metaStore ) throws KettleStepException {
  // determine the maximum length
  int length = -1;
  for ( int i = 0; i < fieldName.length; i++ ) {
    if ( variableName[ i ] != null ) {
      String string = space.environmentSubstitute( variableName[ i ] );
      if ( string.length() > length ) {
        length = string.length();
      }
    }
  }

  RowMetaInterface row = new RowMeta();
  for ( int i = 0; i < fieldName.length; i++ ) {
    ValueMetaInterface valueMeta = new ValueMeta( fieldName[ i ], fieldType[ i ] );
    if ( fieldLength[ i ] < 0 ) {
      valueMeta.setLength( length );
    } else {
      valueMeta.setLength( fieldLength[ i ] );
    }
    if ( fieldPrecision[ i ] >= 0 ) {
      valueMeta.setPrecision( fieldPrecision[ i ] );
    }
    valueMeta.setConversionMask( fieldFormat[ i ] );
    valueMeta.setGroupingSymbol( group[ i ] );
    valueMeta.setDecimalSymbol( decimal[ i ] );
    valueMeta.setCurrencySymbol( currency[ i ] );
    valueMeta.setTrimType( trimType[ i ] );
    valueMeta.setOrigin( name );
    row.addValueMeta( valueMeta );
  }
  inputRowMeta.mergeRowMeta( row );
}
 

import org.pentaho.di.core.row.ValueMetaInterface; //导入方法依赖的package包/类
@Override
public void getFields(RowMetaInterface inputRowMeta, String name, RowMetaInterface[] info, StepMeta nextStep, VariableSpace space, Repository repository, IMetaStore metaStore) throws KettleStepException {
    try {
        inputRowMeta.clear(); // Start with a clean slate, eats the input

        for (TextFileInputField field : inputFields) {
            ValueMetaInterface valueMeta = ValueMetaFactory.createValueMeta(field.getName(), field.getType());
            valueMeta.setConversionMask(field.getFormat());
            valueMeta.setLength(field.getLength());
            valueMeta.setPrecision(field.getPrecision());
            valueMeta.setConversionMask(field.getFormat());
            valueMeta.setDecimalSymbol(field.getDecimalSymbol());
            valueMeta.setGroupingSymbol(field.getGroupSymbol());
            valueMeta.setCurrencySymbol(field.getCurrencySymbol());
            valueMeta.setTrimType(field.getTrimType());
            valueMeta.setStorageType(ValueMetaInterface.STORAGE_TYPE_BINARY_STRING);
            valueMeta.setDateFormatLenient(true);
            valueMeta.setStringEncoding("UTF-8");

            ValueMetaInterface storageMetadata = ValueMetaFactory.cloneValueMeta(valueMeta, ValueMetaInterface.TYPE_STRING);
            storageMetadata.setStorageType(ValueMetaInterface.STORAGE_TYPE_NORMAL);
            storageMetadata.setLength(-1, -1); // we don't really know the lengths of the strings read in advance.
            valueMeta.setStorageMetadata(storageMetadata);

            valueMeta.setOrigin(name);

            inputRowMeta.addValueMeta(valueMeta);
        }
    } catch (Exception e) {

    }
}
 

import org.pentaho.di.core.row.ValueMetaInterface; //导入方法依赖的package包/类
public void getFields(RowMetaInterface rowMeta, String origin, RowMetaInterface[] info, StepMeta nextStep, VariableSpace space) throws KettleStepException
{
	for (int i=0;i<fieldDefinition.length;i++) {
		FixedFileInputField field = fieldDefinition[i];
		
		ValueMetaInterface valueMeta = new ValueMeta(field.getName(), field.getType());
		valueMeta.setConversionMask(field.getFormat());
		valueMeta.setTrimType(field.getTrimType());
		valueMeta.setLength(field.getLength());
		valueMeta.setPrecision(field.getPrecision());
		valueMeta.setConversionMask(field.getFormat());
		valueMeta.setDecimalSymbol(field.getDecimal());
		valueMeta.setGroupingSymbol(field.getGrouping());
		valueMeta.setCurrencySymbol(field.getCurrency());
		valueMeta.setStringEncoding(space.environmentSubstitute(encoding));
		if (lazyConversionActive) valueMeta.setStorageType(ValueMetaInterface.STORAGE_TYPE_BINARY_STRING);
		
		// In case we want to convert Strings...
		//
		ValueMetaInterface storageMetadata = valueMeta.clone();
		storageMetadata.setType(ValueMetaInterface.TYPE_STRING);
		storageMetadata.setStorageType(ValueMetaInterface.STORAGE_TYPE_NORMAL);
		
		valueMeta.setStorageMetadata(storageMetadata);
		
		valueMeta.setOrigin(origin);
		
		rowMeta.addValueMeta(valueMeta);
	}
}
 

import org.pentaho.di.core.row.ValueMetaInterface; //导入方法依赖的package包/类
public void getFields(RowMetaInterface r, String name, RowMetaInterface[] info, StepMeta nextStep, VariableSpace space)
{
    // Remove the field to split
    int idx = r.indexOfValue(splitField);
    if (idx<0) //not found
    {
        throw new RuntimeException(Messages.getString("FieldSplitter.Log.CouldNotFindFieldToSplit",splitField)); //$NON-NLS-1$ //$NON-NLS-2$
    }

    // Add the new fields at the place of the index --> replace!
    for (int i = 0; i < fieldName.length; i++)
    {
        final ValueMetaInterface v = new ValueMeta(fieldName[i], fieldType[i]);
        v.setLength(fieldLength[i], fieldPrecision[i]);
        v.setOrigin(name);
        v.setConversionMask(fieldFormat[i]);
        v.setDecimalSymbol(fieldDecimal[i]);
        v.setGroupingSymbol(fieldGroup[i]);
        v.setCurrencySymbol(fieldCurrency[i]);
        v.setTrimType(fieldTrimType[i]);
        // TODO when implemented in UI
        // v.setDateFormatLenient(dateFormatLenient);
        // TODO when implemented in UI
        // v.setDateFormatLocale(dateFormatLocale);
        if(i==0 && idx>=0)
        {
            //the first valueMeta (splitField) will be replaced
            r.setValueMeta(idx, v);
        }
        else
        {
            //other valueMeta will be added
            if (idx>=r.size()) r.addValueMeta(v);
            r.addValueMeta(idx+i, v);
        }
    }
}
 

import org.pentaho.di.core.row.ValueMetaInterface; //导入方法依赖的package包/类
public void getFields(RowMetaInterface row, String name, RowMetaInterface[] info, StepMeta nextStep, VariableSpace space) throws KettleStepException
{
	// No values are added to the row in this type of step
	// However, in case of Fixed length records, 
	// the field precisions and lengths are altered!
	
	for (int i=0;i<outputFields.length;i++)
	{
	    TextFileField field = outputFields[i];
		ValueMetaInterface v = row.searchValueMeta(field.getName());
		if (v!=null)
		{
			v.setLength(field.getLength());
               v.setPrecision(field.getPrecision());
               v.setConversionMask(field.getFormat());
               v.setDecimalSymbol(field.getDecimalSymbol());
               v.setGroupingSymbol(field.getGroupingSymbol());
               v.setCurrencySymbol(field.getCurrencySymbol());
               v.setOutputPaddingEnabled( isPadded() );
               v.setTrimType(field.getTrimType());
               if ( ! Const.isEmpty(getEncoding()) )
               {
           		v.setStringEncoding(getEncoding());
       		}
               
               // enable output padding by default to be compatible with v2.5.x
               //
               v.setOutputPaddingEnabled(true);
		}
	}
}
 

import org.pentaho.di.core.row.ValueMetaInterface; //导入方法依赖的package包/类
public void getFields(RowMetaInterface inputRowMeta, String name, RowMetaInterface info[], StepMeta nextStep, VariableSpace space) throws KettleStepException
{
       // Determine the maximum length...
       // 
       int length = -1;
	for (int i=0;i<fieldName.length;i++)
	{
           if (variableString[i]!=null)
           {
               String string = space.environmentSubstitute(variableString[i]);
               if (string.length()>length) length=string.length();
           }
	}
       
	RowMetaInterface row=new RowMeta();
	for (int i=0;i<fieldName.length;i++)
	{
		ValueMetaInterface v = new ValueMeta(fieldName[i], fieldType[i]);
           if (fieldLength[i]<0) v.setLength(length); else v.setLength(fieldLength[i]);
           if (fieldPrecision[i]>=0) v.setPrecision(fieldPrecision[i]);
           v.setConversionMask(fieldFormat[i]);
           v.setGroupingSymbol(group[i]);
           v.setDecimalSymbol(decimal[i]);
           v.setCurrencySymbol(currency[i]);
           v.setTrimType(trimType[i]);
           v.setOrigin(name);
           
           row.addValueMeta(v);
	}

       inputRowMeta.mergeRowMeta(row);
   }
 

import org.pentaho.di.core.row.ValueMetaInterface; //导入方法依赖的package包/类
public void getFields(RowMetaInterface r, String name, RowMetaInterface[] info, StepMeta nextStep, VariableSpace space)
{
    // Remove the field to split
    int idx = r.indexOfValue(splitField);
    if (idx<0) //not found
    {
        throw new RuntimeException(BaseMessages.getString(PKG, "FieldSplitter.Log.CouldNotFindFieldToSplit",splitField)); //$NON-NLS-1$ //$NON-NLS-2$
    }

    // Add the new fields at the place of the index --> replace!
    for (int i = 0; i < fieldName.length; i++)
    {
        final ValueMetaInterface v = new ValueMeta(fieldName[i], fieldType[i]);
        v.setLength(fieldLength[i], fieldPrecision[i]);
        v.setOrigin(name);
        v.setConversionMask(fieldFormat[i]);
        v.setDecimalSymbol(fieldDecimal[i]);
        v.setGroupingSymbol(fieldGroup[i]);
        v.setCurrencySymbol(fieldCurrency[i]);
        v.setTrimType(fieldTrimType[i]);
        // TODO when implemented in UI
        // v.setDateFormatLenient(dateFormatLenient);
        // TODO when implemented in UI
        // v.setDateFormatLocale(dateFormatLocale);
        if(i==0 && idx>=0)
        {
            //the first valueMeta (splitField) will be replaced
            r.setValueMeta(idx, v);
        }
        else
        {
            //other valueMeta will be added
            if (idx>=r.size()) r.addValueMeta(v);
            r.addValueMeta(idx+i, v);
        }
    }
}
 

import org.pentaho.di.core.row.ValueMetaInterface; //导入方法依赖的package包/类
private void setValueMeta(ValueMetaInterface v, int i, String name){
            int type = fieldType[i];
            if (type == ValueMetaInterface.TYPE_NONE) type = ValueMetaInterface.TYPE_STRING;
v.setType(type);
            v.setLength(fieldLength[i]);
            v.setPrecision(fieldPrecision[i]);
            v.setOrigin(name);
            v.setConversionMask(fieldFormat[i]);
            v.setDecimalSymbol(fieldDecimal[i]);
            v.setGroupingSymbol(fieldGroup[i]);
            v.setCurrencySymbol(fieldCurrency[i]);
            v.setTrimType(fieldTrimType[i]);
        }
 

import org.pentaho.di.core.row.ValueMetaInterface; //导入方法依赖的package包/类
public void getFields(RowMetaInterface rowMeta, String origin, RowMetaInterface[] info,
    StepMeta nextStep, VariableSpace space) throws KettleStepException {
  rowMeta.clear(); // Start with a clean slate, eats the input

  for (int i = 0; i < inputFields.length; i++) {
    TextFileInputField field = inputFields[i];

    ValueMetaInterface valueMeta = new ValueMeta(field.getName(), field.getType());
    valueMeta.setConversionMask(field.getFormat());
    valueMeta.setLength(field.getLength());
    valueMeta.setPrecision(field.getPrecision());
    valueMeta.setConversionMask(field.getFormat());
    valueMeta.setDecimalSymbol(field.getDecimalSymbol());
    valueMeta.setGroupingSymbol(field.getGroupSymbol());
    valueMeta.setCurrencySymbol(field.getCurrencySymbol());
    valueMeta.setTrimType(field.getTrimType());
    if (lazyConversionActive) {
      valueMeta.setStorageType(ValueMetaInterface.STORAGE_TYPE_BINARY_STRING);
    }
    valueMeta.setStringEncoding(space.environmentSubstitute(encoding));

    // In case we want to convert Strings...
    // Using a copy of the valueMeta object means that the inner and outer representation
    // format is the same.
    // Preview will show the data the same way as we read it.
    // This layout is then taken further down the road by the metadata through the transformation.
    //
    ValueMetaInterface storageMetadata = valueMeta.clone();
    storageMetadata.setType(ValueMetaInterface.TYPE_STRING);
    storageMetadata.setStorageType(ValueMetaInterface.STORAGE_TYPE_NORMAL);
    storageMetadata
        .setLength(-1, -1); // we don't really know the lengths of the strings read in advance.
    valueMeta.setStorageMetadata(storageMetadata);

    valueMeta.setOrigin(origin);

    rowMeta.addValueMeta(valueMeta);
  }

  if (!Const.isEmpty(filenameField) && includingFilename) {
    ValueMetaInterface filenameMeta =
        new ValueMeta(filenameField, ValueMetaInterface.TYPE_STRING);
    filenameMeta.setOrigin(origin);
    if (lazyConversionActive) {
      filenameMeta.setStorageType(ValueMetaInterface.STORAGE_TYPE_BINARY_STRING);
      filenameMeta
          .setStorageMetadata(new ValueMeta(filenameField, ValueMetaInterface.TYPE_STRING));
    }
    rowMeta.addValueMeta(filenameMeta);
  }

  if (!Const.isEmpty(rowNumField)) {
    ValueMetaInterface rowNumMeta = new ValueMeta(rowNumField, ValueMetaInterface.TYPE_INTEGER);
    rowNumMeta.setLength(10);
    rowNumMeta.setOrigin(origin);
    rowMeta.addValueMeta(rowNumMeta);
  }

}
 

import org.pentaho.di.core.row.ValueMetaInterface; //导入方法依赖的package包/类
public void getMetadataFields(RowMetaInterface inputRowMeta, String name)
{
	if (meta!=null && meta.length>0) // METADATA mode: change the meta-data of the values mentioned...
	{
		for (int i=0;i<meta.length;i++)
		{
			SelectMetadataChange metaChange = meta[i];
			
			int idx = inputRowMeta.indexOfValue(metaChange.getName());
			if (idx>=0)  // We found the value
			{
				// This is the value we need to change:
				ValueMetaInterface v = inputRowMeta.getValueMeta(idx);
				
				// Do we need to rename ?
				if (!v.getName().equals(metaChange.getRename()) && !Const.isEmpty(metaChange.getRename()))
				{
					v.setName(metaChange.getRename());
					v.setOrigin(name);
				}
				// Change the type?
				if (metaChange.getType()!=ValueMetaInterface.TYPE_NONE && v.getType()!=metaChange.getType())
				{
					v.setType(metaChange.getType());
					
					// This also moves the data to normal storage type
					//
					v.setStorageType(ValueMetaInterface.STORAGE_TYPE_NORMAL);
				}
				if (metaChange.getLength()     != -2) { v.setLength(metaChange.getLength());       v.setOrigin(name); } 
				if (metaChange.getPrecision()  != -2) { v.setPrecision(metaChange.getPrecision()); v.setOrigin(name); }
				if (metaChange.getStorageType() >= 0) { v.setStorageType(metaChange.getStorageType()); v.setOrigin(name); }
				if (!Const.isEmpty(metaChange.getConversionMask())) 
				{ 
					v.setConversionMask(metaChange.getConversionMask());
					v.setOrigin(name);
				}
				if (!Const.isEmpty(metaChange.getDecimalSymbol())) 
				{ 
					v.setDecimalSymbol(metaChange.getDecimalSymbol());
					v.setOrigin(name);
				}
				if (!Const.isEmpty(metaChange.getGroupingSymbol())) 
				{ 
					v.setGroupingSymbol(metaChange.getGroupingSymbol());
					v.setOrigin(name);
				}
				if (!Const.isEmpty(metaChange.getCurrencySymbol())) 
				{ 
					v.setCurrencySymbol(metaChange.getCurrencySymbol());
					v.setOrigin(name);
				}
			}
		}
	}
}
 

import org.pentaho.di.core.row.ValueMetaInterface; //导入方法依赖的package包/类
public void getFields(RowMetaInterface rowMeta, String origin, RowMetaInterface[] info, StepMeta nextStep, VariableSpace space) throws KettleStepException
{
	rowMeta.clear(); // Start with a clean slate, eats the input
	
	for (int i=0;i<inputFields.length;i++) {
		TextFileInputField field = inputFields[i];
		
		ValueMetaInterface valueMeta = new ValueMeta(field.getName(), field.getType());
		valueMeta.setConversionMask( field.getFormat() );
		valueMeta.setLength( field.getLength() );
		valueMeta.setPrecision( field.getPrecision() );
		valueMeta.setConversionMask( field.getFormat() );
		valueMeta.setDecimalSymbol( field.getDecimalSymbol() );
		valueMeta.setGroupingSymbol( field.getGroupSymbol() );
		valueMeta.setCurrencySymbol( field.getCurrencySymbol() );
		valueMeta.setTrimType( field.getTrimType() );
		if (lazyConversionActive) valueMeta.setStorageType(ValueMetaInterface.STORAGE_TYPE_BINARY_STRING);
		valueMeta.setStringEncoding(space.environmentSubstitute(encoding));
		
		// In case we want to convert Strings...
		// Using a copy of the valueMeta object means that the inner and outer representation format is the same.
		// Preview will show the data the same way as we read it.
		// This layout is then taken further down the road by the metadata through the transformation.
		//
		ValueMetaInterface storageMetadata = valueMeta.clone();
		storageMetadata.setType(ValueMetaInterface.TYPE_STRING);
		storageMetadata.setStorageType(ValueMetaInterface.STORAGE_TYPE_NORMAL);
		storageMetadata.setLength(-1,-1); // we don't really know the lengths of the strings read in advance.
		valueMeta.setStorageMetadata(storageMetadata);
		
		valueMeta.setOrigin(origin);
		
		rowMeta.addValueMeta(valueMeta);
	}
	
	if (!Const.isEmpty(filenameField) && includingFilename) {
		ValueMetaInterface filenameMeta = new ValueMeta(filenameField, ValueMetaInterface.TYPE_STRING);
		filenameMeta.setOrigin(origin);
		if (lazyConversionActive) {
			filenameMeta.setStorageType(ValueMetaInterface.STORAGE_TYPE_BINARY_STRING);
			filenameMeta.setStorageMetadata(new ValueMeta(filenameField, ValueMetaInterface.TYPE_STRING));
		}
		rowMeta.addValueMeta(filenameMeta);
	}
	
	if (!Const.isEmpty(rowNumField)) {
		ValueMetaInterface rowNumMeta = new ValueMeta(rowNumField, ValueMetaInterface.TYPE_INTEGER);
		rowNumMeta.setLength(10);
		rowNumMeta.setOrigin(origin);
		rowMeta.addValueMeta(rowNumMeta);
	}
	
}