@Override public String addMappedColumn( HBaseValueMetaInterface hBaseValueMetaInterface, boolean b ) throws Exception { if ( mappedColumns == null ) { mappedColumns = new HashMap<>(); } mappedColumns.put( hBaseValueMetaInterface.getAlias(), hBaseValueMetaInterface ); this.numMappedColumns++; return hBaseValueMetaInterface.getAlias(); }
@Override public HBaseValueMetaInterfaceImpl copy( HBaseValueMetaInterface hBaseValueMetaInterface ) { HBaseValueMetaInterfaceImpl result = createHBaseValueMetaInterface( hBaseValueMetaInterface.getColumnFamily(), hBaseValueMetaInterface.getColumnName(), hBaseValueMetaInterface.getName(), hBaseValueMetaInterface.getType(), hBaseValueMetaInterface.getLength(), hBaseValueMetaInterface.getPrecision() ); result.setTableName( hBaseValueMetaInterface.getTableName() ); result.setMappingName( hBaseValueMetaInterface.getMappingName() ); result.setKey( hBaseValueMetaInterface.isKey() ); result.setConversionMask( hBaseValueMetaInterface.getConversionMask() ); result.setIndex( hBaseValueMetaInterface.getIndex() ); result.setStorageType( hBaseValueMetaInterface.getStorageType() ); result.setIsLongOrDouble( hBaseValueMetaInterface.getIsLongOrDouble() ); return result; }
private String getIndexValues( HBaseValueMetaInterface vm ) { Object[] labels = vm.getIndex(); StringBuffer vals = new StringBuffer(); vals.append( "{" ); for ( int i = 0; i < labels.length; i++ ) { if ( i != labels.length - 1 ) { vals.append( labels[i].toString().trim() ).append( "," ); } else { vals.append( labels[i].toString().trim() ).append( "}" ); } } return vals.toString(); }
throws KettleException { for ( HBaseValueMetaInterface currentCol : limitCols ) { if ( !currentCol.isKey() ) { String colFamilyName = currentCol.getColumnFamily(); String qualifier = currentCol.getColumnName();
@Override public String getXML() { if ( Const.isEmpty( getKeyName() ) ) { return ""; // nothing defined } String retString = ""; retString += XMLHandler.openTag( "mapping" ); retString += XMLHandler.addTagValue( "mapping_name", getMappingName() ); retString += XMLHandler.addTagValue( "table_name", getTableName() ); retString += XMLHandler.addTagValue( "key", getKeyName() ); retString += XMLHandler.addTagValue( "key_type", getKeyType().toString() ); if ( mappedColumns.size() > 0 ) { retString += XMLHandler.openTag( "mapped_columns" ); for ( String alias : mappedColumns.keySet() ) { HBaseValueMetaInterface vm = mappedColumns.get( alias ); retString += XMLHandler.openTag( "mapped_column" ); retString += XMLHandler.addTagValue( "alias", alias ); retString += XMLHandler.addTagValue( "column_family", vm.getColumnFamily() ); retString += XMLHandler.addTagValue( "column_name", vm.getColumnName() ); retString += XMLHandler.addTagValue( "type", vm.getHBaseTypeDesc() ); retString += XMLHandler.closeTag( "mapped_column" ); } retString += XMLHandler.closeTag( "mapped_columns" ); } retString += XMLHandler.closeTag( "mapping" ); return retString; }
static List<HBaseValueMetaInterface> createOutputFieldsDefinition( List<OutputFieldDefinition> outputFieldsDefinition, Mapping m_mapping, HBaseService hBaseService ) { HBaseValueMetaInterfaceFactory valueMetaInterfaceFactory = hBaseService.getHBaseValueMetaInterfaceFactory(); ByteConversionUtil byteConversionUtil = hBaseService.getByteConversionUtil(); List<HBaseValueMetaInterface> outputFields = new ArrayList<>(); Map<String, HBaseValueMetaInterface> columns = m_mapping.getMappedColumns(); for ( OutputFieldDefinition fieldDefinition : outputFieldsDefinition ) { HBaseValueMetaInterface valueMeta = valueMetaInterfaceFactory.createHBaseValueMetaInterface( fieldDefinition.getFamily(), fieldDefinition .getColumnName(), fieldDefinition.getAlias(), ValueMeta.getType( fieldDefinition.getHbaseType() ), -1, -1 ); valueMeta.setKey( fieldDefinition.isKey() ); valueMeta.setConversionMask( fieldDefinition.getFormat() ); HBaseValueMetaInterface mappedColumn = columns.get( fieldDefinition.getAlias() ); if ( mappedColumn != null && mappedColumn.getIndex() != null ) { Object[] indexVal = mappedColumn.getIndex(); String indexStrign = byteConversionUtil.objectIndexValuesToString( indexVal ); Object[] vals = byteConversionUtil.stringIndexListToObjects( indexStrign ); valueMeta.setIndex( vals ); valueMeta.setStorageType( ValueMetaInterface.STORAGE_TYPE_INDEXED ); } outputFields.add( valueMeta ); } return outputFields; }
if ( i != keyIndex && !current.isNull( kettleRow[i] ) ) { HBaseValueMetaInterface hbaseColMeta = columnsMappedByAlias.get( current.getName() ); String columnFamily = hbaseColMeta.getColumnFamily(); String columnName = hbaseColMeta.getColumnName(); binaryColName = true; byte[] encoded = hbaseColMeta.encodeColumnValue( kettleRow[i], current );
HBaseValueMetaInterface vm = m_mappedColumns.get( transMeta.environmentSubstitute( alias ) ); if ( vm != null ) { vm.setType( HBaseInput.getKettleTypeByKeyType( m_keyType ) ); String type = ValueMetaBase.getTypeDesc( vm.getType() ); tableItem.setText( 2, type ); return vm; HBaseValueMetaInterface vm = m_mappedColumns.get( transMeta.environmentSubstitute( alias ) ); if ( vm != null ) { String type = ValueMetaBase.getTypeDesc( vm.getType() ); if ( vm.getType() == ValueMetaInterface.TYPE_INTEGER ) { if ( vm.getIsLongOrDouble() ) { type = "Long"; } else { if ( vm.getType() == ValueMetaInterface.TYPE_NUMBER ) { if ( vm.getIsLongOrDouble() ) { type = "Double"; } else { String aliasF = vm.getAlias(); if ( alias.equals( aliasF ) ) { String type = ValueMetaBase.getTypeDesc( vm.getType() ); tableItem.setText( 2, type ); return vm;
String colA = "first_string_column"; HBaseValueMetaInterface vm = valueMetaInterfaceFactory .createHBaseValueMetaInterface( family1, colA, colA, ValueMetaInterface.TYPE_STRING, -1, -1 ); vm.setTableName( tableName ); vm.setMappingName( mappingName ); testMapping.addMappedColumn( vm, false ); .createHBaseValueMetaInterface( family1, colB, colB, ValueMetaInterface.TYPE_INTEGER, -1, -1 ); vm.setIsLongOrDouble( false ); vm.setTableName( tableName ); vm.setMappingName( mappingName ); testMapping.addMappedColumn( vm, false ); String colC = "first_indexed_column"; vm = valueMetaInterfaceFactory .createHBaseValueMetaInterface( family2, colC, colC, ValueMetaInterface.TYPE_STRING, -1, -1 ); vm.setTableName( tableName ); vm.setMappingName( mappingName ); vm.setStorageType( ValueMetaInterface.STORAGE_TYPE_INDEXED ); Object[] vals = { "nomVal1", "nomVal2", "nomVal3" }; vm.setIndex( vals ); testMapping.addMappedColumn( vm, false ); .createHBaseValueMetaInterface( family1, colD, colD, ValueMetaInterface.TYPE_BINARY, -1, -1 ); vm.setTableName( tableName ); vm.setMappingName( mappingName ); testMapping.addMappedColumn( vm, false ); .createHBaseValueMetaInterface( family1, colE, colE, ValueMetaInterface.TYPE_BOOLEAN, -1, -1 );
public static HBaseValueMetaInterface buildNonKeyValueMeta( String alias, String family, String columnName, String type, String indexedVals, HBaseService hBaseService ) throws KettleException { HBaseValueMetaInterfaceFactory valueMetaInterfaceFactory = hBaseService.getHBaseValueMetaInterfaceFactory(); HBaseValueMetaInterface valueMeta = valueMetaInterfaceFactory.createHBaseValueMetaInterface( family, columnName, alias, 0, UNDEFINED_VALUE, UNDEFINED_VALUE ); try { valueMeta.setHBaseTypeFromString( type ); if ( valueMeta.isString() && !Const.isEmpty( indexedVals ) ) { ByteConversionUtil byteConversionUtil = hBaseService.getByteConversionUtil(); Object[] vals = byteConversionUtil.stringIndexListToObjects( indexedVals ); valueMeta.setIndex( vals ); valueMeta.setStorageType( ValueMetaInterface.STORAGE_TYPE_INDEXED ); } return valueMeta; } catch ( IllegalArgumentException e ) { throw new KettleException( e ); } }
public String[] getComboValues( TableItem tableItem, int rowNr, int colNr ) { String[] comboValues = colinf2[ 2 ].getComboValues(); // try to fill in the type String alias = tableItem.getText( 1 ); HBaseValueMetaInterface vm = null; if ( !Const.isEmpty( alias ) ) { vm = setFilterTableTypeColumn( tableItem ); } if ( vm != null ) { if ( vm.isNumeric() || vm.isDate() || vm.isBoolean() ) { comboValues = ColumnFilter.ComparisonType.getNumericOperators(); } else if ( vm.isString() ) { comboValues = ColumnFilter.ComparisonType.getStringOperators(); } else { comboValues = new String[ 1 ]; comboValues[ 0 ] = ""; } } else { // if we've not got a connection, or there is no user-specified // columns saved in the meta class, then just get all the // operators comboValues = ColumnFilter.ComparisonType.getAllOperators(); } return comboValues; } } );
valueMetaInterfaceFactory.createHBaseValueMetaInterface( null, null, alias, 0, UNDEFINED_VALUE, UNDEFINED_VALUE ); valueMeta.setKey( true ); try { theMapping.setKeyTypeAsString( type ); valueMeta.setType( HBaseInput.getKettleTypeByKeyType( theMapping.getKeyType() ) ); } catch ( Exception ex ) {
.createHBaseValueMetaInterface( family, colName, "Family", ValueMetaInterface.TYPE_STRING, -1, -1 ); testMapping.addMappedColumn( vm, true ); vm = valueMetaInterfaceFactory .createHBaseValueMetaInterface( family, colName, "Column", ValueMetaInterface.TYPE_STRING, -1, -1 ); testMapping.addMappedColumn( vm, true ); vm = valueMetaInterfaceFactory .createHBaseValueMetaInterface( family, colName, "Value", ValueMetaInterface.TYPE_STRING, -1, -1 ); testMapping.addMappedColumn( vm, true ); vm = valueMetaInterfaceFactory .createHBaseValueMetaInterface( family, colName, "Timestamp", ValueMetaInterface.TYPE_INTEGER, -1, -1 ); vm.setIsLongOrDouble( true ); testMapping.addMappedColumn( vm, true );
if ( !mappedCol.getHBaseTypeDesc().equalsIgnoreCase( fieldTypeS ) ) { throw new KettleException( BaseMessages.getString( HBaseInputMeta.PKG, "HBaseInput.Error.FieldTypeMismatch", fieldTypeS, fieldAliasS, mappedCol.getHBaseTypeDesc() ) );
.createHBaseValueMetaInterface( null, mapping.getKeyName(), "dummy", ValueMetaInterface.TYPE_INTEGER, 0, 0 ); m_tupleColsFromAliasMap.add( keyMeta );
m_outputFields.get( i ).saveRep( rep, id_transformation, id_step, i );
byte[] encodedValue = valueMeta.encodeColumnValue( row[valueIndex], valueInMeta ); put.addColumn( columnFamily, columnName, binaryColName, encodedValue ); byte[] encodedVisibility = visibilityMeta.encodeColumnValue( row[visibilityIndex], visibilityInMeta ); put.addColumn( columnFamily, MappingUtils.TUPLE_MAPPING_VISIBILITY, false, encodedVisibility );
MappingFactory mappingFactory = hBaseService.getMappingFactory(); m_outputFields = valueMetaInterfaceFactory.createListFromRepository( rep, id_step );
@Override public void getFields( RowMetaInterface rowMeta, String origin, RowMetaInterface[] info, StepMeta nextStep, VariableSpace space ) throws KettleStepException { rowMeta.clear(); // start afresh - eats the input if ( m_mapping != null ) { int kettleType; if ( m_mapping.getKeyType() == Mapping.KeyType.DATE || m_mapping.getKeyType() == Mapping.KeyType.UNSIGNED_DATE ) { kettleType = ValueMetaInterface.TYPE_DATE; } else if ( m_mapping.getKeyType() == Mapping.KeyType.STRING ) { kettleType = ValueMetaInterface.TYPE_STRING; } else if ( m_mapping.getKeyType() == Mapping.KeyType.BINARY ) { kettleType = ValueMetaInterface.TYPE_BINARY; } else { kettleType = ValueMetaInterface.TYPE_INTEGER; } ValueMetaInterface keyMeta = new ValueMeta( m_mapping.getKeyName(), kettleType ); keyMeta.setOrigin( origin ); rowMeta.addValueMeta( keyMeta ); // Add the rest of the fields in the mapping Map<String, HBaseValueMetaInterface> mappedColumnsByAlias = m_mapping.getMappedColumns(); Set<String> aliasSet = mappedColumnsByAlias.keySet(); for ( String alias : aliasSet ) { HBaseValueMetaInterface columnMeta = mappedColumnsByAlias.get( alias ); columnMeta.setOrigin( origin ); rowMeta.addValueMeta( columnMeta ); } } }