MutableTable.java

/* 
 *
 * SchemaCrawler
 * http://sourceforge.net/projects/schemacrawler
 * Copyright (c) 2000-2010, Sualeh Fatehi.
 *
 * This library is free software; you can redistribute it and/or modify it under the terms
 * of the GNU Lesser General Public License as published by the Free Software Foundation;
 * either version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License along with this
 * library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
 * Boston, MA 02111-1307, USA.
 *
 */

package schemacrawler.build;


import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import schemacrawler.schema.CheckConstraint;
import schemacrawler.schema.Column;
import schemacrawler.schema.ForeignKey;
import schemacrawler.schema.ForeignKeyColumnMap;
import schemacrawler.schema.Index;
import schemacrawler.schema.NamedObject;
import schemacrawler.schema.PrimaryKey;
import schemacrawler.schema.Privilege;
import schemacrawler.schema.Schema;
import schemacrawler.schema.Table;
import schemacrawler.schema.TableRelationshipType;
import schemacrawler.schema.TableType;
import schemacrawler.schema.Trigger;

/**
 * Represents a table in the database.
 * 
 * @author Sualeh Fatehi
 */
public class MutableTable
  extends BaseDatabaseObjectMetadata
  implements Table
{

  private enum TableAssociationType
  {

    all,
    exported,
    imported;
  }

  private static final long serialVersionUID = 3257290248802284852L;

  private final TableType type;
  private final PrimaryKey primaryKey;
  private final Column[] columns;
  private final ForeignKey[] foreignKeys;
  private final Index[] indices;
  private final CheckConstraint[] checkConstraints;
  private final Trigger[] triggers;
  private final Privilege[] privileges;
  private final int sortIndex;

  MutableTable(final TableBuilder builder)
  {
    super(builder);
    this.type = builder.type;
    this.primaryKey = builder.primaryKey;
    this.columns = builder.getColumns();
    this.foreignKeys = builder.getForeignKeys();
    this.indices = builder.getIndices();
    this.checkConstraints = builder.getCheckConstraints();
    this.triggers = builder.getTriggers();
    this.privileges = builder.getPrivileges();
    this.sortIndex = builder.sortIndex;
  }

  /**
   * {@inheritDoc}
   */
  @Override
  public int compareTo(final NamedObject obj)
  {
    if (obj == null)
    {
      return -1;
    }

    final MutableTable other = (MutableTable) obj;
    int comparison = 0;

    if (comparison == 0)
    {
      comparison = sortIndex - other.sortIndex;
    }
    if (comparison == 0)
    {
      comparison = super.compareTo(other);
    }

    return comparison;
  }

  /**
   * {@inheritDoc}
   * 
   * @see Table#getCheckConstraints()
   */
  public CheckConstraint[] getCheckConstraints()
  {
    return checkConstraints;
  }

  /**
   * {@inheritDoc}
   * 
   * @see schemacrawler.schema.Table#getColumn(java.lang.String)
   */
  public Column getColumn(final String name)
  {
    Column column = null;
    for (final Column aColumn: columns)
    {
      if (aColumn.getName().equals(name))
      {
        column = aColumn;
        break;
      }
    }
    return column;
  }

  /**
   * {@inheritDoc}
   * 
   * @see Table#getColumns()
   */
  public Column[] getColumns()
  {
    return columns;
  }

  /**
   * {@inheritDoc}
   * 
   * @see schemacrawler.schema.Table#getColumnsListAsString()
   */
  public String getColumnsListAsString()
  {
    final StringBuilder buffer = new StringBuilder();
    for (int i = 0; i < columns.length; i++)
    {
      final Column column = columns[i];
      if (i > 0)
      {
        buffer.append(", ");
      }
      buffer.append(column.getName());
    }
    return buffer.toString();
  }

  /**
   * {@inheritDoc}
   * 
   * @see schemacrawler.schema.Table#getExportedForeignKeys()
   */
  public ForeignKey[] getExportedForeignKeys()
  {
    return getForeignKeys(TableAssociationType.exported);
  }

  /**
   * {@inheritDoc}
   * 
   * @see schemacrawler.schema.Table#getForeignKey(java.lang.String)
   */
  public ForeignKey getForeignKey(final String name)
  {
    ForeignKey foreignKey = null;
    for (final ForeignKey aForeignKey: foreignKeys)
    {
      if (aForeignKey.getName().equals(name))
      {
        foreignKey = aForeignKey;
        break;
      }
    }
    return foreignKey;
  }

  /**
   * {@inheritDoc}
   * 
   * @see schemacrawler.schema.Table#getForeignKeys()
   */
  public ForeignKey[] getForeignKeys()
  {
    return getForeignKeys(TableAssociationType.all);
  }

  public ForeignKey[] getImportedForeignKeys()
  {
    return getForeignKeys(TableAssociationType.imported);
  }

  /**
   * {@inheritDoc}
   * 
   * @see schemacrawler.schema.Table#getIndex(java.lang.String)
   */
  public Index getIndex(final String name)
  {
    Index index = null;
    for (final Index aIndex: indices)
    {
      if (aIndex.getName().equals(name))
      {
        index = aIndex;
        break;
      }
    }
    return index;
  }

  /**
   * {@inheritDoc}
   * 
   * @see Table#getIndices()
   */
  public Index[] getIndices()
  {
    return indices;
  }

  /**
   * {@inheritDoc}
   * 
   * @see Table#getPrimaryKey()
   */
  public PrimaryKey getPrimaryKey()
  {
    return primaryKey;
  }

  /**
   * {@inheritDoc}
   * 
   * @see schemacrawler.schema.Table#getPrivilege(java.lang.String)
   */
  public Privilege getPrivilege(final String name)
  {
    Privilege privilege = null;
    for (final Privilege aPrivilege: privileges)
    {
      if (aPrivilege.getName().equals(name))
      {
        privilege = aPrivilege;
        break;
      }
    }
    return privilege;
  }

  /**
   * {@inheritDoc}
   * 
   * @see Table#getPrivileges()
   */
  public Privilege[] getPrivileges()
  {
    return privileges;
  }

  /**
   * {@inheritDoc}
   * 
   * @see schemacrawler.schema.Table#getRelatedTables(schemacrawler.schema.TableRelationshipType)
   */
  public Table[] getRelatedTables(final TableRelationshipType tableRelationshipType)
  {
    final Set<MutableTable> relatedTables = new HashSet<MutableTable>();
    if (tableRelationshipType != null
        && tableRelationshipType != TableRelationshipType.none)
    {
      for (final ForeignKey mutableForeignKey: foreignKeys)
      {
        for (final ForeignKeyColumnMap columnPair: mutableForeignKey
          .getColumnPairs())
        {
          final MutableTable parentTable = (MutableTable) columnPair
            .getPrimaryKeyColumn().getParent();
          final MutableTable childTable = (MutableTable) columnPair
            .getForeignKeyColumn().getParent();
          switch (tableRelationshipType)
          {
            case parent:
              if (equals(childTable))
              {
                relatedTables.add(parentTable);
              }
              break;
            case child:
              if (equals(parentTable))
              {
                relatedTables.add(childTable);
              }
              break;
            default:
              break;
          }
        }
      }
    }
    return relatedTables.toArray(new Table[relatedTables.size()]);
  }

  /**
   * {@inheritDoc}
   * 
   * @see schemacrawler.schema.Table#getTrigger(java.lang.String)
   */
  public Trigger getTrigger(final String name)
  {
    Trigger trigger = null;
    for (final Trigger aTrigger: triggers)
    {
      if (aTrigger.getName().equals(name))
      {
        trigger = aTrigger;
        break;
      }
    }
    return trigger;
  }

  /**
   * {@inheritDoc}
   * 
   * @see Table#getTriggers()
   */
  public Trigger[] getTriggers()
  {
    return triggers;
  }

  /**
   * {@inheritDoc}
   * 
   * @see Table#getType()
   */
  public TableType getType()
  {
    return type;
  }

  private ForeignKey[] getForeignKeys(final TableAssociationType tableAssociationType)
  {
    final List<ForeignKey> foreignKeysList = new ArrayList<ForeignKey>(Arrays.asList(foreignKeys));
    if (tableAssociationType != null
        && tableAssociationType != TableAssociationType.all)
    {
      for (final Iterator<ForeignKey> iterator = foreignKeysList.iterator(); iterator
        .hasNext();)
      {
        final ForeignKey mutableForeignKey = iterator.next();
        final ForeignKeyColumnMap[] columnPairs = mutableForeignKey
          .getColumnPairs();
        boolean isExportedKey = false;
        boolean isImportedKey = false;
        for (final ForeignKeyColumnMap columnPair: columnPairs)
        {
          if (columnPair.getPrimaryKeyColumn().getParent().equals(this))
          {
            isExportedKey = true;
          }
          if (columnPair.getForeignKeyColumn().getParent().equals(this))
          {
            isImportedKey = true;
          }
        }
        switch (tableAssociationType)
        {
          case exported:
            if (!isExportedKey)
            {
              iterator.remove();
            }
            break;
          case imported:
            if (!isImportedKey)
            {
              iterator.remove();
            }
            break;
          default:
            break;
        }
      }
    }
    return foreignKeysList.toArray(new ForeignKey[foreignKeysList.size()]);
  }

  int getSortIndex()
  {
    return sortIndex;
  }

  public class TableBuilder
    extends BaseDatabaseObjectBuilder
  {

    protected TableBuilder(Schema schema, String name)
    {
      super(schema, name);
    }

    private static final long serialVersionUID = 3257290248802284852L;

    private TableType type = TableType.unknown; // Default value
    private MutablePrimaryKey primaryKey;
    private final Set<ColumnMetadata> columns = new HashSet<ColumnMetadata>();
    private final Set<MutableForeignKey> foreignKeys = new HashSet<MutableForeignKey>();
    private final Set<MutableIndex> indices = new HashSet<MutableIndex>();
    private final Set<CheckConstraintMetadata> checkConstraints = new HashSet<CheckConstraintMetadata>();
    private final Set<MutableTrigger> triggers = new HashSet<MutableTrigger>();
    private final Set<MutablePrivilege> privileges = new HashSet<MutablePrivilege>();
    private int sortIndex;

    public CheckConstraint[] getCheckConstraints()
    {
      return checkConstraints.toArray(new CheckConstraint[checkConstraints
        .size()]);
    }

    public Column[] getColumns()
    {
      return columns.toArray(new Column[columns.size()]);
    }

    public ForeignKey[] getForeignKeys()
    {
      return foreignKeys.toArray(new ForeignKey[foreignKeys.size()]);
    }

    public Index[] getIndices()
    {
      return indices.toArray(new Index[indices.size()]);
    }

    public MutablePrimaryKey getPrimaryKey()
    {
      return primaryKey;
    }

    public Privilege[] getPrivileges()
    {
      return privileges.toArray(new Privilege[privileges.size()]);
    }

    /**
     * {@inheritDoc}
     * 
     * @see Table#getTriggers()
     */
    public Trigger[] getTriggers()
    {
      return triggers.toArray(new Trigger[triggers.size()]);
    }

    public TableType getType()
    {
      return type;
    }

    public void addCheckConstraint(final CheckConstraintMetadata checkConstraint)
    {
      checkConstraints.add(checkConstraint);
    }

    public void addColumn(final ColumnMetadata column)
    {
      columns.add(column);
    }

    public void addForeignKey(final MutableForeignKey foreignKey)
    {
      foreignKeys.add(foreignKey);
    }

    public void addIndex(final MutableIndex index)
    {
      indices.add(index);
    }

    public void addPrivilege(final MutablePrivilege privilege)
    {
      privileges.add(privilege);
    }

    public void addTrigger(final MutableTrigger trigger)
    {
      triggers.add(trigger);
    }

    public int getSortIndex()
    {
      return sortIndex;
    }

    public void setPrimaryKey(final MutablePrimaryKey primaryKey)
    {
      this.primaryKey = primaryKey;
    }

    public void setSortIndex(final int sortIndex)
    {
      this.sortIndex = sortIndex;
    }

    public void setType(final TableType type)
    {
      if (type == null)
      {
        throw new IllegalArgumentException("Null table type");
      }
      this.type = type;
    }

  }

}