public RowMetaInterface getReturnRowMeta() throws KettleDatabaseException { return database.getReturnRowMeta(); }
@Override public RowMetaAndData call() throws Exception { Object[] lookup = database.getLookup( pstmt_entry_attributes ); return new RowMetaAndData( database.getReturnRowMeta(), lookup ); } } );
@Override public RowMetaAndData call() throws Exception { Object[] lookup = database.getLookup( psStepAttributesLookup ); return new RowMetaAndData( database.getReturnRowMeta(), lookup ); } } );
@Override public RowMetaAndData call() throws Exception { Object[] r = database.getLookup( psTransAttributesLookup ); if ( r == null ) { return null; } return new RowMetaAndData( database.getReturnRowMeta(), r ); } } );
@Override public RowMetaAndData call() throws Exception { Object[] r = database.getLookup( psJobAttributesLookup ); if ( r == null ) { return null; } return new RowMetaAndData( database.getReturnRowMeta(), r ); } } );
@Override public RowMetaAndData call() throws Exception { ResultSet resultSet = null; resultSet = database.openQuery( ps, parameterMeta, parameterData ); Object[] result = database.getRow( resultSet ); if ( resultSet != null ) { database.closeQuery( resultSet ); } if ( result == null ) { return new RowMetaAndData( database.getReturnRowMeta(), RowDataUtil.allocateRowData( database .getReturnRowMeta().size() ) ); } return new RowMetaAndData( database.getReturnRowMeta(), result ); } } );
@Override public String[] call() throws Exception { ResultSet resultSet = database.openQuery( ps, parameterMeta, parameterData ); List<Object[]> rows = database.getRows( resultSet, 0, null ); if ( Utils.isEmpty( rows ) ) { return new String[ 0 ]; } // assemble the result // RowMetaInterface rowMeta = database.getReturnRowMeta(); String[] strings = new String[ rows.size() ]; for ( int i = 0; i < strings.length; i++ ) { Object[] row = rows.get( i ); strings[ i ] = rowMeta.getString( row, 0 ); } return strings; } } );
@Override public ObjectId[] call() throws Exception { ResultSet resultSet = database.openQuery( ps, parameterMeta, parameterData ); List<Object[]> rows = database.getRows( resultSet, 0, null ); if ( Utils.isEmpty( rows ) ) { return new ObjectId[ 0 ]; } RowMetaInterface rowMeta = database.getReturnRowMeta(); ObjectId[] ids = new ObjectId[ rows.size() ]; for ( int i = 0; i < ids.length; i++ ) { Object[] row = rows.get( i ); ids[ i ] = new LongObjectId( rowMeta.getInteger( row, 0 ) ); } return ids; } } );
private Database mockDatabase() throws KettleDatabaseException { Database databaseMock = mock( Database.class ); RowMeta databaseRowMeta = new RowMeta(); databaseRowMeta.addValueMeta( new ValueMetaString( "id" ) ); databaseRowMeta.addValueMeta( new ValueMetaString( "value" ) ); doReturn( databaseRowMeta ).when( databaseMock ).getTableFields( anyString() ); doReturn( databaseRowMeta ).when( databaseMock ).getTableFieldsMeta( anyString(), anyString() ); doReturn( Arrays.asList( new Object[][] { { "1", "value" } } ) ).when( databaseMock ).getRows( anyString(), anyInt() ); doReturn( databaseRowMeta ).when( databaseMock ).getReturnRowMeta(); return databaseMock; }
private void putToReadOnlyCache( Database db, List<Object[]> rows ) { ReadAllCache.Builder cacheBuilder = new ReadAllCache.Builder( data, rows.size() ); // all keys have the same row meta, // it is useless to re-create it each time RowMetaInterface returnRowMeta = db.getReturnRowMeta(); cacheBuilder.setKeysMeta( returnRowMeta.clone() ); final int keysAmount = meta.getStreamKeyField1().length; // Copy the data into 2 parts: key and value... // final int valuesAmount = data.returnMeta.size(); for ( Object[] row : rows ) { Object[] keyData = new Object[ keysAmount ]; System.arraycopy( row, 0, keyData, 0, keysAmount ); Object[] valueData = new Object[ valuesAmount ]; System.arraycopy( row, keysAmount, valueData, 0, valuesAmount ); cacheBuilder.add( keyData, valueData ); incrementLinesInput(); } data.cache = cacheBuilder.build(); }
public void run( IProgressMonitor monitor ) throws InvocationTargetException, InterruptedException { db = new Database( Spoon.loggingObject, dbMeta ); try { db.connect(); if ( limit > 0 ) { db.setQueryLimit( limit ); } rows = db.getFirstRows( tableName, limit, new ProgressMonitorAdapter( monitor ) ); rowMeta = db.getReturnRowMeta(); } catch ( KettleException e ) { throw new InvocationTargetException( e, "Couldn't find any rows because of an error :" + e.toString() ); } finally { db.disconnect(); } } };
@Override public Collection<RowMetaAndData> call() throws Exception { ResultSet resultSet = null; try { resultSet = database.openQuery( ps, parameterMeta, parameterData ); List<Object[]> rows = database.getRows( resultSet, 0, null ); for ( Object[] row : rows ) { RowMetaAndData rowWithMeta = new RowMetaAndData( database.getReturnRowMeta(), row ); long id = rowWithMeta.getInteger( quote( KettleDatabaseRepository.FIELD_DATABASE_ATTRIBUTE_ID_DATABASE_ATTRIBUTE ), 0 ); if ( id > 0 ) { attrs.add( rowWithMeta ); } } return attrs; } catch ( KettleDatabaseException e ) { throw e; } finally { database.closeQuery( resultSet ); } } } );
@Override public List<RepositoryElementMetaInterface> call() throws Exception { List<RepositoryElementMetaInterface> repositoryObjects = new ArrayList<RepositoryElementMetaInterface>(); ResultSet rs = database.openQuery( sql, directoryIdRow.getRowMeta(), directoryIdRow.getData() ); if ( rs != null ) { List<Object[]> rows = database.getRows( rs, -1, null ); if ( rs != null ) { database.closeQuery( rs ); } RowMetaInterface rowMeta = database.getReturnRowMeta(); for ( Object[] r : rows ) { ObjectId id = new LongObjectId( rowMeta.getInteger( r, 4 ) ); repositoryObjects.add( new RepositoryObject( id, rowMeta.getString( r, 0 ), repositoryDirectory, rowMeta .getString( r, 1 ), rowMeta.getDate( r, 2 ), objectType, rowMeta.getString( r, 3 ), false ) ); } } return repositoryObjects; } } );
private DatabaseLookupData getCreatedData( boolean allEquals ) throws Exception { Database db = mock( Database.class ); when( db.getRows( anyString(), anyInt() ) ) .thenReturn( Collections.singletonList( new Object[] { 1L } ) ); RowMeta returnRowMeta = new RowMeta(); returnRowMeta.addValueMeta( new ValueMetaInteger() ); when( db.getReturnRowMeta() ).thenReturn( returnRowMeta ); DatabaseLookupMeta meta = createTestMeta(); DatabaseLookupData data = new DatabaseLookupData(); DatabaseLookup step = createSpiedStep( db, mockHelper, meta ); step.init( meta, data ); data.db = db; data.keytypes = new int[] { ValueMetaInterface.TYPE_INTEGER }; if ( allEquals ) { data.allEquals = true; data.conditions = new int[] { DatabaseLookupMeta.CONDITION_EQ }; } else { data.allEquals = false; data.conditions = new int[] { DatabaseLookupMeta.CONDITION_LT }; } step.processRow( meta, data ); return data; }
private void putToDefaultCache( Database db, List<Object[]> rows ) { final int keysAmount = meta.getStreamKeyField1().length; RowMetaInterface prototype = copyValueMetasFrom( db.getReturnRowMeta(), keysAmount ); // Copy the data into 2 parts: key and value... // for ( Object[] row : rows ) { int index = 0; // not sure it is efficient to re-create the same on every row, // but this was done earlier, so I'm keeping this behaviour RowMetaInterface keyMeta = prototype.clone(); Object[] keyData = new Object[ keysAmount ]; for ( int i = 0; i < keysAmount; i++ ) { keyData[ i ] = row[ index++ ]; } // RowMeta valueMeta = new RowMeta(); Object[] valueData = new Object[ data.returnMeta.size() ]; for ( int i = 0; i < data.returnMeta.size(); i++ ) { valueData[ i ] = row[ index++ ]; // valueMeta.addValueMeta(returnRowMeta.getValueMeta(index++)); } // Store the data... // data.cache.storeRowInCache( meta, keyMeta, keyData, valueData ); incrementLinesInput(); } }
any( PreparedStatement.class ) ); returnRowMeta.addValueMeta( new ValueMetaDate( "TimeStamp" ) ); doReturn( returnRowMeta ).when( db ).getReturnRowMeta();
any( PreparedStatement.class ) ); returnRowMeta.addValueMeta( new ValueMetaDate( "TimeStamp" ) ); doReturn( returnRowMeta ).when( db ).getReturnRowMeta();
@Test public void createsReadDefaultCache_AndUsesOnlyNeededFieldsFromMeta() throws Exception { Database db = mock( Database.class ); when( db.getRows( anyString(), anyInt() ) ) .thenReturn( Arrays.asList( new Object[] { 1L }, new Object[] { 2L } ) ); RowMeta returnRowMeta = new RowMeta(); returnRowMeta.addValueMeta( new ValueMetaInteger() ); returnRowMeta.addValueMeta( new ValueMetaInteger() ); when( db.getReturnRowMeta() ).thenReturn( returnRowMeta ); DatabaseLookupMeta meta = createTestMeta(); DatabaseLookupData data = new DatabaseLookupData(); DatabaseLookup step = createSpiedStep( db, mockHelper, meta ); step.init( meta, data ); data.db = db; data.keytypes = new int[] { ValueMetaInterface.TYPE_INTEGER }; data.allEquals = true; data.conditions = new int[] { DatabaseLookupMeta.CONDITION_EQ }; step.processRow( meta, data ); data.lookupMeta = new RowMeta(); data.lookupMeta.addValueMeta( new ValueMetaInteger() ); assertNotNull( data.cache.getRowFromCache( data.lookupMeta, new Object[] { 1L } ) ); assertNotNull( data.cache.getRowFromCache( data.lookupMeta, new Object[] { 2L } ) ); }
public synchronized void fillStepAttributesBuffer( ObjectId id_transformation ) throws KettleException { String sql = "SELECT " + quote( KettleDatabaseRepository.FIELD_STEP_ATTRIBUTE_ID_STEP ) + ", " + quote( KettleDatabaseRepository.FIELD_STEP_ATTRIBUTE_CODE ) + ", " + quote( KettleDatabaseRepository.FIELD_STEP_ATTRIBUTE_NR ) + ", " + quote( KettleDatabaseRepository.FIELD_STEP_ATTRIBUTE_VALUE_NUM ) + ", " + quote( KettleDatabaseRepository.FIELD_STEP_ATTRIBUTE_VALUE_STR ) + " " + "FROM " + databaseMeta.getQuotedSchemaTableCombination( null, KettleDatabaseRepository.TABLE_R_STEP_ATTRIBUTE ) + " " + "WHERE " + quote( KettleDatabaseRepository.FIELD_STEP_ATTRIBUTE_ID_TRANSFORMATION ) + " = ? " + "ORDER BY " + quote( KettleDatabaseRepository.FIELD_STEP_ATTRIBUTE_ID_STEP ) + ", " + quote( KettleDatabaseRepository.FIELD_STEP_ATTRIBUTE_CODE ) + ", " + quote( KettleDatabaseRepository.FIELD_STEP_ATTRIBUTE_NR ); PreparedStatement ps = getPreparedStatement( sql ); RowMetaAndData parameter = getParameterMetaData( id_transformation ); stepAttributesBuffer = callRead( () -> database.getRows( database.openQuery( ps, parameter.getRowMeta(), parameter.getData() ), -1, null ) ); stepAttributesRowMeta = database.getReturnRowMeta(); // must use java-based sort to ensure compatibility with binary search // database ordering may or may not be case-insensitive // in case db sort does not match our sort // Collections.sort( stepAttributesBuffer, new StepAttributeComparator() ); // }
RowMetaInterface rowMeta = database.getReturnRowMeta(); for ( Object[] row : rows ) {