liquibase.dbdoc.TableWriter Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of liquibase-core Show documentation
Liquibase is a tool for managing and executing database changes.
There is a newer version: 4.30.0
package liquibase.dbdoc;

import liquibase.Scope;
import liquibase.change.Change;
import liquibase.database.Database;
import liquibase.exception.DatabaseException;
import liquibase.exception.DatabaseHistoryException;
import liquibase.resource.PathHandlerFactory;
import liquibase.resource.Resource;
import liquibase.structure.core.*;

import java.io.IOException;
import java.io.Writer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class TableWriter extends HTMLWriter {

    public TableWriter(Resource rootOutputDir, Database database) {
        super(rootOutputDir.resolve("tables"), database);
    }

    @Override
    protected String createTitle(Object object) {
        return "Changes affecting table \""+object.toString() + "\"";
    }

    @Override
    protected void writeCustomHTML(Writer fileWriter, Object object, List changes, Database database) throws IOException {
        final Table table = (Table) object;
        writeTableRemarks(fileWriter, table);
        writeColumns(fileWriter, table);
        writeTableIndexes(fileWriter, table);
        writeTableForeignKeys(fileWriter, table);
    }

    public void writeHTML(Object object, List ranChanges, List changesToRun, String changeLog, String schema) throws DatabaseHistoryException, IOException, DatabaseException {
        super.outputDir = Scope.getCurrentScope().getSingleton(PathHandlerFactory.class).getResource(super.baseOutputDir.getPath() + System.getProperty("file.separator") + schema);
        super.writeHTML(object, ranChanges, changesToRun, changeLog);

    }

    private void writeColumns(Writer fileWriter, Table table) throws IOException {
        List> cells = new ArrayList<>();

        for (Column column : table.getColumns()) {
            String remarks = column.getRemarks();
            cells.add(Arrays.asList(column.getType().toString(),
                    column.isNullable() ? "NULL" : "NOT NULL",
                    "" + column.getName() + "", (remarks != null) ? remarks : ""));
            //todo: add foreign key info to columns?
        }


        writeTable("Current Columns", cells, fileWriter);
    }

    private void writeTableRemarks(Writer fileWriter, Table table) throws IOException {
        final String tableRemarks = table.getRemarks();
        if ((tableRemarks != null) && !tableRemarks.isEmpty()) {
        	final List> cells = new ArrayList<>();
        	cells.add(Collections.singletonList(tableRemarks));
        	writeTable("Table Description", cells, fileWriter);
        }
    }

    private void writeTableIndexes(Writer fileWriter, Table table) throws IOException {
        final List> cells = new ArrayList<>();
        final PrimaryKey primaryKey = table.getPrimaryKey();
        if (!table.getIndexes().isEmpty()) {
            for (Index index : table.getIndexes()) {
                cells.add(Arrays.asList((primaryKey != null && primaryKey.getBackingIndex() == index ? "Primary Key " : index.isUnique() ? "Unique " : "Non-Unique ") +
                        (index.getClustered() == null ? "" : (index.getClustered() ? "Clustered" : "Non-Clustered")),
                        index.getName(),
                        index.getColumnNames().replace(index.getRelation().getName() + ".","")));
            }
        writeTable("Current Table Indexes", cells, fileWriter);
        }
    }

    private void writeTableForeignKeys(Writer fileWriter, Table table) throws IOException {
        final List> cells = new ArrayList<>();
        if(!table.getOutgoingForeignKeys().isEmpty())
        {
            for (ForeignKey outgoingForeignKey : table.getOutgoingForeignKeys()) {
                cells.add(Arrays.asList(outgoingForeignKey.getName(),
                        outgoingForeignKey.getForeignKeyColumns().toString().replace(table.getName() + ".", "").replaceAll("[\\[\\]]", ""),
                        outgoingForeignKey.getPrimaryKeyTable().toString(),
                        outgoingForeignKey.getPrimaryKeyColumns().toString().replace(outgoingForeignKey.getPrimaryKeyTable().toString() + ".", "").replaceAll("[\\[\\]]", "")));
            }
            writeTable("Current Table Foreign Keys", cells, fileWriter);
        }
    }
}