Java DatabaseMeta类代码示例

import org.pentaho.di.core.database.DatabaseMeta; //导入依赖的package包/类
@Override public void loadXML(Node stepnode, List<DatabaseMeta> databases, IMetaStore metaStore)
    throws KettleXMLException {
    super.loadXML(stepnode, databases, metaStore);
    String truncateStr = XMLHandler.getTagValue(stepnode, "truncate");
    if (truncateStr.equals("true")) {
        setTruncate(true);
    } else {
        setTruncate(false);
    }

    int nrStreamFields = XMLHandler.countNodes(stepnode, "stream_fields");
    streamFields = new ArrayList<String>(nrStreamFields);
    for (int i = 0; i < nrStreamFields; i++) {
        Node fieldNode = XMLHandler.getSubNodeByNr(stepnode, "stream_fields", i);
        streamFields.add(XMLHandler.getTagValue(fieldNode, "name"));
    }
}
 

import org.pentaho.di.core.database.DatabaseMeta; //导入依赖的package包/类
@Override public void readRep(Repository rep, IMetaStore metaStore, ObjectId id_step,
    List<DatabaseMeta> databases) throws KettleException {
    super.readRep(rep, metaStore, id_step, databases);

    String truncateStr = rep.getStepAttributeString(id_step, "truncate");
    if (truncateStr.equals("true")) {
        setTruncate(true);
    } else {
        setTruncate(false);
    }

    int nrStreamFields = rep.countNrStepAttributes(id_step, "stream_field_name");
    streamFields = new ArrayList<String>(nrStreamFields);
    for (int i = 0; i < nrStreamFields; i++) {
        streamFields.add(rep.getStepAttributeString(id_step, i, "stream_field_name"));
    }
}
 

import org.pentaho.di.core.database.DatabaseMeta; //导入依赖的package包/类
@Override public void loadXML(Node stepnode, List<DatabaseMeta> databases, IMetaStore metaStore)
    throws KettleXMLException {
    setEndpoint(XMLHandler.getTagValue(stepnode, "endpoint"));
    setTunnelEndpoint(XMLHandler.getTagValue(stepnode, "tunnelEndpoint"));
    setAccessId(XMLHandler.getTagValue(stepnode, "accessId"));
    setAccessKey(XMLHandler.getTagValue(stepnode, "accessKey"));
    setProjectName(XMLHandler.getTagValue(stepnode, "projectName"));
    setTableName(XMLHandler.getTagValue(stepnode, "tableName"));
    setPartition(XMLHandler.getTagValue(stepnode, "partition"));

    int nrFields = XMLHandler.countNodes(stepnode, "fields");
    odpsFields = new ArrayList<OdpsField>(nrFields);
    for (int i = 0; i < nrFields; i++) {
        Node fieldNode = XMLHandler.getSubNodeByNr(stepnode, "fields", i);
        OdpsField field = new OdpsField();
        field.setName(XMLHandler.getTagValue(fieldNode, "name"));
        field.setType(XMLHandler.getTagValue(fieldNode, "type"));
        field.setComment(XMLHandler.getTagValue(fieldNode, "comment"));
        odpsFields.add(field);
    }
}
 

import org.pentaho.di.core.database.DatabaseMeta; //导入依赖的package包/类
@Override public void readRep(Repository rep, IMetaStore metaStore, ObjectId id_step,
    List<DatabaseMeta> databases) throws KettleException {
    setEndpoint(rep.getStepAttributeString(id_step, "endpoint"));
    setTunnelEndpoint(rep.getStepAttributeString(id_step, "tunnelEndpoint"));
    setAccessId(rep.getStepAttributeString(id_step, "accessId"));
    setAccessKey(rep.getStepAttributeString(id_step, "accessKey"));
    setProjectName(rep.getStepAttributeString(id_step, "projectName"));
    setTableName(rep.getStepAttributeString(id_step, "tableName"));
    setPartition(rep.getStepAttributeString(id_step, "partition"));

    int nrFields = rep.countNrStepAttributes(id_step, "field_name");
    odpsFields = new ArrayList<OdpsField>(nrFields);
    for (int i = 0; i < nrFields; i++) {
        OdpsField field = new OdpsField();
        field.setName(rep.getStepAttributeString(id_step, i, "field_name"));
        field.setType(rep.getStepAttributeString(id_step, i, "field_type"));
        field.setComment(rep.getStepAttributeString(id_step, i, "field_comment"));
        odpsFields.add(field);
    }
}
 

import org.pentaho.di.core.database.DatabaseMeta; //导入依赖的package包/类
/**
* 创建数据连接元数据对象 <br/>
* @author jingma
 * @param name 数据库连接名称
 * @param url 数据库连接
 * @param user 数据库用户名
 * @param pass 数据库密码
 * @param replace 是否替换已经存在的
 * @param repository 资源库
* @return
 * @throws Exception 
*/
public static DatabaseMeta createDatabaseMeta(String name, String url,String user,String pass,
        boolean replace,Repository repository) throws Exception {
    JSONObject urlObj = JdbcUtil.parseJdbcUrl(url);
    if(UtilConst.DS_TYPE_ORACLE.equals(urlObj.getString(JdbcUtil.DB_TYPE))){
        return createDatabaseMeta(name, dbTypeToKettle(urlObj.getString(JdbcUtil.DB_TYPE)), 
                DatabaseMeta.dbAccessTypeCode[DatabaseMeta.TYPE_ACCESS_NATIVE], 
                urlObj.getString(JdbcUtil.HOSTNAME), urlObj.getString(JdbcUtil.DATABASE_NAME), 
                urlObj.getString(JdbcUtil.PORT), user, pass,null,replace,repository);
    }else if(UtilConst.DS_TYPE_MYSQL.equals(urlObj.getString(JdbcUtil.DB_TYPE))){
        return createDatabaseMeta(name, dbTypeToKettle(urlObj.getString(JdbcUtil.DB_TYPE)), 
                DatabaseMeta.dbAccessTypeCode[DatabaseMeta.TYPE_ACCESS_NATIVE], 
                urlObj.getString(JdbcUtil.HOSTNAME), urlObj.getString(JdbcUtil.DATABASE_NAME), 
                urlObj.getString(JdbcUtil.PORT), user, pass,urlObj.getJSONObject(JdbcUtil.PARAM_OBJ),
                replace,repository);
    }else{
        return null;
    }
}
 

import org.pentaho.di.core.database.DatabaseMeta; //导入依赖的package包/类
@Override
public void readRep(Repository rep, IMetaStore metaStore, ObjectId id_step, List<DatabaseMeta> databases)
    throws KettleException {

  String connectionName = rep.getStepAttributeString(id_step, TAG_CONNECTION);
  if (StringUtils.isNotEmpty(connectionName)) {
    try {
      connection = HCPConnectionUtils.getConnectionFactory(metaStore).loadElement(connectionName);
    } catch (MetaStoreException e) {
      // We just log the message but we don't abort the complete meta-data
      // loading.
      //
      log.logError(BaseMessages.getString(PKG, "HCPGetMeta.Error.HCPConnectionNotFound", connectionName));
      connection = null;
    }
  }
  sourceFileField = rep.getStepAttributeString(id_step, TAG_SOURCE_FILE);
  targetFileField = rep.getStepAttributeString(id_step, TAG_TARGET_FILE);
  responseCodeField = rep.getStepAttributeString(id_step, TAG_RESPONSE_CODE_FIELD);
  responseTimeField = rep.getStepAttributeString(id_step, TAG_RESPONSE_TIME_FIELD);
  responseSizeField = rep.getStepAttributeString(id_step, TAG_RESPONSE_SIZE_FIELD);
}
 

import org.pentaho.di.core.database.DatabaseMeta; //导入依赖的package包/类
@Override
public void readRep(Repository rep, IMetaStore metaStore, ObjectId id_step, List<DatabaseMeta> databases)
    throws KettleException {

  String connectionName = rep.getStepAttributeString(id_step, TAG_CONNECTION);
  if (StringUtils.isNotEmpty(connectionName)) {
    try {
      connection = HCPConnectionUtils.getConnectionFactory(metaStore).loadElement(connectionName);
    } catch(MetaStoreException e) {
      // We just log the message but we don't abort the complete meta-data loading.
      //
      log.logError(BaseMessages.getString(PKG, "HCPPutMeta.Error.HCPConnectionNotFound", connectionName));
      connection = null;
    }
  }
  targetFileField = rep.getStepAttributeString(id_step, TAG_TARGET_FILE_FIELD);
  responseCodeField = rep.getStepAttributeString(id_step, TAG_RESPONSE_CODE_FIELD);
  responseTimeField = rep.getStepAttributeString(id_step, TAG_RESPONSE_TIME_FIELD);
}
 

import org.pentaho.di.core.database.DatabaseMeta; //导入依赖的package包/类
@Override
public void readRep(Repository rep, IMetaStore metaStore, ObjectId id_step, List<DatabaseMeta> databases)
    throws KettleException {

  String connectionName = rep.getStepAttributeString(id_step, TAG_CONNECTION);
  if (StringUtils.isNotEmpty(connectionName)) {
    try {
      connection = HCPConnectionUtils.getConnectionFactory(metaStore).loadElement(connectionName);
    } catch(MetaStoreException e) {
      // We just log the message but we don't abort the complete meta-data loading.
      //
      log.logError(BaseMessages.getString(PKG, "HCPPutMeta.Error.HCPConnectionNotFound", connectionName));
      connection = null;
    }
  }
  sourceFileField = rep.getStepAttributeString(id_step, TAG_SOURCE_FILE_FIELD);
  targetFileField = rep.getStepAttributeString(id_step, TAG_TARGET_FILE_FIELD);
  updating = rep.getStepAttributeBoolean(id_step, TAG_UPDATING);
  responseCodeField = rep.getStepAttributeString(id_step, TAG_RESPONSE_CODE_FIELD);
  responseTimeField = rep.getStepAttributeString(id_step, TAG_RESPONSE_TIME_FIELD);
}
 

import org.pentaho.di.core.database.DatabaseMeta; //导入依赖的package包/类
/**
 * Load the values for this step from an XML Node
 *
 * @param stepnode  the Node to get the info from
 * @param databases The available list of databases to reference to
 * @param counters  Counters to reference.
 * @throws KettleXMLException When an unexpected XML error occurred. (malformed etc.)
 */
@Override public void loadXML(Node stepnode, List<DatabaseMeta> databases,
    Map<String, Counter> counters) throws KettleXMLException {
  try {
    databaseName = XMLHandler.getTagValue(stepnode, "databaseName");
    tabelName = XMLHandler.getTagValue(stepnode, "TableName");
    mdkeySize = XMLHandler.getTagValue(stepnode, "MDKeySize");
    measureCount = XMLHandler.getTagValue(stepnode, "Measurecount");
    heirAndKeySize = XMLHandler.getTagValue(stepnode, "HeirAndKeySize");
    tableName = XMLHandler.getTagValue(stepnode, "tableName");
    groupByEnabled = XMLHandler.getTagValue(stepnode, "isGroupByEnabled");
    aggregatorClassString = XMLHandler.getTagValue(stepnode, "aggregatorClassString");
    aggregatorString = XMLHandler.getTagValue(stepnode, "aggregatorString");
    factDimLensString = XMLHandler.getTagValue(stepnode, "factDimLensString");
    levelAnddataTypeString = XMLHandler.getTagValue(stepnode, "levelAnddataTypeString");
    partitionID = XMLHandler.getTagValue(stepnode, "partitionID");
    segmentId = XMLHandler.getTagValue(stepnode, "segmentId");
    taskNo = XMLHandler.getTagValue(stepnode, "taskNo");
  } catch (Exception e) {
    throw new KettleXMLException("Unable to read step info from XML node", e);
  }
}
 

import org.pentaho.di.core.database.DatabaseMeta; //导入依赖的package包/类
/**
 * Read the steps information from a Kettle repository
 *
 * @param rep       The repository to read from
 * @param idStep    The step ID
 * @param databases The databases to reference
 * @param counters  The counters to reference
 * @throws KettleException When an unexpected error occurred (database, network, etc)
 */
@Override public void readRep(Repository rep, ObjectId idStep, List<DatabaseMeta> databases,
    Map<String, Counter> counters) throws KettleException {
  try {
    tabelName = rep.getStepAttributeString(idStep, "TableName");
    mdkeySize = rep.getStepAttributeString(idStep, "MDKeySize");
    measureCount = rep.getStepAttributeString(idStep, "Measurecount");
    heirAndKeySize = rep.getStepAttributeString(idStep, "HeirAndKeySize");
    databaseName = rep.getStepAttributeString(idStep, "databaseName");
    tableName = rep.getStepAttributeString(idStep, "tableName");
    groupByEnabled = rep.getStepAttributeString(idStep, "isGroupByEnabled");
    aggregatorClassString = rep.getStepAttributeString(idStep, "aggregatorClassString");
    aggregatorString = rep.getStepAttributeString(idStep, "aggregatorString");
    factDimLensString = rep.getStepAttributeString(idStep, "factDimLensString");
    levelAnddataTypeString = rep.getStepAttributeString(idStep, "levelAnddataTypeString");
    partitionID = rep.getStepAttributeString(idStep, "partitionID");
    segmentId = rep.getStepAttributeString(idStep, "segmentId");
    taskNo = rep.getStepAttributeString(idStep, "taskNo");
  } catch (Exception exception) {
    throw new KettleException(BaseMessages
        .getString(PKG, "CarbonDataWriterStepMeta.Exception.UnexpectedErrorInReadingStepInfo"),
        exception);
  }

}
 

import org.pentaho.di.core.database.DatabaseMeta; //导入依赖的package包/类
/**
 * Load the values for this step from an XML Node
 *
 * @param stepnode  the Node to get the info from
 * @param databases The available list of databases to reference to
 * @param counters  Counters to reference.
 * @throws KettleXMLException When an unexpected XML error occurred. (malformed etc.)
 */
public void loadXML(Node stepnode, List<DatabaseMeta> databases, Map<String, Counter> counters)
    throws KettleXMLException {
  try {
    this.tabelName = XMLHandler.getTagValue(stepnode, "TableName");
    this.outputRowSize = XMLHandler.getTagValue(stepnode, "outputRowSize");
    this.factDimLensString = XMLHandler.getTagValue(stepnode, "factDimLensString");
    this.tableName = XMLHandler.getTagValue(stepnode, "tableName");
    this.databaseName = XMLHandler.getTagValue(stepnode, "databaseName");
    this.dimensionCount = XMLHandler.getTagValue(stepnode, "dimensionCount");
    this.noDictionaryDims = XMLHandler.getTagValue(stepnode, "noDictionaryDims");
    this.noDictionaryDimsMapping = XMLHandler.getTagValue(stepnode, "noDictionaryDimsMapping");
    this.complexDimensionCount = XMLHandler.getTagValue(stepnode, "complexDimensionCount");
    this.measureCount = XMLHandler.getTagValue(stepnode, "measureCount");
    this.updateMemberRequest = XMLHandler.getTagValue(stepnode, "isUpdateMemberRequest");
    this.measureDataType = XMLHandler.getTagValue(stepnode, "measureDataType");
    this.partitionID = XMLHandler.getTagValue(stepnode, "partitionID");
    this.segmentId = XMLHandler.getTagValue(stepnode, "segmentId");
    this.taskNo = XMLHandler.getTagValue(stepnode, "taskNo");
  } catch (Exception e) {
    throw new KettleXMLException("Unable to read step info from XML node", e);
  }
}
 

import org.pentaho.di.core.database.DatabaseMeta; //导入依赖的package包/类
/**
 * Read the steps information from a Kettle repository
 *
 * @param rep       The repository to read from
 * @param idStep    The step ID
 * @param databases The databases to reference
 * @param counters  The counters to reference
 * @throws KettleException When an unexpected error occurred (database, network, etc)
 */
public void readRep(Repository rep, ObjectId idStep, List<DatabaseMeta> databases,
    Map<String, Counter> counters) throws KettleException {
  try {
    this.tabelName = rep.getStepAttributeString(idStep, "TableName");
    this.outputRowSize = rep.getStepAttributeString(idStep, "outputRowSize");
    this.databaseName = rep.getStepAttributeString(idStep, "databaseName");
    this.tableName = rep.getStepAttributeString(idStep, "tableName");
    this.dimensionCount = rep.getStepAttributeString(idStep, "dimensionCount");
    this.noDictionaryDims = rep.getStepAttributeString(idStep, "noDictionaryDims");
    this.noDictionaryDims = rep.getStepAttributeString(idStep, "noDictionaryDimsMapping");
    this.complexDimensionCount = rep.getStepAttributeString(idStep, "complexDimensionCount");
    this.measureCount = rep.getStepAttributeString(idStep, "measureCount");
    this.updateMemberRequest = rep.getStepAttributeString(idStep, "isUpdateMemberRequest");
    this.measureDataType = rep.getStepAttributeString(idStep, "measureDataType");
    this.partitionID = rep.getStepAttributeString(idStep, "partitionID");
    this.segmentId = rep.getStepAttributeString(idStep, "segmentId");
    this.taskNo = rep.getStepAttributeString(idStep, "taskNo");
  } catch (Exception ex) {
    throw new KettleException(BaseMessages
        .getString(PKG, "CarbonDataWriterStepMeta.Exception.UnexpectedErrorInReadingStepInfo",
            new String[0]), ex);
  }
}
 

import org.pentaho.di.core.database.DatabaseMeta; //导入依赖的package包/类
@Override
public void loadXML(Node stepnode, List<DatabaseMeta> databases, Map<String, Counter> counters)
    throws KettleXMLException {
  try {
    tableName = XMLHandler.getTagValue(stepnode, "TableName");
    aggregateLevels = XMLHandler.getTagValue(stepnode, "AggregateLevels");
    numberOfCores = XMLHandler.getTagValue(stepnode, "NumberOfCores");
    databaseName = XMLHandler.getTagValue(stepnode, "databaseName");
    tableName = XMLHandler.getTagValue(stepnode, "tableName");
    noDictionaryDims = XMLHandler.getTagValue(stepnode, "noDictionaryDims");
    measureCount = XMLHandler.getTagValue(stepnode, "measureCount");
    columnGroupsString = XMLHandler.getTagValue(stepnode, "dimensionsStoreType");
    dimensionCount = XMLHandler.getTagValue(stepnode, "dimensionCount");
    complexDimsCount = XMLHandler.getTagValue(stepnode, "complexDimsCount");
    complexTypeString = XMLHandler.getTagValue(stepnode, "complexTypeString");
    measureDataType = XMLHandler.getTagValue(stepnode, "measureDataType");
    taskNo = XMLHandler.getTagValue(stepnode, "taskNo");
    factTimeStamp = XMLHandler.getTagValue(stepnode, "factTimeStamp");
    partitionID = XMLHandler.getTagValue(stepnode, "partitionID");
    isUseInvertedIndex = XMLHandler.getTagValue(stepnode, "isUseInvertedIndex");
    segmentId = XMLHandler.getTagValue(stepnode, "segmentId");
    noDictionaryDimsMapping = XMLHandler.getTagValue(stepnode, "noDictionaryDimsMapping");
  } catch (Exception e) {
    throw new KettleXMLException("Unable to read step info from XML node", e);
  }
}
 

import org.pentaho.di.core.database.DatabaseMeta; //导入依赖的package包/类
@Override public void readRep(Repository rep, ObjectId idStep, List<DatabaseMeta> databases,
    Map<String, Counter> counters) throws KettleException {
  try {
    tableName = rep.getStepAttributeString(idStep, "TableName");
    aggregateLevels = rep.getStepAttributeString(idStep, "AggregateLevels");
    numberOfCores = rep.getStepAttributeString(idStep, "NumberOfCores");
    databaseName = rep.getStepAttributeString(idStep, "databaseName");
    tableName = rep.getStepAttributeString(idStep, "tableName");
    noDictionaryDims = rep.getStepAttributeString(idStep, "noDictionaryDims");
    measureCount = rep.getStepAttributeString(idStep, "measureCount");
    columnGroupsString = rep.getStepAttributeString(idStep, "dimensionsStoreType");
    dimensionCount = rep.getStepAttributeString(idStep, "dimensionCount");
    complexDimsCount = rep.getStepAttributeString(idStep, "complexDimsCount");
    complexTypeString = rep.getStepAttributeString(idStep, "complexTypeString");
    measureDataType = rep.getStepAttributeString(idStep, "measureDataType");
    taskNo = rep.getStepAttributeString(idStep, "taskNo");
    factTimeStamp = rep.getStepAttributeString(idStep, "factTimeStamp");
    partitionID = rep.getStepAttributeString(idStep, "partitionID");
    isUseInvertedIndex = rep.getStepAttributeString(idStep, "isUseInvertedIndex");
    segmentId = rep.getStepAttributeString(idStep, "segmentId");
    noDictionaryDimsMapping = rep.getStepAttributeString(idStep, "noDictionaryDimsMapping");
  } catch (Exception e) {
    throw new KettleException(BaseMessages
        .getString(pkg, "CarbonMDKeyStepMeta.Exception.UnexpectedErrorInReadingStepInfo"), e);
  }
}
 

import org.pentaho.di.core.database.DatabaseMeta; //导入依赖的package包/类
@Override public void readRep( Repository rep, IMetaStore metaStore, ObjectId stepId, List<DatabaseMeta> databases )
    throws KettleException {
  try {
    broker = rep.getStepAttributeString( stepId, "BROKER" );
    topic = rep.getStepAttributeString( stepId, "TOPIC" );
    m_topicIsFromField = rep.getStepAttributeBoolean( stepId, "TOPIC_IS_FROM_FIELD" );
    field = rep.getStepAttributeString( stepId, "FIELD" );
    clientId = rep.getStepAttributeString( stepId, "CLIENT_ID" );
    timeout = rep.getStepAttributeString( stepId, "TIMEOUT" );
    qos = rep.getStepAttributeString( stepId, "QOS" );
    requiresAuth = Boolean.parseBoolean( rep.getStepAttributeString( stepId, "REQUIRES_AUTH" ) );
    username = rep.getStepAttributeString( stepId, "USERNAME" );
    password = rep.getStepAttributeString( stepId, "PASSWORD" );

    sslCaFile = rep.getStepAttributeString( stepId, "SSL_CA_FILE" );
    sslCertFile = rep.getStepAttributeString( stepId, "SSL_CERT_FILE" );
    sslKeyFile = rep.getStepAttributeString( stepId, "SSL_KEY_FILE" );
    sslKeyFilePass = rep.getStepAttributeString( stepId, "SSL_KEY_FILE_PASS" );
  } catch ( Exception e ) {
    throw new KettleException( "MQTTClientMeta.Exception.loadRep", e );
  }
}