protected void buildSchema()

in core/persistence-jpa-upgrader/src/main/java/org/apache/syncope/core/persistence/jpa/upgrade/WiserSchemaTool.java [53:224]
151 lines of code
60 McCabe index (conditional complexity)

    protected void buildSchema(
            final SchemaGroup db,
            final SchemaGroup repos,
            final boolean considerDatabaseState) throws SQLException {

        // add sequences
        if (getSequences()) {
            for (Schema schema : repos.getSchemas()) {
                for (Sequence seq : schema.getSequences()) {
                    if (considerDatabaseState && db.findSequence(schema, seq.getQualifiedPath()) != null) {
                        continue;
                    }

                    if (createSequence(seq)) {
                        Schema dbSchema = Optional.ofNullable(db.getSchema(seq.getSchemaIdentifier())).
                                orElseGet(() -> db.addSchema(seq.getSchemaIdentifier()));
                        dbSchema.importSequence(seq);
                    } else {
                        _log.warn(_loc.get("add-seq", seq));
                    }
                }
            }
        }

        // order is important in this method; start with columns
        DBIdentifier defaultSchemaName = DBIdentifier.newSchema(_dict.getDefaultSchemaName());
        for (Schema schema : repos.getSchemas()) {
            for (Table tab : schema.getTables()) {
                Table dbTable = considerDatabaseState
                        ? db.findTable(schema, tab.getQualifiedPath(), defaultSchemaName)
                        : null;
                if (dbTable != null) {
                    for (Column col : tab.getColumns()) {
                        Column dbCol = dbTable.getColumn(col.getIdentifier());
                        if (dbCol == null) {
                            if (addColumn(col)) {
                                dbTable.importColumn(col);
                            } else {
                                _log.warn(_loc.get("add-col", col, tab));
                            }
                        } else if (!col.equalsColumn(_dict, dbCol)) {
                            _log.warn(_loc.get("bad-col",
                                    new Object[] { dbCol, dbTable, dbCol.getDescription(), col.getDescription() }));
                        }
                    }
                }
            }
        }

        // primary keys
        if (getPrimaryKeys()) {
            for (Schema schema : repos.getSchemas()) {
                for (Table tab : schema.getTables()) {
                    PrimaryKey pk = tab.getPrimaryKey();
                    Table dbTable = considerDatabaseState
                            ? db.findTable(schema, tab.getQualifiedPath())
                            : null;
                    if (pk != null && !pk.isLogical() && dbTable != null) {
                        if (dbTable.getPrimaryKey() == null && addPrimaryKey(pk)) {
                            dbTable.importPrimaryKey(pk);
                        } else if (dbTable.getPrimaryKey() == null) {
                            _log.warn(_loc.get("add-pk", pk, tab));
                        } else if (!pk.equalsPrimaryKey(dbTable.getPrimaryKey())) {
                            _log.warn(_loc.get("bad-pk",
                                    dbTable.getPrimaryKey(), dbTable));
                        }
                    }
                }
            }
        }

        // tables
        Set<Table> newTables = new HashSet<>();
        for (Schema schema : repos.getSchemas()) {
            for (Table tab : schema.getTables()) {
                if (considerDatabaseState && db.findTable(schema, tab.getQualifiedPath()) != null) {
                    continue;
                }

                if (createTable(tab)) {
                    newTables.add(tab);
                    Schema dbSchema = Optional.ofNullable(db.getSchema(tab.getSchemaIdentifier())).
                            orElseGet(() -> db.addSchema(tab.getSchemaIdentifier()));
                    dbSchema.importTable(tab);
                } else {
                    _log.warn(_loc.get("add-table", tab));
                }
            }
        }

        // indexes
        for (Schema schema : repos.getSchemas()) {
            Table[] tabs = schema.getTables();
            for (Table tab : tabs) {
                // create indexes on new tables even if indexes have been turned off
                if (!getIndexes() && !newTables.contains(tab)) {
                    continue;
                }

                Table dbTable = considerDatabaseState
                        ? db.findTable(schema, tab.getQualifiedPath())
                        : null;
                if (dbTable != null) {
                    for (Index idx : tab.getIndexes()) {
                        Index dbIdx = findIndex(dbTable, idx);
                        if (dbIdx == null) {
                            if (createIndex(idx, dbTable, tab.getUniques())) {
                                dbTable.importIndex(idx);
                            } else {
                                _log.warn(_loc.get("add-index", idx, tab));
                            }
                        } else if (!idx.equalsIndex(dbIdx)) {
                            _log.warn(_loc.get("bad-index", dbIdx, dbTable));
                        }
                    }
                }
            }
        }

        // Unique Constraints on group of columns
        for (Schema schema : repos.getSchemas()) {
            for (Table tab : schema.getTables()) {
                // create unique constraints only on new tables
                if (!newTables.contains(tab)) {
                    continue;
                }
                Unique[] uniques = tab.getUniques();
                if (uniques == null || uniques.length == 0) {
                    continue;
                }
                Table dbTable = considerDatabaseState
                        ? db.findTable(tab)
                        : null;
                if (dbTable == null) {
                    continue;
                }
                for (Unique unique : uniques) {
                    dbTable.importUnique(unique);
                }
            }
        }

        // foreign keys
        for (Schema schema : repos.getSchemas()) {
            for (Table tab : schema.getTables()) {
                // create foreign keys on new tables even if fks have been turned off
                if (!getForeignKeys() && !newTables.contains(tab)) {
                    continue;
                }

                Table dbTable = considerDatabaseState
                        ? db.findTable(schema, tab.getQualifiedPath())
                        : null;
                if (dbTable != null) {
                    for (ForeignKey fk : tab.getForeignKeys()) {
                        if (!fk.isLogical()) {
                            ForeignKey dbFk = findForeignKey(dbTable, fk);
                            if (dbFk == null) {
                                if (addForeignKey(fk)) {
                                    dbTable.importForeignKey(fk);
                                } else {
                                    _log.warn(_loc.get("add-fk", fk, tab));
                                }
                            } else if (!fk.equalsForeignKey(dbFk)) {
                                _log.warn(_loc.get("bad-fk", dbFk, dbTable));
                            }
                        }
                    }
                }
            }
        }
    }