import schemacrawler.schema.Column; //导入依赖的package包/类
/**
 * Uses heuristics to determine whether a table is a join table.
 * <p>
 * A table is identified as a join table if every column is part of a foreign key or part of the primary key. Furthermore the primary may only consist of
 * a single column or every column has to be part of a foreign key.
 *
 * @param table The table to check
 * @return {@code true} if the table is probably a join table, false otherwise
 */
public static boolean isJoinTable(final Table table) {
    if (table.getPrimaryKey() == null) {
        return false;
    }
    final boolean hasMultipartFK = (table.getPrimaryKey().getColumns().size() > 1);
    for (final Column column : table.getColumns()) {
        if (hasMultipartFK) {
            // has to be both
            if (!(column.isPartOfForeignKey() && column.isPartOfPrimaryKey())) {
                return false;
            }
        } else {
            // If there is a single column that is not part of a foreign key and not the primary key, it needs a separate class
            if (!column.isPartOfForeignKey() && !column.isPartOfPrimaryKey()) {
                return false;
            }
        }
    }
    return true;
}
 

import schemacrawler.schema.Column; //导入依赖的package包/类
/**
 * Fills a {@link ColumnModel} with information from a {@link Column}.
 * @param column The column
 * @return The filled model
 */
public ColumnModel extractColumnModel(Column column) {
    LOG.debug("Extracting model for column {}", column.getName());
    ColumnModel model = new ColumnModel();
    model.setName(this.nameProvider.getMethodNameForColumn(column));
    model.setDbName(ModelUtil.removeQuotes(column.getName()));
    model.setDbTableName(column.getParent().getName());
    model.setDbFullTableName(column.getParent().getFullName());

    model.setSqlType(column.getColumnDataType().getName());
    model.setSqlTypeInt(column.getColumnDataType().getJavaSqlType().getJavaSqlType());
    String javaDataTypeName = dataTypeProvider.getCanonicalDataTypeName(column);
    model.setJavaTypeName(javaDataTypeName);
    model.setNotNull(!column.isNullable());
    model.setPartOfPrimaryKey(column.isPartOfPrimaryKey());
    model.setPartOfForeignKey(column.isPartOfForeignKey());
    model.setExplicitAttribute(explicitAttributeDecider.isExplicitAttribute(column));
    model.setUnique(column.isPartOfUniqueIndex() || column.isPartOfPrimaryKey());

    model.setConvenienceSetters(convenienceSetterProvider.getConvenienceSetters(column, javaDataTypeName));

    return model;
}
 

import schemacrawler.schema.Column; //导入依赖的package包/类
@Override
public String getCanonicalDataTypeName(final Column column) {
    if (typeMappings.getTableMappings() != null) {
        final HashMap<String, String> tableMap = typeMappings.getTableMappings().get(column.getParent().getFullName());
        if (tableMap != null) {
            final String className = tableMap.get(column.getName());
            if (className != null) {
                return className;
            }
        }
    }
    final HashMap<String, String> defaultMappings = typeMappings.getDefaultTypeMappings();
    if (defaultMappings != null) {
        List<String> variants = DataTypePrecisionHelper.getDataTypeWithAllPrecisionVariants(column);
        for (final String variant : variants) {
            final String defaultType = defaultMappings.get(variant);
            if (defaultType != null) {
                return defaultType;
            }
        }
    }
    return fallbackProvider.getCanonicalDataTypeName(column);
}
 

import schemacrawler.schema.Column; //导入依赖的package包/类
@Test
public void testGetDataTypeBySqlName() throws Exception {
    TypeMappings typeMappings = new TypeMappings();
    typeMappings.setDefaultTypeMappings(Arrays.asList(
            new DefaultTypeMapping("DECIMAL", "java.lang.Long"),
            new DefaultTypeMapping("DECIMAL(1)", "java.lang.Boolean")
    ));

    ColumnDataType cdt = Mockito.mock(ColumnDataType.class);
    Mockito.when(cdt.getName()).thenReturn("DECIMAL");
    Column column1 = Mockito.mock(Column.class);
    Mockito.when(column1.getColumnDataType()).thenReturn(cdt);
    Mockito.when(column1.getSize()).thenReturn(1);
    Mockito.when(column1.getDecimalDigits()).thenReturn(0);

    Column column2 = Mockito.mock(Column.class);
    Mockito.when(column2.getColumnDataType()).thenReturn(cdt);
    Mockito.when(column2.getSize()).thenReturn(10);
    Mockito.when(column2.getSize()).thenReturn(0);

    XmlFileDataTypeProvider dataTypeProvider = new XmlFileDataTypeProvider(typeMappings, new DefaultDataTypeProvider());

    Assert.assertEquals("java.lang.Boolean", dataTypeProvider.getDataTypeBySqlType(column1));
    Assert.assertEquals("java.lang.Long", dataTypeProvider.getDataTypeBySqlType(column2));
}
 

import schemacrawler.schema.Column; //导入依赖的package包/类
protected NodeSpec toNodeSpec(EntitySpec entitySpec, Column column) {
    NodeSpec nodeSpec = new NodeSpec();
    nodeSpec.setName( getNodeName( column ));
    if (nodeSpec.getName().equals("id")) {
        nodeSpec.setPrimaryKey(true);
    }
    nodeSpec.setColumnName( column.getName());
    nodeSpec.setJdbcType( getNodeType( column ));
    nodeSpec.setJavaType( getJavaType( nodeSpec.getJdbcType() ));
    nodeSpec.setNullable( column.isNullable() ? Nullable.NULL : Nullable.NOT_NULL);
    if (nodeSpec.getJavaType() == JavaType.STRING) {
        nodeSpec.setLength( column.getSize() );
    }
    else if (nodeSpec.getJavaType() == JavaType.BIGDECIMAL) {
        nodeSpec.setPrecision( column.getSize() );
        nodeSpec.setScale( column.getDecimalDigits());
    }
    nodeSpec.setEntity(entitySpec);
    nodeSpecs.put(column, nodeSpec);
    return nodeSpec;
}
 

import schemacrawler.schema.Column; //导入依赖的package包/类
/**
 * The lint that does the job
 * @param table table
 * @param connection connection
 */
@Override
protected void lint(final Table table, final Connection connection) throws SchemaCrawlerException{

    try (Statement stmt = connection.createStatement()){

        List<Column> columns = getColumns(table);
        int columnDataType;
        int count;
        int distinctCount;

        for (Column column : columns) {
            columnDataType = column.getColumnDataType().getJavaSqlType().getJavaSqlType();
            if(columnDataType == Types.BINARY || columnDataType == Types.BLOB) {
                inspectBlobData(stmt, table, column);
            }
        }
    }catch (SQLException ex) {
        LOGGER.severe(ex.getMessage());
        throw new SchemaCrawlerException(ex.getMessage(), ex);
    }

}
 

import schemacrawler.schema.Column; //导入依赖的package包/类
private void findMismatchedForeignKeys(final Table table){
    
    if (table != null && !(table instanceof View))
    {
        for (final ForeignKey foreignKey: table.getImportedForeignKeys())
        {
            for (final ForeignKeyColumnReference columnReference: foreignKey)
            {
                final Column pkColumn = columnReference.getPrimaryKeyColumn();
                final Column fkColumn = columnReference.getForeignKeyColumn();
                if (!pkColumn.getColumnDataType().getJavaSqlType().getJavaSqlTypeName().equals(fkColumn.getColumnDataType().getJavaSqlType().getJavaSqlTypeName())
                        || pkColumn.getSize() != fkColumn.getSize())
                {
                    addTableLint(table, "Foreign key data type ("+fkColumn.getColumnDataType().getJavaSqlType().getJavaSqlTypeName()+") "
                            + "does not match Primary key ("+pkColumn.getColumnDataType().getJavaSqlType().getJavaSqlTypeName()+").", foreignKey);
                    break;
                }
            }
        }
    }
}
 

import schemacrawler.schema.Column; //导入依赖的package包/类
/**
 * The lint that does the job
 *
 * @param table      table
 * @param connection connection
 */
@Override
protected void lint(final Table table, final Connection connection) throws SchemaCrawlerException {
    try {
        if ("PostgreSQL".equalsIgnoreCase(connection.getMetaData().getDatabaseProductName()) && "9.4".compareTo(connection.getMetaData().getDatabaseProductVersion()) <= 0) {
            List<Column> columns = getColumns(table);
            for (Column column : columns) {
                LOGGER.log(Level.INFO, "Checking {0}...", column.getFullName() + " - " + column.getColumnDataType().getDatabaseSpecificTypeName());
                if (Objects.equals("bytea", column.getColumnDataType().getDatabaseSpecificTypeName())) {
                    addLint(table, getDescription(), column.getFullName());
                }
            }
        }
    } catch (SQLException ex) {
        LOGGER.severe(ex.getMessage());
        throw new SchemaCrawlerException(ex.getMessage(), ex);
    }
}
 

import schemacrawler.schema.Column; //导入依赖的package包/类
private static int getSelectCount(Statement stmt, Table table, Column column) throws SchemaCrawlerException{
    String tableName = table.getName().replaceAll("\"", "");
    String columnName = column.getName().replaceAll("\"", "");

    String sql = "select count (\"" + columnName + "\") as countRow from \"" + tableName +"\"";
    LOGGER.log(Level.CONFIG, "SQL : {0}", sql);

    int count = 0;
    try(ResultSet rs = stmt.executeQuery(sql)){
        if(rs.next()){
            count = rs.getInt("countRow");
        }
    }catch (SQLException ex) {
        LOGGER.severe(ex.getMessage());
        throw new SchemaCrawlerException(ex.getMessage(), ex);
    }
    return count;
}
 

import schemacrawler.schema.Column; //导入依赖的package包/类
private static int getSelectDistinctCount(Statement stmt, Table table, Column column) throws SchemaCrawlerException{
    String tableName = table.getName().replaceAll("\"", "");
    String columnName = column.getName().replaceAll("\"", "");
    
    String sql = "select count (distinct \"" + columnName + "\") as countDistinctRow from \"" + tableName +"\"";
    LOGGER.log(Level.CONFIG, "SQL : {0}", sql);
    
    int count = 0;
    try(ResultSet rs = stmt.executeQuery(sql)){
        if(rs.next()){
            count = rs.getInt("countDistinctRow");
        }
    }catch (SQLException ex) {
        LOGGER.severe(ex.getMessage());
        throw new SchemaCrawlerException(ex.getMessage(), ex);
    }
    return count;
}
 

import schemacrawler.schema.Column; //导入依赖的package包/类
@Override
public boolean isExplicitAttribute(Column column) {
    String tableName = column.getParent().getName();
    String columnName = column.getName();

    return explicitDataByTableRegex.keySet().stream()
            .filter(tableName::matches)
            .flatMap(tableNameRegex -> {
                if (explicitDataByTableRegex.get(tableNameRegex).attributes == null) {
                    return null;
                }
                return Arrays.stream(explicitDataByTableRegex.get(tableNameRegex).attributes);
            })
            .anyMatch(columnName::matches);
}
 

import schemacrawler.schema.Column; //导入依赖的package包/类
private static boolean matchesColumns(final String[] regexes, final ForeignKey foreignKey) {
    /*return foreignKey.getColumnReferences().stream()
            .map(ForeignKeyColumnReference::getForeignKeyColumn)
            .map(Column::getName)
            .anyMatch(name -> name.matches(regex));*/
    List<String> columnNames = foreignKey.getColumnReferences().stream()
            .map(ForeignKeyColumnReference::getForeignKeyColumn)
            .map(Column::getName)
            .collect(Collectors.toList());
    if (columnNames.size() != regexes.length) {
        return false;
    }
    final Stack<Integer> usedFields = new Stack<>();
    for (final String colName : columnNames) {
        boolean foundMatch = false;
        for (int i = 0; i < regexes.length; i++) {
            if (!usedFields.contains(i)) {
                foundMatch = colName.matches(regexes[i]);
                if (foundMatch) {
                    usedFields.push(i);
                    break;
                }
            }
        }
        if (!foundMatch) {
            return false;
        }
    }
    return true;

}
 

import schemacrawler.schema.Column; //导入依赖的package包/类
@Override
public String getMethodNameForColumn(final Column column) {
    if (mappings.containsKey(column.getParent().getName())) {
        if (mappings.get(column.getParent().getName()).getColumns() != null &&
                mappings.get(column.getParent().getName()).getColumns().containsKey(column.getName())) {
            return mappings.get(column.getParent().getName()).getColumns().get(column.getName());
        }
    }
    return null;
}
 

import schemacrawler.schema.Column; //导入依赖的package包/类
/**
 * Generates an appropriate method name for a foreign key
 * @param foreignKey The database foreign key
 * @return The generated name
 */
@Override
public String getMethodNameForReference(final ForeignKey foreignKey) {
    final Column c = foreignKey.getColumnReferences().get(0).getForeignKeyColumn();
    // check if only one-column fk
    if (foreignKey.getColumnReferences().size() == 1) {
        return getMethodNameForColumn(c) + getClassNameForTable(c.getReferencedColumn().getParent());
    }

    final StringBuilder nameBuilder = new StringBuilder();
    final List<String> words = new ArrayList<>(Arrays.asList(foreignKey.getName()
            .toLowerCase()
            .replaceAll("(^[0-9]+|[^a-z0-9_-])", "") // Delete every not-alphanumeric or _/- character and numbers at beginning
            .split("_")));
    words.removeAll(Arrays.asList("fk", "", null)); // removes FK_ prefix and empty entries
    final List<String> tableWords = new ArrayList<>(Arrays.asList(c.getParent().getName()
            .toLowerCase()
            .replaceAll("(^[0-9]+|[^a-z0-9_-])", "") // Delete every not-alphanumeric or _/- character and numbers at beginning
            .split("_")));
    words.removeAll(tableWords);
    nameBuilder.append(words.get(0));
    for (int i = 1; i < words.size(); i++) {
        String word = words.get(i);

        nameBuilder.append(word.substring(0, 1).toUpperCase());
        nameBuilder.append(word.substring(1));
    }
    return nameBuilder.toString();
}
 

import schemacrawler.schema.Column; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public String getMethodNameForColumn(final Column column) {
    this.wasUsedBefore = true;
    for (final NameProvider provider : providers) {
        final String name = provider.getMethodNameForColumn(column);
        if (Objects.nonNull(name)) {
            return name;
        }
    }
    return this.fallbackProvider.getMethodNameForColumn(column);
}
 

import schemacrawler.schema.Column; //导入依赖的package包/类
@Override
public String getMethodNameForForeignKeyColumn(ForeignKey foreignKey, Column primaryKeyColumn, Column foreignKeyColumn) {
    this.wasUsedBefore = true;
    for (final NameProvider provider : providers) {
        final String name = provider.getMethodNameForForeignKeyColumn(foreignKey, primaryKeyColumn, foreignKeyColumn);
        if (Objects.nonNull(name)) {
            return name;
        }
    }
    return this.fallbackProvider.getMethodNameForForeignKeyColumn(foreignKey, primaryKeyColumn, foreignKeyColumn);
}
 

import schemacrawler.schema.Column; //导入依赖的package包/类
@Override
public String getCanonicalDataTypeName(final Column column) {
    String dataTypeByName = getDataTypeByName(column.getParent().getName(), column.getName());
    String dataTypeByType = getDataTypeBySqlType(column);
    return dataTypeByName != null ? dataTypeByName :
            dataTypeByType != null ? dataTypeByType : fallbackDataTypeProvider.getCanonicalDataTypeName(column);
}
 

import schemacrawler.schema.Column; //导入依赖的package包/类
String getDataTypeBySqlType(final Column column) {
    List<String> variants = DataTypePrecisionHelper.getDataTypeWithAllPrecisionVariants(column);
    return variants.stream()
            .map(variant ->
                    typeMappings.getDefaultTypeMappings().stream()
                            .filter(dtm -> dtm.getSqlType().replaceAll("\\s", "").toUpperCase().equals(variant.toUpperCase()))
                            .findFirst().orElse(null))
            .filter(Objects::nonNull)
            .map(DefaultTypeMapping::getJavaType)
            .findFirst().orElse(null);
}
 

import schemacrawler.schema.Column; //导入依赖的package包/类
@Override
public List<ConvenienceSetterModel> getConvenienceSetters(Column column, String javaDataTypeName) {
    return this.convenienceSetterConfig.getConvenienceSetterConfigs().stream()
            .filter(dataTypeConvenienceSetterConfig -> dataTypeConvenienceSetterConfig.getJavaDataTypeName().equals(javaDataTypeName))
            .flatMap(dataTypeConvenienceSetterConfig -> dataTypeConvenienceSetterConfig.getConvenienceSetters().stream())
            .collect(Collectors.toList());
}
 

import schemacrawler.schema.Column; //导入依赖的package包/类
@Test
public void getConvenienceSetters() throws Exception {
    InputStream stream = this.getClass().getResourceAsStream("XmlFileConvencienceSetterProviderTest.xml");
    InputStreamReader reader = new InputStreamReader(stream, "UTF-8");

    XmlFileConvenienceSetterProvider provider = new XmlFileConvenienceSetterProvider(reader);

    Assert.assertEquals(1, provider.getConvenienceSetters(Mockito.mock(Column.class), "java.util.Date").size());
}