Java DatabaseInterface类代码示例

import org.pentaho.di.core.database.DatabaseInterface; //导入依赖的package包/类
public void addDatabases(ComboVar wConnection, Class<? extends DatabaseInterface> databaseType) {
for (int i = 0; i < transMeta.nrDatabases(); i++) {
    DatabaseMeta ci = transMeta.getDatabase(i);
    if (databaseType==null || ci.getDatabaseInterface().getClass().equals(databaseType)) {
 	  wConnection.add(ci.getName());
   }
}
//  Add the metaDBConnectionName if we have it 
//  and it is already not added to the list in wConnection.
if (!Const.isEmpty(input.getDbConnectionName())) {
 String[] arrayDatabaseList = wConnection.getItems();
 if (arrayDatabaseList == null) {
  List<String> databaseNameList = Arrays.asList(arrayDatabaseList);
  if (!databaseNameList.contains(input.getDbConnectionName())) {
   wConnection.add(input.getDbConnectionName());
  }
 }
}
}
 

import org.pentaho.di.core.database.DatabaseInterface; //导入依赖的package包/类
/**
 * Publishes a datasource to the current BI server
 * @param databaseMeta
 * @param update
 * @return
 * @throws KettleDatabaseException
 */
private boolean publishDataSource(DatabaseMeta databaseMeta, boolean update) throws KettleDatabaseException,
    ConnectionServiceException {

  // create a new connection object and populate it from the databaseMeta
  DatabaseConnection connection = new DatabaseConnection();
  DatabaseDialectService dds = new DatabaseDialectService();
  DatabaseTypeHelper dth = new DatabaseTypeHelper(dds.getDatabaseTypes());
  DatabaseInterface intf = databaseMeta.getDatabaseInterface();
  connection.setName(PublisherHelper.getBiServerCompatibleDatabaseName(databaseMeta.getName()));
  connection.setPassword(databaseMeta.getPassword());    
  connection.setUsername(databaseMeta.getUsername());   
  connection.setDatabaseName(intf.getDatabaseName());   
  connection.setDatabasePort(String.valueOf(intf.getAttributes().getProperty("PORT_NUMBER")));
  connection.setHostname(databaseMeta.getHostname());
  connection.setForcingIdentifiersToLowerCase("N".equals(intf.getAttributes().getProperty("FORCE_IDENTIFIERS_TO_LOWERCASE"))?false:true); 
  connection.setQuoteAllFields("N".equals(intf.getAttributes().getProperty("QUOTE_ALL_FIELDS"))?false:true);    
  connection.setAccessType(DatabaseAccessType.NATIVE);
  IDatabaseType driver = dth.getDatabaseTypeByShortName(intf.getPluginId());
  connection.setDatabaseType(driver);        
  return updateConnection(connection, update);
}
 

import org.pentaho.di.core.database.DatabaseInterface; //导入依赖的package包/类
public static DatabaseInterface getDatabaseInterface( String productName, DatabaseMeta databaseMeta ) {

    if ( productName == null ) {
      return null;
    }

    // special case to separate hive1 and hive2
    if ( productName.indexOf( "Apache Hive" ) >= 0 ) { //$NON-NLS-1$
      String hivePluginId = databaseMeta.getDatabaseInterface().getPluginId();
      switch ( hivePluginId ) {
        case "HIVE": //$NON-NLS-1$
        case "HIVE2": //$NON-NLS-1$
          productName = hivePluginId;
          break;
      }
    }
    return getDatabaseInterface( productName );
  }
 

import org.pentaho.di.core.database.DatabaseInterface; //导入依赖的package包/类
public void addDatabases( ComboVar wConnection, Class<? extends DatabaseInterface> databaseType ) {
  for ( int i = 0; i < transMeta.nrDatabases(); i++ ) {
    DatabaseMeta ci = transMeta.getDatabase( i );
    if ( databaseType == null || ci.getDatabaseInterface().getClass().equals( databaseType ) ) {
      wConnection.add( ci.getName() );
    }
  }
  // Add the metaDBConnectionName if we have it
  // and it is already not added to the list in wConnection.
  if ( !Utils.isEmpty( input.getDbConnectionName() ) ) {
    String[] arrayDatabaseList = wConnection.getItems();
    if ( arrayDatabaseList == null ) {
      List<String> databaseNameList = Arrays.asList();
      if ( !databaseNameList.contains( input.getDbConnectionName() ) ) {
        wConnection.add( input.getDbConnectionName() );
      }
    }
  }
}
 

import org.pentaho.di.core.database.DatabaseInterface; //导入依赖的package包/类
protected String getFragment( DatabaseInterface database, String dbName, String extension, String defaultFragment ) {
  String fragment;
  String ext = ( extension == null ? "" : extension );
  String databaseName = ( dbName == null ? "" : dbName );
  String defaultFrag = ( defaultFragment == null ? "" : defaultFragment );
  if ( database.getXulOverlayFile() != null ) {
    fragment = packagePath.concat( database.getXulOverlayFile() ).concat( ext );
  } else {
    fragment = packagePath.concat( databaseName ).concat( ext );
  }
  InputStream in = getClass().getClassLoader().getResourceAsStream( fragment.toLowerCase() );
  if ( in == null ) {
    fragment = packagePath.concat( defaultFrag );
  }
  return fragment;
}
 

import org.pentaho.di.core.database.DatabaseInterface; //导入依赖的package包/类
@Override
public void pluginAdded( Object serviceObject ) {
  PluginInterface plugin = (PluginInterface) serviceObject;
  String pluginName = plugin.getName();
  try {
    DatabaseInterface databaseInterface = (DatabaseInterface) registry.loadClass( plugin );
    databaseInterface.setPluginId( plugin.getIds()[0] );
    databaseInterface.setName( pluginName );
    databaseTypeAdded( pluginName, databaseInterface );
  } catch ( KettleException e ) {
    Throwable t = e;
    if ( e.getCause() != null ) {
      t = e.getCause();
    }
    System.out.println( "Could not create connection entry for "
      + pluginName + ".  " + t.getClass().getName() );
    LogChannel.GENERAL.logError( "Could not create connection entry for "
      + pluginName + ".  " + t.getClass().getName() );
  }
}
 

import org.pentaho.di.core.database.DatabaseInterface; //导入依赖的package包/类
@Override
public String getDatabaseColumnTypeDefinition( DatabaseInterface databaseInterface, String tk, String pk,
  boolean use_autoinc, boolean add_fieldname, boolean add_cr ) {

  String retval = null;
  if ( databaseInterface instanceof PostgreSQLDatabaseMeta ) {
    if ( add_fieldname ) {
      retval = getName() + " ";
    } else {
      retval = "";
    }
    retval += "INET";
    if ( add_cr ) {
      retval += Const.CR;
    }
  }

  return retval;
}
 

import org.pentaho.di.core.database.DatabaseInterface; //导入依赖的package包/类
/**
 * PDI-10877 Table input step returns no data when pulling a timestamp column from IBM Netezza
 *
 * @throws Exception
 */
@Test
public void testGetValueFromSqlTypeNetezza() throws Exception {
  ValueMetaBase obj = new ValueMetaBase();
  DatabaseInterface databaseInterface = new NetezzaDatabaseMeta();
  ResultSet resultSet = Mockito.mock( ResultSet.class );
  ResultSetMetaData metaData = Mockito.mock( ResultSetMetaData.class );
  Mockito.when( resultSet.getMetaData() ).thenReturn( metaData );

  Mockito.when( metaData.getColumnType( 1 ) ).thenReturn( Types.DATE );
  Mockito.when( metaData.getColumnType( 2 ) ).thenReturn( Types.TIME );

  obj.type = ValueMetaInterface.TYPE_DATE;
  // call to testing method
  obj.getValueFromResultSet( databaseInterface, resultSet, 0 );
  // for jdbc Date type getDate method called
  Mockito.verify( resultSet, Mockito.times( 1 ) ).getDate( Mockito.anyInt() );

  obj.getValueFromResultSet( databaseInterface, resultSet, 1 );
  // for jdbc Time type getTime method called
  Mockito.verify( resultSet, Mockito.times( 1 ) ).getTime( Mockito.anyInt() );
}
 

import org.pentaho.di.core.database.DatabaseInterface; //导入依赖的package包/类
@Test
public void testGetValueFromSQLTypeTypeOverride() throws Exception {
  final int varbinaryColumnIndex = 2;

  ValueMetaBase valueMetaBase = new ValueMetaBase(),
    valueMetaBaseSpy = Mockito.spy( valueMetaBase );
  DatabaseMeta dbMeta = Mockito.mock( DatabaseMeta.class );
  DatabaseInterface databaseInterface = Mockito.mock( DatabaseInterface.class );
  Mockito.doReturn( databaseInterface ).when( dbMeta ).getDatabaseInterface();

  ResultSetMetaData metaData = Mockito.mock( ResultSetMetaData.class );
  valueMetaBaseSpy.getValueFromSQLType( dbMeta, TEST_NAME, metaData, varbinaryColumnIndex, false, false );

  Mockito.verify( databaseInterface, Mockito.times( 1 ) ).customizeValueFromSQLType( Mockito.any( ValueMetaInterface.class ),
    Mockito.any( ResultSetMetaData.class ), Mockito.anyInt() );
}
 

import org.pentaho.di.core.database.DatabaseInterface; //导入依赖的package包/类
@Test
public void testVerticaTimeType() throws Exception {
  // PDI-12244
  ResultSet resultSet = Mockito.mock( ResultSet.class );
  ResultSetMetaData metaData = Mockito.mock( ResultSetMetaData.class );
  ValueMetaInterface valueMetaInterface = Mockito.mock( ValueMetaInternetAddress.class );

  Mockito.when( resultSet.getMetaData() ).thenReturn( metaData );
  Mockito.when( metaData.getColumnType( 1 ) ).thenReturn( Types.TIME );
  Mockito.when( resultSet.getTime( 1 ) ).thenReturn( new Time( 0 ) );
  Mockito.when( valueMetaInterface.getOriginalColumnType() ).thenReturn( Types.TIME );
  Mockito.when( valueMetaInterface.getType() ).thenReturn( ValueMetaInterface.TYPE_DATE );

  DatabaseInterface databaseInterface = new Vertica5DatabaseMeta();
  Object ret = databaseInterface.getValueFromResultSet( resultSet, valueMetaInterface, 0 );
  assertEquals( new Time( 0 ), ret );
}
 

import org.pentaho.di.core.database.DatabaseInterface; //导入依赖的package包/类
@Test
public void testGetValueFromSQLTypeBinaryMysql() throws Exception {

  final int binaryColumnIndex = 1;
  ValueMetaBase valueMetaBase = new ValueMetaBase();
  DatabaseMeta dbMeta = Mockito.spy( new DatabaseMeta() );
  DatabaseInterface databaseInterface = new MySQLDatabaseMeta();
  dbMeta.setDatabaseInterface( databaseInterface );

  ResultSet resultSet = Mockito.mock( ResultSet.class );
  ResultSetMetaData metaData = Mockito.mock( ResultSetMetaData.class );

  Mockito.when( resultSet.getMetaData() ).thenReturn( metaData );
  Mockito.when( metaData.getColumnType( binaryColumnIndex ) ).thenReturn( Types.LONGVARBINARY );

  ValueMetaInterface binaryValueMeta =
    valueMetaBase.getValueFromSQLType( dbMeta, TEST_NAME, metaData, binaryColumnIndex, false, false );
  Assert.assertEquals( ValueMetaInterface.TYPE_BINARY, binaryValueMeta.getType() );
  Assert.assertTrue( binaryValueMeta.isBinary() );
}
 

import org.pentaho.di.core.database.DatabaseInterface; //导入依赖的package包/类
/**
 * Property value has priority
 */
@Test public void testExceptionStrategyWithPacketTooBigExceptionPropSetY() {
  System.setProperty( DatabaseLogExceptionFactory.KETTLE_GLOBAL_PROP_NAME, PROPERTY_VALUE_TRUE );

  DatabaseMeta databaseMeta = mock( DatabaseMeta.class );
  DatabaseInterface databaseInterface = new MySQLDatabaseMeta();
  PacketTooBigException e = new PacketTooBigException();

  when( logTable.getDatabaseMeta() ).thenReturn( databaseMeta );
  when( databaseMeta.getDatabaseInterface() ).thenReturn( databaseInterface );

  LogExceptionBehaviourInterface
    exceptionStrategy =
    DatabaseLogExceptionFactory.getExceptionStrategy( logTable, new KettleDatabaseException( e ) );
  String strategyName = exceptionStrategy.getClass().getName();
  assertEquals( THROWABLE, strategyName );
}
 

import org.pentaho.di.core.database.DatabaseInterface; //导入依赖的package包/类
@SuppressWarnings({ "rawtypes", "unchecked" })
public void addDatabases( XulMenuList wConnection, Class<? extends DatabaseInterface> databaseType ) {
  List<String> databases = new ArrayList<String>();
  for (int i = 0; i < transMeta.nrDatabases(); i++) {
    DatabaseMeta ci = transMeta.getDatabase(i);
    if (databaseType == null || ci.getDatabaseInterface().getClass().equals(databaseType)) {
      databases.add(ci.getName());
    }
  }
  wConnection.setElements(databases);
}
 

import org.pentaho.di.core.database.DatabaseInterface; //导入依赖的package包/类
public void addDatabases(CCombo wConnection, Class<? extends DatabaseInterface> databaseType) {
  for (int i = 0; i < transMeta.nrDatabases(); i++) {
    DatabaseMeta ci = transMeta.getDatabase(i);
    if (databaseType==null || ci.getDatabaseInterface().getClass().equals(databaseType))
    {
  	  wConnection.add(ci.getName());
    }
  }
}
 

import org.pentaho.di.core.database.DatabaseInterface; //导入依赖的package包/类
private String getFragment(DatabaseInterface database, String databaseName, String extension, String defaultFragment ){
  String fragment;
  if (database.getXulOverlayFile()!=null) {
  	fragment = packagePath.concat(database.getXulOverlayFile()).concat(extension);
  } else {
  	fragment = packagePath.concat(databaseName).concat(extension);
  }
  InputStream in = getClass().getClassLoader().getResourceAsStream(fragment.toLowerCase());
  if (in == null){
    fragment = packagePath.concat(defaultFragment);
  }
  return fragment;
}