@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; }
@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(); }
throws KettleException { for ( HBaseValueMetaInterface currentCol : limitCols ) { if ( !currentCol.isKey() ) { String colFamilyName = currentCol.getColumnFamily(); String qualifier = currentCol.getColumnName();
for ( String alias : mappedColumns.keySet() ) { HBaseValueMetaInterface column = mappedColumns.get( alias ); String aliasS = column.getAlias(); if ( column.isNumeric() || column.isDate() || column.isString() || column.isBoolean() ) { filterAliasNames.add( aliasS ); String aliasS = column.getAlias(); String family = column.getColumnFamily(); String name = column.getColumnName(); String type = column.getTypeDesc(); String format = column.getConversionMask(); if ( column.getStorageType() == ValueMetaInterface.STORAGE_TYPE_INDEXED ) { String valuesString = byteConversionUtil.objectIndexValuesToString( column.getIndex() ); String aliasS = column.getAlias(); String type = column.getTypeDesc(); item.setText( 1, aliasS ); item.setText( 5, type ); if ( column.isKey() ) { item.setText( 2, "Y" ); item.setText( 7, "N" ); if ( !Const.isEmpty( column.getConversionMask() ) ) { item.setText( 6, column.getConversionMask() ); if ( column.isNumeric() || column.isDate() || column.isString() ) { if ( !filterAliasesDone ) {
for ( String alias : aliases ) { HBaseValueMetaInterface vm = mapping.get( alias ); String valueType = ValueMetaInterface.typeCodes[ vm.getType() ]; if ( vm.isInteger() && vm.getIsLongOrDouble() ) { valueType = "Long"; if ( vm.isNumber() ) { if ( vm.getIsLongOrDouble() ) { valueType = "Double"; } else { if ( vm.getStorageType() == ValueMetaInterface.STORAGE_TYPE_INDEXED && vm.isString() ) { Object[] labels = vm.getIndex(); StringBuffer vals = new StringBuffer(); vals.append( "{" ); .addColumn( family, hBasePut.createColumnName( vm.getColumnFamily(), vm.getColumnName(), alias ), false, byteConversionUtil.toBytes( valueType ) );
item.setText( 1, alias ); item.setText( 2, "N" ); item.setText( 3, vm.getColumnFamily() ); item.setText( 4, vm.getColumnName() ); if ( vm.isInteger() ) { if ( vm.getIsLongOrDouble() ) { item.setText( 5, "Long" ); } else { item.setText( 5, "Integer" ); } else if ( vm.isNumber() ) { if ( vm.getIsLongOrDouble() ) { item.setText( 5, "Double" ); } else { item.setText( 5, vm.getTypeDesc() ); if ( vm.getStorageType() == ValueMetaInterface.STORAGE_TYPE_INDEXED ) { item.setText( 6, m_admin.getConnection().getService().getByteConversionUtil().objectIndexValuesToString( vm .getIndex() ) );
if ( currentCol.isKey() ) { byte[] rawKey = null; try { int keyIndex = outputRowMeta.indexOfValue( currentCol.getAlias() ); outputRowData[keyIndex] = decodedKey; } else { String colFamilyName = currentCol.getColumnFamily(); String qualifier = currentCol.getColumnName(); int outputIndex = outputRowMeta.indexOfValue( currentCol.getAlias() ); if ( outputIndex < 0 ) { throw new KettleException( BaseMessages.getString( HBaseInputMeta.PKG, "HBaseInput.Error.ColumnNotDefinedInOutput", currentCol.getAlias() ) ); Object decodedVal = currentCol.decodeColumnValue( ( kv == null ) ? null : kv ); String colFamilyName = currentCol.getColumnFamily(); String qualifier = currentCol.getColumnName(); if ( currentCol.isKey() ) { Object decodedVal = currentCol.decodeColumnValue( ( kv == null ) ? null : kv );
@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; }
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;
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 );
newMeta.setIsLongOrDouble( false ); } else if ( decodedType.equalsIgnoreCase( "Double" ) ) { newMeta = valueMetaInterfaceFactory newMeta.setIsLongOrDouble( false ); } else if ( decodedType.equalsIgnoreCase( "Long" ) ) { newMeta = valueMetaInterfaceFactory throw new IOException( "Indexed/nominal type must have at least one " + "label declared" ); newMeta.setIndex( labels ); newMeta.setStorageType( ValueMetaInterface.STORAGE_TYPE_INDEXED ); } else { throw new IOException( "Unknown column type : \"" + decodedType + "\"" ); newMeta.setTableName( tableName ); newMeta.setMappingName( mappingName ); String alias = newMeta.getAlias(); if ( !Mapping.TupleMapping.KEY.toString().equalsIgnoreCase( alias ) ) { if ( resultMapping.getKeyName().equals( alias ) ) { throw new IOException( "Error in mapping. Column \"" + newMeta.getAlias() + "\" has the same name as the table key (" + resultMapping.getKeyName() + ")" ); } else { resultCols.put( newMeta.getAlias(), newMeta );
HBaseValueMetaInterface current = m_outputColumns[i]; String colFamilyName = current.getColumnFamily(); String qualifier = current.getColumnName(); Object decodedVal = current.decodeColumnValue( ( kv == null ) ? null : kv ); outputRowData[i + 1] = decodedVal;
.createHBaseValueMetaInterface( null, null, m_tableMapping.getKeyName(), getKettleTypeByKeyType( m_tableMapping.getKeyType() ), -1, -1 ); vm2.setKey( true ); try { m_tableMapping.addMappedColumn( vm2, m_tableMapping.isTupleMapping() ); if ( m_userOutputColumns != null && m_userOutputColumns.size() > 0 ) { for ( HBaseValueMetaInterface vm : m_userOutputColumns ) { if ( !vm.isKey() ) { if ( m_columnsMappedByAlias.get( vm.getAlias() ) == null ) { throw new KettleException( BaseMessages.getString( HBaseInputMeta.PKG, "HBaseInput.Error.UnableToFindUserSelectedColumn", vm.getAlias(), m_tableMapping.getFriendlyName() ) ); dateOrNumberConversionMaskForKey = vm.getConversionMask();
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; }
Set<String> families = new TreeSet<String>(); for ( String col : cols ) { String family = theMapping.getMappedColumns().get( col ).getColumnFamily(); families.add( family );
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(); }
if ( !mappedCol.getHBaseTypeDesc().equalsIgnoreCase( fieldTypeS ) ) { throw new KettleException( BaseMessages.getString( HBaseInputMeta.PKG, "HBaseInput.Error.FieldTypeMismatch", fieldTypeS, fieldAliasS, mappedCol.getHBaseTypeDesc() ) );