Question

我正在开发一个自定义nifi处理器，以比较Oracle DB中两个不同数据库用户的架构。因此，如果我们必须选择一个用户作为“源”用户，另一个用户作为“目标”用户，那么这种定制的nifi处理器将能够验证不同数据库用户之间的架构。

如果源中有目标中没有的表，则处理器将为该表生成创建脚本。如果源和目标中有相同名称的表，则将比较列。

如果源表具有目标表中不存在的列名，则处理器将生成一个更改脚本（ADD）。如果存在相同的列，则它将比较数据类型和长度。如果数据类型和长度不匹配，处理器将生成另一个更改脚本（修改）。

我这样做的方法是，从表user_tab_columns中获取表详细信息，它将提供所有列名称，数据类型，数据长度，精度，小数位数等。

因此，我将对两个数据库用户执行相同的方法。然后，我将比较源和目标的每个值，如果不匹配，我将执行所需的操作。

我只是想知道，在不同的数据库用户之间执行模式比较是否有不同的方法，以及如何改进当前方法。

private void validateCurrentTable(XelerateJsonTableDetail currentTable,DataValidationDetails dataValidationDetails) throws SQLException {

    boolean isDataAvailable = true;
    boolean validationFlag;
    List<DataValidationMetaDetails> sourceMetaDetailsList = new ArrayList<DataValidationMetaDetails>();
    List<DataValidationMetaDetails> targetMetaDetailsList = new ArrayList<DataValidationMetaDetails>();

    ResultSet metaDataSource = getColumns(sourceConnection,currentTable.getTableName());

    while(isDataAvailable){
        DataValidationMetaDetails sourceMetaDetails = new DataValidationMetaDetails() ;
        if(!metaDataSource.next()){
            isDataAvailable = false;
        }else{
            sourceMetaDetails.settableName(metaDataSource.getString("TABLE_NAME"));
            sourceMetaDetails.setColumnName(metaDataSource.getString("COLUMN_NAME"));
            sourceMetaDetails.setdataType(metaDataSource.getString("DATA_TYPE"));
            sourceMetaDetails.setdataLength(metaDataSource.getString("DATA_LENGTH"));
            sourceMetaDetails.setdataPrescision(checkNull(metaDataSource.getString("DATA_PRECISION")));
            sourceMetaDetails.setdataScale(checkNull(metaDataSource.getString("DATA_SCALE")));
            if("C".equals(metaDataSource.getString("CHAR_USED"))){
                sourceMetaDetails.setDataCharLength(metaDataSource.getString("CHAR_LENGTH"));
                sourceMetaDetails.setDataCharUsed(metaDataSource.getString("CHAR_USED"));
            }
            sourceMetaDetailsList.add(sourceMetaDetails);
        }
    }

    isDataAvailable = true;
    ResultSet metaDataTarget = getColumns(targetConnection,currentTable.getTableName());

    while(isDataAvailable){
        DataValidationMetaDetails targetMetaDetails = new DataValidationMetaDetails() ;
        if(!metaDataTarget.next()){
            isDataAvailable = false;
        }else{
            targetMetaDetails.settableName(metaDataTarget.getString("TABLE_NAME"));
            targetMetaDetails.setColumnName(metaDataTarget.getString("COLUMN_NAME"));
            targetMetaDetails.setdataType(metaDataTarget.getString("DATA_TYPE"));
            targetMetaDetails.setdataLength(metaDataTarget.getString("DATA_LENGTH"));
            targetMetaDetails.setdataPrescision(checkNull(metaDataTarget.getString("DATA_PRECISION")));
            targetMetaDetails.setdataScale(checkNull(metaDataTarget.getString("DATA_SCALE")));
            if("C".equals(metaDataTarget.getString("CHAR_USED"))){
                targetMetaDetails.setDataCharLength(metaDataTarget.getString("CHAR_LENGTH"));
                targetMetaDetails.setDataCharUsed(metaDataTarget.getString("CHAR_USED"));
            }
            targetMetaDetailsList.add(targetMetaDetails);
        }
    }
    validationFlag = compareSchema(sourceMetaDetailsList,targetMetaDetailsList);
}

private boolean compareSchema(List<DataValidationMetaDetails> sourceMetaDetailsList, List<DataValidationMetaDetails> targetMetaDetailsList) {

    Map<String,DataValidationMetaDetails> schemaMap = new HashMap<String,DataValidationMetaDetails>();
    DataValidationMetaDetails mapMetaDeatils = new DataValidationMetaDetails();

    for(DataValidationMetaDetails metaDeatils : targetMetaDetailsList){
        schemaMap.put(metaDeatils.getColumnName(), metaDeatils);
    }

    for(DataValidationMetaDetails metaDeatils : sourceMetaDetailsList){
        if(null!=schemaMap.get(metaDeatils.getColumnName())){
            mapMetaDeatils = schemaMap.get(metaDeatils.getColumnName());
            if(mapMetaDeatils.getdataType().equals(metaDeatils.getdataType())){
                if(!mapMetaDeatils.getdataLength().equals(metaDeatils.getdataLength())){
                    if(!mapMetaDeatils.getdataPrescision().equals(metaDeatils.getdataPrescision())){
                        if(!mapMetaDeatils.getdataScale().equals(metaDeatils.getdataScale())){
                            String dataTypeMod = "";
                            genAlterModifyScript(metaDeatils,"");
                        }
                    }else{

                    }
                }else{

                    genAlterModifyScript(metaDeatils,"L");
                }
            }else{
                logger.info("Data Type Mismatch for the Column : "+metaDeatils.getColumnName());
            }

        }else{
            genAlterAddScript(metaDeatils);
        }
    }
    return false;
}


private void genAlterModifyScript(DataValidationMetaDetails metaDeatils,String flag) {

    alterModifyQuery.append("\n");
    alterModifyQuery.append("ALTER TABLE ");
    alterModifyQuery.append(metaDeatils.gettableName());
    alterModifyQuery.append(" MODIFY ");
    alterModifyQuery.append(metaDeatils.getColumnName());

    switch(flag){
        case "L" : alterModifyQuery.append("("+metaDeatils.getdataLength()+")");
        break;

        case "P" : alterModifyQuery.append("("+metaDeatils.getdataPrescision()+","+metaDeatils.getdataScale()+")");
        break;

        case "S" : alterModifyQuery.append("("+metaDeatils.getdataPrescision()+","+metaDeatils.getdataScale()+")");
        break;
    }
}

Answer 1

在Oracle中，您可以执行以下操作找到SCHEMA_1和SCHEMA_2之间的表不匹配：

SELECT *
  FROM DBA_TABLES t1
  WHERE t1.OWNER = 'SCHEMA_1'
MINUS
SELECT *
  FROM DBA_TABLES t2
  WHERE t2.OWNER = 'SCHEMA_2';

类似地，要查找不匹配的列，您可以使用

SELECT c1.COLUMN_NAME,
       c1.DATA_TYPE
  FROM DBA_TAB_COLS c1
  WHERE c1.OWNER = 'SCHEMA_1' AND
        c1.TABLE_NAME IN (SELECT t2.TABLE_NAME
                            FROM DBA_TABLES t2
                            WHERE t2.OWNER = 'SCHEMA_2')
MINUS
SELECT c2.COLUMN_NAME,
       c2.DATA_TYPE
  FROM DBA_TAB_COLS c2
  WHERE c2.OWNER = 'SCHEMA_2' AND
        c2.TABLE_NAME IN (SELECT t1.TABLE_NAME
                            FROM DBA_TABLES t1
                            WHERE t1.OWNER = 'SCHEMA_1')

调整此项以比较您想比较的其他任何内容。您可以通过查询正确的DBA视图和字段将其相当容易地扩展到其他数据库对象。

好运。

如何在两个不同的数据库用户之间比较架构？

1 个答案: