| /******************************************************************************* |
| * Copyright (c) 2006, 2007 Oracle. All rights reserved. |
| * This program and the accompanying materials are made available under the terms of |
| * the Eclipse Public License v1.0, which accompanies this distribution and is available at |
| * http://www.eclipse.org/legal/epl-v10.html. |
| * |
| * Contributors: |
| * Oracle - initial API and implementation |
| ******************************************************************************/ |
| package org.eclipse.jpt.db.internal; |
| |
| import java.text.Collator; |
| import java.util.Collection; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.Set; |
| import org.eclipse.datatools.connectivity.sqm.core.rte.ICatalogObject; |
| import org.eclipse.datatools.connectivity.sqm.core.rte.ICatalogObjectListener; |
| import org.eclipse.jpt.utility.internal.StringTools; |
| import org.eclipse.jpt.utility.internal.iterators.TransformationIterator; |
| |
| /** |
| * Wrap a DTP Schema |
| */ |
| public final class Schema extends DTPWrapper { |
| private final Database database; |
| private final org.eclipse.datatools.modelbase.sql.schema.Schema dtpSchema; |
| private ICatalogObjectListener schemaListener; |
| |
| private Set tables; // lazy-initialized |
| private Set sequences; // lazy-initialized |
| |
| |
| // ********** constructors ********** |
| |
| Schema( Database database, org.eclipse.datatools.modelbase.sql.schema.Schema dtpSchema) { |
| super(); |
| this.database = database; |
| this.dtpSchema = dtpSchema; |
| this.initialize(); |
| } |
| |
| // ********** behavior ********** |
| |
| private void initialize() { |
| if( this.connectionIsOnline()) { |
| this.schemaListener = this.buildSchemaListener(); |
| this.addCatalogObjectListener(( ICatalogObject) this.dtpSchema, this.schemaListener); |
| } |
| } |
| |
| protected boolean connectionIsOnline() { |
| return this.database.connectionIsOnline(); |
| } |
| |
| private ICatalogObjectListener buildSchemaListener() { |
| return new ICatalogObjectListener() { |
| public void notifyChanged( final ICatalogObject schema, final int eventType) { |
| if( schema == Schema.this.dtpSchema) { |
| Schema.this.refresh(); |
| Schema.this.database.schemaChanged( Schema.this, eventType); |
| } |
| } |
| }; |
| } |
| |
| private void refresh() { |
| this.disposeTables(); |
| this.disposeSequences(); |
| |
| this.tables = null; |
| this.sequences = null; |
| } |
| |
| void tableChanged( Table table, int eventType) { |
| this.database.tableChanged( table, this, eventType); |
| } |
| |
| protected Table wrap( org.eclipse.datatools.modelbase.sql.tables.Table table) { |
| return new Table( this, table); |
| } |
| |
| protected Sequence wrap( org.eclipse.datatools.modelbase.sql.schema.Sequence sequence) { |
| return new Sequence( this, sequence); |
| } |
| |
| protected void dispose() { |
| this.removeCatalogObjectListener(( ICatalogObject) this.dtpSchema, this.schemaListener); |
| |
| this.disposeTables(); |
| this.disposeSequences(); |
| } |
| |
| private void disposeTables() { |
| if( this.tables != null) { |
| for( Iterator i = this.tables(); i.hasNext(); ) { |
| (( Table)i.next()).dispose(); |
| } |
| } |
| } |
| |
| private void disposeSequences() { |
| if( this.sequences != null) { |
| for( Iterator i = this.sequences(); i.hasNext(); ) { |
| (( Sequence)i.next()).dispose(); |
| } |
| } |
| } |
| |
| // ********** queries ********** |
| |
| public String getName() { |
| return this.dtpSchema.getName(); |
| } |
| |
| boolean isCaseSensitive() { |
| return this.database.isCaseSensitive(); |
| } |
| |
| Column column( org.eclipse.datatools.modelbase.sql.tables.Column dtpColumn) { |
| return this.database.column(dtpColumn); |
| } |
| |
| |
| // ********** tables ********** |
| |
| private synchronized Collection getTables() { |
| if( this.tables == null) { |
| this.tables = this.buildTables(); |
| } |
| return this.tables; |
| } |
| |
| private Set buildTables() { |
| Collection dtpTables = this.dtpSchema.getTables(); |
| Set result = new HashSet( dtpTables.size()); |
| for( Iterator i = dtpTables.iterator(); i.hasNext(); ) { |
| result.add( this.wrap(( org.eclipse.datatools.modelbase.sql.tables.Table) i.next())); |
| } |
| return result; |
| } |
| |
| public Iterator tables() { |
| return this.getTables().iterator(); |
| } |
| |
| public int tablesSize() { |
| return this.getTables().size(); |
| } |
| |
| public boolean tablesContains( Column column) { |
| return this.getTables().contains( column); |
| } |
| |
| public Iterator<String> tableNames() { |
| return new TransformationIterator( this.tables()) { |
| protected Object transform( Object next) { |
| return (( Table) next).getName(); |
| } |
| }; |
| } |
| |
| public boolean containsTableNamed( String name) { |
| return this.tableNamed( name) != null; |
| } |
| |
| public Table tableNamed( String name) { |
| return this.isCaseSensitive() ? this.tableNamedInternal( name) : this.tableNamedIgnoreCase( name); |
| } |
| |
| private Table tableNamedInternal( String name) { |
| for( Iterator i = this.tables(); i.hasNext(); ) { |
| Table table = ( Table) i.next(); |
| if( table.getName().equals( name)) { |
| return table; |
| } |
| } |
| return null; |
| } |
| |
| private Table tableNamedIgnoreCase( String name) { |
| for( Iterator i = this.tables(); i.hasNext(); ) { |
| Table table = ( Table) i.next(); |
| if( StringTools.stringsAreEqualIgnoreCase( table.getName(), name)) { |
| return table; |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * return the table for the specified dtp table |
| */ |
| Table table( org.eclipse.datatools.modelbase.sql.tables.Table dtpTable) { |
| if( dtpTable.getSchema() != this.dtpSchema) { |
| return this.database.table( dtpTable); |
| } |
| for( Iterator i = this.tables(); i.hasNext(); ) { |
| Table table = ( Table) i.next(); |
| if( table.wraps( dtpTable)) { |
| return table; |
| } |
| } |
| throw new IllegalArgumentException( "invalid DTP table: " + dtpTable); |
| } |
| |
| // ***** sequences |
| |
| private synchronized Collection getSequences() { |
| if( this.sequences == null) { |
| this.sequences = this.buildSequences(); |
| } |
| return this.sequences; |
| } |
| |
| private Set buildSequences() { |
| Collection dtpSequences = this.dtpSchema.getSequences(); |
| Set result = new HashSet( dtpSequences.size()); |
| for( Iterator i = dtpSequences.iterator(); i.hasNext(); ) { |
| result.add( this.wrap(( org.eclipse.datatools.modelbase.sql.schema.Sequence) i.next())); |
| } |
| return result; |
| } |
| |
| public Iterator sequences() { |
| return this.getSequences().iterator(); |
| } |
| |
| public int sequencesSize() { |
| return this.getSequences().size(); |
| } |
| |
| public boolean sequencesContains( Column column) { |
| return this.getSequences().contains( column); |
| } |
| |
| public Iterator sequenceNames() { |
| return new TransformationIterator(this.sequences()) { |
| protected Object transform( Object next) { |
| return (( Sequence)next).getName(); |
| } |
| }; |
| } |
| |
| public boolean containsSequenceNamed( String name) { |
| return this.sequenceNamed( name) != null; |
| } |
| |
| public Sequence sequenceNamed( String name) { |
| return this.isCaseSensitive() ? this.sequenceNamedInternal( name) : this.sequenceNamedIgnoreCase( name); |
| } |
| |
| private Sequence sequenceNamedInternal( String name) { |
| for( Iterator i = this.sequences(); i.hasNext(); ) { |
| Sequence sequence = ( Sequence) i.next(); |
| if( sequence.getName().equals( name)) { |
| return sequence; |
| } |
| } |
| return null; |
| } |
| |
| private Sequence sequenceNamedIgnoreCase( String name) { |
| for( Iterator i = this.sequences(); i.hasNext(); ) { |
| Sequence sequence = ( Sequence) i.next(); |
| if( sequence.getName().equalsIgnoreCase( name)) { |
| return sequence; |
| } |
| } |
| return null; |
| } |
| |
| boolean wraps( org.eclipse.datatools.modelbase.sql.schema.Schema dtpSchema) { |
| return this.dtpSchema == dtpSchema; |
| } |
| |
| // ********** Comparable implementation ********** |
| |
| public int compareTo( Object o) { |
| return Collator.getInstance().compare( this.getName(), (( Schema)o).getName()); |
| } |
| |
| } |