jpa/plugins/org.eclipse.jpt.db/src/org/eclipse/jpt/db/internal/DTPConnectionProfileWrapper.java - dali/webtools.dali - Git at Google

 /*******************************************************************************
  * Copyright (c) 2006, 2008 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.Iterator;
 import java.util.Vector;

 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.datatools.connectivity.ConnectEvent;
 import org.eclipse.datatools.connectivity.IConnectionProfile;
 import org.eclipse.datatools.connectivity.IManagedConnection;
 import org.eclipse.datatools.connectivity.IManagedConnectionOfflineListener;
 import org.eclipse.datatools.connectivity.drivers.DriverManager;
 import org.eclipse.datatools.connectivity.drivers.jdbc.IJDBCDriverDefinitionConstants;
 import org.eclipse.datatools.connectivity.sqm.core.connection.ConnectionInfo;
 import org.eclipse.datatools.sqltools.core.DatabaseIdentifier;
 import org.eclipse.datatools.sqltools.core.profile.ProfileUtil;
 import org.eclipse.jpt.db.ConnectionListener;
 import org.eclipse.jpt.db.ConnectionProfile;
 import org.eclipse.jpt.db.Schema;
 import org.eclipse.jpt.utility.internal.StringTools;
 import org.eclipse.jpt.utility.internal.iterators.CloneIterator;

 /**
  *  Wrap a DTP ConnectionProfile
  */
 final class DTPConnectionProfileWrapper
 	implements ConnectionProfile, ConnectionProfileHolder
 {
 	// the wrapped DTP connection profile
 	private final IConnectionProfile dtpConnectionProfile;

 	// the DTP managed connection we listen to
 	private final IManagedConnection dtpManagedConnection;

 	// forward events from the DTP connection profile's managed connections
 	private final LocalConnectionListener connectionListener;

 	// lazy-initialized - can be a "null" database
 	private InternalDatabase database;


 	// ********** constants **********

 	public static final String LIVE_DTP_CONNECTION_TYPE = "java.sql.Connection";  //$NON-NLS-1$

 	public static final String OFFLINE_DTP_CONNECTION_TYPE = ConnectionInfo.class.getName();

 	public static final String DATABASE_PRODUCT_PROP_ID = "org.eclipse.datatools.connectivity.server.version";  //$NON-NLS-1$

 	public static final String POSTGRESQL_VENDOR = "postgres";  //$NON-NLS-1$

 	public static final String POSTGRESQL_DEFAULT_SCHEMA_NAME = "public";  //$NON-NLS-1$


 	// ********** constructor **********

 	DTPConnectionProfileWrapper(IConnectionProfile dtpConnectionProfile) {
 		super();
 		this.dtpConnectionProfile = dtpConnectionProfile;
 		this.dtpManagedConnection = this.buildDTPManagedConnection();
 		this.connectionListener = new LocalConnectionListener();
 		this.dtpManagedConnection.addConnectionListener(this.connectionListener);
 	}

 	private IManagedConnection buildDTPManagedConnection() {
 		String connectionType = this.dtpConnectionProfile.supportsWorkOfflineMode() ?
 				OFFLINE_DTP_CONNECTION_TYPE : LIVE_DTP_CONNECTION_TYPE;
 		return this.dtpConnectionProfile.getManagedConnection(connectionType);
 	}


 	// ********** ConnectionProfileHolder implementation **********

 	public DTPConnectionProfileWrapper getConnectionProfile() {
 		return this;
 	}


 	// ********** ConnectionProfile implementation **********

 	public String getName() {
 		return this.dtpConnectionProfile.getName();
 	}

 	public boolean isNull() {
 		return false;
 	}

 	public void connect() {
 		if (this.isDisconnected()) {
 			this.checkStatus(this.dtpConnectionProfile.connect());
 		}
 	}

 	public void disconnect() {
 		this.checkStatus(this.dtpConnectionProfile.disconnect());
 	}

 	public boolean isActive() {
 		return this.isConnected() || this.isWorkingOffline();
 	}

 	public boolean isInactive() {
 		return ! this.isActive();
 	}

 	public boolean isConnected() {
 		return this.dtpManagedConnection.isConnected()
 				&& ! this.dtpManagedConnection.isWorkingOffline();
 	}

 	public boolean isDisconnected() {
 		return ! this.isConnected();
 	}

 	public boolean isWorkingOffline() {
 		return this.dtpManagedConnection.isWorkingOffline();
 	}

 	public boolean supportsWorkOfflineMode() {
 		return this.dtpConnectionProfile.supportsWorkOfflineMode();
 	}

 	public boolean canWorkOffline() {
 		return this.dtpConnectionProfile.canWorkOffline();
 	}

 	public IStatus saveWorkOfflineData() {
 		return this.dtpConnectionProfile.saveWorkOfflineData();
 	}

 	public IStatus workOffline() {
 		return this.dtpConnectionProfile.workOffline();
 	}

 	public String getDatabaseVendor() {
 		return this.getProperty(IJDBCDriverDefinitionConstants.DATABASE_VENDOR_PROP_ID);
 	}

 	public String getDatabaseName() {
 		return this.getProperty(IJDBCDriverDefinitionConstants.DATABASE_NAME_PROP_ID);
 	}

 	public String getDatabaseProduct() {
 		return this.getProperty(DATABASE_PRODUCT_PROP_ID);
 	}

 	public String getDatabaseVersion() {
 		return this.getProperty(IJDBCDriverDefinitionConstants.DATABASE_VERSION_PROP_ID);
 	}

 	public String getUserName() {
 		String userName = this.getProperty(IJDBCDriverDefinitionConstants.USERNAME_PROP_ID);
 		if (userName.contains(" ")){
 			return userName.split("\\s")[0];
 		}
 		return userName;
 	}

 	public String getUserPassword() {
 		return this.getProperty(IJDBCDriverDefinitionConstants.PASSWORD_PROP_ID);
 	}

 	public synchronized InternalDatabase getDatabase() {
 		if (this.database == null) {
 			this.database = this.buildDatabase();
 		}
 		return this.database;
 	}

 	public DTPCatalogWrapper getDefaultCatalog() {
 		return this.getDatabase().getDefaultCatalog();
 	}

 	public void addConnectionListener(ConnectionListener listener) {
 		this.connectionListener.addConnectionListener(listener);
 	}

 	public void removeConnectionListener(ConnectionListener listener) {
 		this.connectionListener.removeConnectionListener(listener);
 	}

 	public Schema getDefaultSchema() {
 		return this.getDatabase().schemaNamed(this.getDefaultSchemaName());
 	}

 	public String getDriverClassName() {
 		return this.getProperty(IJDBCDriverDefinitionConstants.DRIVER_CLASS_PROP_ID);
 	}

 	public String getUrl() {
 		return this.getProperty(IJDBCDriverDefinitionConstants.URL_PROP_ID);
 	}

 	public String getInstanceID() {
 		return this.dtpConnectionProfile.getInstanceID();
 	}

 	public String getProviderID() {
 		return this.dtpConnectionProfile.getProviderId();
 	}

 	public String getDriverDefinitionID() {
 		return this.getProperty(DRIVER_DEFINITION_PROP_ID);
 	}

 	public String getDriverJarList() {
 		return DriverManager.getInstance().getDriverInstanceByID(this.getDriverDefinitionID()).getJarList();
 	}


 	// ********** internal methods **********

 	private void checkStatus(IStatus status) {
 		if (status.isOK()) {
 			return;
 		}
 		if (status.isMultiStatus()) {
 			status = status.getChildren()[0];  // take the first one?
 		}
 		throw new RuntimeException(status.getMessage(), status.getException());
 	}

 	private InternalDatabase buildDatabase() {
 		if (this.isInactive()) {
 			return NullDatabase.instance();
 		}

 		if (this.isWorkingOffline()) {
 			ConnectionInfo connectionInfo = (ConnectionInfo) this.dtpManagedConnection.getConnection().getRawConnection();
 			return new DTPDatabaseWrapper(this, connectionInfo.getSharedDatabase());
 		}

 		// TODO see DTP bug 202306
 		// pass connect=true in to ProfileUtil.getDatabase()
 		// there is a bug mentioned in a comment:
 		//     "during the profile connected event notification,
 		//     IManagedConnection is connected while IConnectionProfile is not"
 		// so, some hackery here to handle hackery there
 		return new DTPDatabaseWrapper(this, ProfileUtil.getDatabase(new DatabaseIdentifier(this.getName(), this.getDatabaseName()), true));
 	}

 	boolean wraps(IConnectionProfile dtpCP) {
 		return this.dtpConnectionProfile == dtpCP;
 	}

 	void databaseChanged(DTPDatabaseWrapper db, int eventType) {
 		this.connectionListener.databaseChanged(db, eventType);
 	}

 	void catalogChanged(DTPCatalogWrapper catalog, int eventType) {
 		this.connectionListener.catalogChanged(catalog, eventType);
 	}

 	void schemaChanged(DTPSchemaWrapper schema, int eventType) {
 		this.connectionListener.schemaChanged(schema, eventType);
 	}

 	void sequenceChanged(DTPSequenceWrapper sequence, int eventType) {
 		this.connectionListener.sequenceChanged(sequence, eventType);
 	}

 	void tableChanged(DTPTableWrapper table, int eventType) {
 		this.connectionListener.tableChanged(table, eventType);
 	}

 	void columnChanged(DTPColumnWrapper column, int eventType) {
 		this.connectionListener.columnChanged(column, eventType);
 	}

 	void foreignKeyChanged(DTPForeignKeyWrapper foreignKey, int eventType) {
 		this.connectionListener.foreignKeyChanged(foreignKey, eventType);
 	}

 	/**
 	 * private - use #getDefaultSchema() : Schema instead
 	 */
 	private String getDefaultSchemaName() {
 		if (this.getDatabase().getVendor().equalsIgnoreCase(POSTGRESQL_VENDOR)) {
 			return POSTGRESQL_DEFAULT_SCHEMA_NAME;
 		}
 		return this.getUserName();
 	}

 	private String getProperty(String propertyName) {
 		return this.dtpConnectionProfile.getBaseProperties().getProperty(propertyName);
 	}


 	// ********** disposal **********

 	synchronized void dispose() {
 		this.disposeDatabase();
 		this.dtpManagedConnection.removeConnectionListener(this.connectionListener);
 	}

 	synchronized void disposeDatabase() {
 		if (this.database != null) {
 			this.database.dispose();
 			this.database = null;
 		}
 	}


 	// ********** Comparable implementation **********

 	public int compareTo(ConnectionProfile connectionProfile) {
 		return Collator.getInstance().compare(this.getName(), connectionProfile.getName());
 	}


 	// ********** overrides **********

 	@Override
 	public String toString() {
 		return StringTools.buildToStringFor(this, this.getName());
 	}


 	// ********** DTP connection listener **********

 	/**
 	 * This listener translates and forwards IManagedConnectionListener and
 	 * IManagedConnectionOfflineListener events to ConnectionListeners.
 	 */
 	private class LocalConnectionListener implements IManagedConnectionOfflineListener {
 		private Vector<ConnectionListener> listeners = new Vector<ConnectionListener>();

 		LocalConnectionListener() {
 			super();
 		}

 		void addConnectionListener(ConnectionListener listener) {
 			this.listeners.add(listener);
 		}

 		void removeConnectionListener(ConnectionListener listener) {
 			this.listeners.remove(listener);
 		}

 		private Iterator<ConnectionListener> listeners() {
 			return new CloneIterator<ConnectionListener>(this.listeners);
 		}


 		// ********** IManagedConnectionListener implementation **********

 		public void opened(ConnectEvent event) {
 			// clear the (possibly "null") database so it will be rebuilt with the "live" data
 			DTPConnectionProfileWrapper.this.disposeDatabase();
 			// forward event to listeners
 			for (Iterator<ConnectionListener> stream = this.listeners(); stream.hasNext(); ) {
 				stream.next().opened(DTPConnectionProfileWrapper.this);
 			}
 		}

 		/**
 		 * This method is never called from the base DTP code.
 		 * Perhaps DTP extenders call it....
 		 * @see ManagedConnection#fireModifiedEvent(Object)
 		 *     which is never called...
 		 */
 		public void modified(ConnectEvent event) {
 			// forward event to listeners
 			for (Iterator<ConnectionListener> stream = this.listeners(); stream.hasNext(); ) {
 				stream.next().modified(DTPConnectionProfileWrapper.this);
 			}
 		}

 		public boolean okToClose(ConnectEvent event) {
 			// forward event to listeners
 			for (Iterator<ConnectionListener> stream = this.listeners(); stream.hasNext(); ) {
 				if ( ! stream.next().okToClose(DTPConnectionProfileWrapper.this)) {
 					return false;
 				}
 			}
 			return true;
 		}

 		public void aboutToClose(ConnectEvent event) {
 			// forward event to listeners
 			for (Iterator<ConnectionListener> stream = this.listeners(); stream.hasNext(); ) {
 				stream.next().aboutToClose(DTPConnectionProfileWrapper.this);
 			}
 		}

 		public void closed(ConnectEvent event) {
 			// clear the database
 			DTPConnectionProfileWrapper.this.disposeDatabase();
 			// forward event to listeners
 			for (Iterator<ConnectionListener> stream = this.listeners(); stream.hasNext(); ) {
 				stream.next().closed(DTPConnectionProfileWrapper.this);
 			}
 		}


 		// ********** IManagedConnectionOfflineListener implementation **********

 		// live => off-line
 		public boolean okToDetach(ConnectEvent event) {
 			// don't forward the event to listeners (?)
 			return true;
 		}

 		// live => off-line
 		public void aboutToDetach(ConnectEvent event) {
 			// don't forward the event; the database will be cleared and
 			// listeners will be notified once the "offline" connection is "opened/workingOffline"
 		}

 		// live => off-line
 		public void workingOffline(ConnectEvent event) {
 			// clear the (possibly null) database so it will be rebuilt with the "off-line" data
 			DTPConnectionProfileWrapper.this.disposeDatabase();
 			// convert the event to an "open" event and forward it to listeners
 			for (Iterator<ConnectionListener> stream = this.listeners(); stream.hasNext(); ) {
 				stream.next().opened(DTPConnectionProfileWrapper.this);
 			}
 		}

 		// off-line => live
 		public void aboutToAttach(ConnectEvent event) {
 			// don't forward the event; the database will be cleared and
 			// listeners will be notified once the "live" connection is "opened"
 		}


 		// ********** internal methods **********

 		void databaseChanged(DTPDatabaseWrapper db, int eventType) {
 			for (Iterator<ConnectionListener> stream = this.listeners(); stream.hasNext(); ) {
 				stream.next().databaseChanged(DTPConnectionProfileWrapper.this, db);
 			}
 		}

 		void catalogChanged(DTPCatalogWrapper catalog, int eventType) {
 			for (Iterator<ConnectionListener> stream = this.listeners(); stream.hasNext(); ) {
 				stream.next().catalogChanged(DTPConnectionProfileWrapper.this, catalog);
 			}
 		}

 		void schemaChanged(DTPSchemaWrapper schema, int eventType) {
 			for (Iterator<ConnectionListener> stream = this.listeners(); stream.hasNext(); ) {
 				stream.next().schemaChanged(DTPConnectionProfileWrapper.this, schema);
 			}
 		}

 		void sequenceChanged(DTPSequenceWrapper sequence, int eventType) {
 			for (Iterator<ConnectionListener> stream = this.listeners(); stream.hasNext(); ) {
 				stream.next().sequenceChanged(DTPConnectionProfileWrapper.this, sequence);
 			}
 		}

 		void tableChanged(DTPTableWrapper table, int eventType) {
 			for (Iterator<ConnectionListener> stream = this.listeners(); stream.hasNext(); ) {
 				stream.next().tableChanged(DTPConnectionProfileWrapper.this, table);
 			}
 		}

 		void columnChanged(DTPColumnWrapper column, int eventType) {
 			for (Iterator<ConnectionListener> stream = this.listeners(); stream.hasNext(); ) {
 				stream.next().columnChanged(DTPConnectionProfileWrapper.this, column);
 			}
 		}

 		void foreignKeyChanged(DTPForeignKeyWrapper foreignKey, int eventType) {
 			for (Iterator<ConnectionListener> stream = this.listeners(); stream.hasNext(); ) {
 				stream.next().foreignKeyChanged(DTPConnectionProfileWrapper.this, foreignKey);
 			}
 		}

 	}

 }
	/*******************************************************************************
	* Copyright (c) 2006, 2008 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.Iterator;
	import java.util.Vector;

	import org.eclipse.core.runtime.IStatus;
	import org.eclipse.datatools.connectivity.ConnectEvent;
	import org.eclipse.datatools.connectivity.IConnectionProfile;
	import org.eclipse.datatools.connectivity.IManagedConnection;
	import org.eclipse.datatools.connectivity.IManagedConnectionOfflineListener;
	import org.eclipse.datatools.connectivity.drivers.DriverManager;
	import org.eclipse.datatools.connectivity.drivers.jdbc.IJDBCDriverDefinitionConstants;
	import org.eclipse.datatools.connectivity.sqm.core.connection.ConnectionInfo;
	import org.eclipse.datatools.sqltools.core.DatabaseIdentifier;
	import org.eclipse.datatools.sqltools.core.profile.ProfileUtil;
	import org.eclipse.jpt.db.ConnectionListener;
	import org.eclipse.jpt.db.ConnectionProfile;
	import org.eclipse.jpt.db.Schema;
	import org.eclipse.jpt.utility.internal.StringTools;
	import org.eclipse.jpt.utility.internal.iterators.CloneIterator;

	/**
	* Wrap a DTP ConnectionProfile
	*/
	final class DTPConnectionProfileWrapper
	implements ConnectionProfile, ConnectionProfileHolder
	{
	// the wrapped DTP connection profile
	private final IConnectionProfile dtpConnectionProfile;

	// the DTP managed connection we listen to
	private final IManagedConnection dtpManagedConnection;

	// forward events from the DTP connection profile's managed connections
	private final LocalConnectionListener connectionListener;

	// lazy-initialized - can be a "null" database
	private InternalDatabase database;


	// ******** constants ********

	public static final String LIVE_DTP_CONNECTION_TYPE = "java.sql.Connection"; //$NON-NLS-1$

	public static final String OFFLINE_DTP_CONNECTION_TYPE = ConnectionInfo.class.getName();

	public static final String DATABASE_PRODUCT_PROP_ID = "org.eclipse.datatools.connectivity.server.version"; //$NON-NLS-1$

	public static final String POSTGRESQL_VENDOR = "postgres"; //$NON-NLS-1$

	public static final String POSTGRESQL_DEFAULT_SCHEMA_NAME = "public"; //$NON-NLS-1$


	// ******** constructor ********

	DTPConnectionProfileWrapper(IConnectionProfile dtpConnectionProfile) {
	super();
	this.dtpConnectionProfile = dtpConnectionProfile;
	this.dtpManagedConnection = this.buildDTPManagedConnection();
	this.connectionListener = new LocalConnectionListener();
	this.dtpManagedConnection.addConnectionListener(this.connectionListener);
	}

	private IManagedConnection buildDTPManagedConnection() {
	String connectionType = this.dtpConnectionProfile.supportsWorkOfflineMode() ?
	OFFLINE_DTP_CONNECTION_TYPE : LIVE_DTP_CONNECTION_TYPE;
	return this.dtpConnectionProfile.getManagedConnection(connectionType);
	}


	// ******** ConnectionProfileHolder implementation ********

	public DTPConnectionProfileWrapper getConnectionProfile() {
	return this;
	}


	// ******** ConnectionProfile implementation ********

	public String getName() {
	return this.dtpConnectionProfile.getName();
	}

	public boolean isNull() {
	return false;
	}

	public void connect() {
	if (this.isDisconnected()) {
	this.checkStatus(this.dtpConnectionProfile.connect());
	}
	}

	public void disconnect() {
	this.checkStatus(this.dtpConnectionProfile.disconnect());
	}

	public boolean isActive() {
	return this.isConnected() \|\| this.isWorkingOffline();
	}

	public boolean isInactive() {
	return ! this.isActive();
	}

	public boolean isConnected() {
	return this.dtpManagedConnection.isConnected()
	&& ! this.dtpManagedConnection.isWorkingOffline();
	}

	public boolean isDisconnected() {
	return ! this.isConnected();
	}

	public boolean isWorkingOffline() {
	return this.dtpManagedConnection.isWorkingOffline();
	}

	public boolean supportsWorkOfflineMode() {
	return this.dtpConnectionProfile.supportsWorkOfflineMode();
	}

	public boolean canWorkOffline() {
	return this.dtpConnectionProfile.canWorkOffline();
	}

	public IStatus saveWorkOfflineData() {
	return this.dtpConnectionProfile.saveWorkOfflineData();
	}

	public IStatus workOffline() {
	return this.dtpConnectionProfile.workOffline();
	}

	public String getDatabaseVendor() {
	return this.getProperty(IJDBCDriverDefinitionConstants.DATABASE_VENDOR_PROP_ID);
	}

	public String getDatabaseName() {
	return this.getProperty(IJDBCDriverDefinitionConstants.DATABASE_NAME_PROP_ID);
	}

	public String getDatabaseProduct() {
	return this.getProperty(DATABASE_PRODUCT_PROP_ID);
	}

	public String getDatabaseVersion() {
	return this.getProperty(IJDBCDriverDefinitionConstants.DATABASE_VERSION_PROP_ID);
	}

	public String getUserName() {
	String userName = this.getProperty(IJDBCDriverDefinitionConstants.USERNAME_PROP_ID);
	if (userName.contains(" ")){
	return userName.split("\\s")[0];
	}
	return userName;
	}

	public String getUserPassword() {
	return this.getProperty(IJDBCDriverDefinitionConstants.PASSWORD_PROP_ID);
	}

	public synchronized InternalDatabase getDatabase() {
	if (this.database == null) {
	this.database = this.buildDatabase();
	}
	return this.database;
	}

	public DTPCatalogWrapper getDefaultCatalog() {
	return this.getDatabase().getDefaultCatalog();
	}

	public void addConnectionListener(ConnectionListener listener) {
	this.connectionListener.addConnectionListener(listener);
	}

	public void removeConnectionListener(ConnectionListener listener) {
	this.connectionListener.removeConnectionListener(listener);
	}

	public Schema getDefaultSchema() {
	return this.getDatabase().schemaNamed(this.getDefaultSchemaName());
	}

	public String getDriverClassName() {
	return this.getProperty(IJDBCDriverDefinitionConstants.DRIVER_CLASS_PROP_ID);
	}

	public String getUrl() {
	return this.getProperty(IJDBCDriverDefinitionConstants.URL_PROP_ID);
	}

	public String getInstanceID() {
	return this.dtpConnectionProfile.getInstanceID();
	}

	public String getProviderID() {
	return this.dtpConnectionProfile.getProviderId();
	}

	public String getDriverDefinitionID() {
	return this.getProperty(DRIVER_DEFINITION_PROP_ID);
	}

	public String getDriverJarList() {
	return DriverManager.getInstance().getDriverInstanceByID(this.getDriverDefinitionID()).getJarList();
	}


	// ******** internal methods ********

	private void checkStatus(IStatus status) {
	if (status.isOK()) {
	return;
	}
	if (status.isMultiStatus()) {
	status = status.getChildren()[0]; // take the first one?
	}
	throw new RuntimeException(status.getMessage(), status.getException());
	}

	private InternalDatabase buildDatabase() {
	if (this.isInactive()) {
	return NullDatabase.instance();
	}

	if (this.isWorkingOffline()) {
	ConnectionInfo connectionInfo = (ConnectionInfo) this.dtpManagedConnection.getConnection().getRawConnection();
	return new DTPDatabaseWrapper(this, connectionInfo.getSharedDatabase());
	}

	// TODO see DTP bug 202306
	// pass connect=true in to ProfileUtil.getDatabase()
	// there is a bug mentioned in a comment:
	// "during the profile connected event notification,
	// IManagedConnection is connected while IConnectionProfile is not"
	// so, some hackery here to handle hackery there
	return new DTPDatabaseWrapper(this, ProfileUtil.getDatabase(new DatabaseIdentifier(this.getName(), this.getDatabaseName()), true));
	}

	boolean wraps(IConnectionProfile dtpCP) {
	return this.dtpConnectionProfile == dtpCP;
	}

	void databaseChanged(DTPDatabaseWrapper db, int eventType) {
	this.connectionListener.databaseChanged(db, eventType);
	}

	void catalogChanged(DTPCatalogWrapper catalog, int eventType) {
	this.connectionListener.catalogChanged(catalog, eventType);
	}

	void schemaChanged(DTPSchemaWrapper schema, int eventType) {
	this.connectionListener.schemaChanged(schema, eventType);
	}

	void sequenceChanged(DTPSequenceWrapper sequence, int eventType) {
	this.connectionListener.sequenceChanged(sequence, eventType);
	}

	void tableChanged(DTPTableWrapper table, int eventType) {
	this.connectionListener.tableChanged(table, eventType);
	}

	void columnChanged(DTPColumnWrapper column, int eventType) {
	this.connectionListener.columnChanged(column, eventType);
	}

	void foreignKeyChanged(DTPForeignKeyWrapper foreignKey, int eventType) {
	this.connectionListener.foreignKeyChanged(foreignKey, eventType);
	}

	/**
	* private - use #getDefaultSchema() : Schema instead
	*/
	private String getDefaultSchemaName() {
	if (this.getDatabase().getVendor().equalsIgnoreCase(POSTGRESQL_VENDOR)) {
	return POSTGRESQL_DEFAULT_SCHEMA_NAME;
	}
	return this.getUserName();
	}

	private String getProperty(String propertyName) {
	return this.dtpConnectionProfile.getBaseProperties().getProperty(propertyName);
	}


	// ******** disposal ********

	synchronized void dispose() {
	this.disposeDatabase();
	this.dtpManagedConnection.removeConnectionListener(this.connectionListener);
	}

	synchronized void disposeDatabase() {
	if (this.database != null) {
	this.database.dispose();
	this.database = null;
	}
	}


	// ******** Comparable implementation ********

	public int compareTo(ConnectionProfile connectionProfile) {
	return Collator.getInstance().compare(this.getName(), connectionProfile.getName());
	}


	// ******** overrides ********

	@Override
	public String toString() {
	return StringTools.buildToStringFor(this, this.getName());
	}


	// ******** DTP connection listener ********

	/**
	* This listener translates and forwards IManagedConnectionListener and
	* IManagedConnectionOfflineListener events to ConnectionListeners.
	*/
	private class LocalConnectionListener implements IManagedConnectionOfflineListener {
	private Vector<ConnectionListener> listeners = new Vector<ConnectionListener>();

	LocalConnectionListener() {
	super();
	}

	void addConnectionListener(ConnectionListener listener) {
	this.listeners.add(listener);
	}

	void removeConnectionListener(ConnectionListener listener) {
	this.listeners.remove(listener);
	}

	private Iterator<ConnectionListener> listeners() {
	return new CloneIterator<ConnectionListener>(this.listeners);
	}


	// ******** IManagedConnectionListener implementation ********

	public void opened(ConnectEvent event) {
	// clear the (possibly "null") database so it will be rebuilt with the "live" data
	DTPConnectionProfileWrapper.this.disposeDatabase();
	// forward event to listeners
	for (Iterator<ConnectionListener> stream = this.listeners(); stream.hasNext(); ) {
	stream.next().opened(DTPConnectionProfileWrapper.this);
	}
	}

	/**
	* This method is never called from the base DTP code.
	* Perhaps DTP extenders call it....
	* @see ManagedConnection#fireModifiedEvent(Object)
	* which is never called...
	*/
	public void modified(ConnectEvent event) {
	// forward event to listeners
	for (Iterator<ConnectionListener> stream = this.listeners(); stream.hasNext(); ) {
	stream.next().modified(DTPConnectionProfileWrapper.this);
	}
	}

	public boolean okToClose(ConnectEvent event) {
	// forward event to listeners
	for (Iterator<ConnectionListener> stream = this.listeners(); stream.hasNext(); ) {
	if ( ! stream.next().okToClose(DTPConnectionProfileWrapper.this)) {
	return false;
	}
	}
	return true;
	}

	public void aboutToClose(ConnectEvent event) {
	// forward event to listeners
	for (Iterator<ConnectionListener> stream = this.listeners(); stream.hasNext(); ) {
	stream.next().aboutToClose(DTPConnectionProfileWrapper.this);
	}
	}

	public void closed(ConnectEvent event) {
	// clear the database
	DTPConnectionProfileWrapper.this.disposeDatabase();
	// forward event to listeners
	for (Iterator<ConnectionListener> stream = this.listeners(); stream.hasNext(); ) {
	stream.next().closed(DTPConnectionProfileWrapper.this);
	}
	}


	// ******** IManagedConnectionOfflineListener implementation ********

	// live => off-line
	public boolean okToDetach(ConnectEvent event) {
	// don't forward the event to listeners (?)
	return true;
	}

	// live => off-line
	public void aboutToDetach(ConnectEvent event) {
	// don't forward the event; the database will be cleared and
	// listeners will be notified once the "offline" connection is "opened/workingOffline"
	}

	// live => off-line
	public void workingOffline(ConnectEvent event) {
	// clear the (possibly null) database so it will be rebuilt with the "off-line" data
	DTPConnectionProfileWrapper.this.disposeDatabase();
	// convert the event to an "open" event and forward it to listeners
	for (Iterator<ConnectionListener> stream = this.listeners(); stream.hasNext(); ) {
	stream.next().opened(DTPConnectionProfileWrapper.this);
	}
	}

	// off-line => live
	public void aboutToAttach(ConnectEvent event) {
	// don't forward the event; the database will be cleared and
	// listeners will be notified once the "live" connection is "opened"
	}


	// ******** internal methods ********

	void databaseChanged(DTPDatabaseWrapper db, int eventType) {
	for (Iterator<ConnectionListener> stream = this.listeners(); stream.hasNext(); ) {
	stream.next().databaseChanged(DTPConnectionProfileWrapper.this, db);
	}
	}

	void catalogChanged(DTPCatalogWrapper catalog, int eventType) {
	for (Iterator<ConnectionListener> stream = this.listeners(); stream.hasNext(); ) {
	stream.next().catalogChanged(DTPConnectionProfileWrapper.this, catalog);
	}
	}

	void schemaChanged(DTPSchemaWrapper schema, int eventType) {
	for (Iterator<ConnectionListener> stream = this.listeners(); stream.hasNext(); ) {
	stream.next().schemaChanged(DTPConnectionProfileWrapper.this, schema);
	}
	}

	void sequenceChanged(DTPSequenceWrapper sequence, int eventType) {
	for (Iterator<ConnectionListener> stream = this.listeners(); stream.hasNext(); ) {
	stream.next().sequenceChanged(DTPConnectionProfileWrapper.this, sequence);
	}
	}

	void tableChanged(DTPTableWrapper table, int eventType) {
	for (Iterator<ConnectionListener> stream = this.listeners(); stream.hasNext(); ) {
	stream.next().tableChanged(DTPConnectionProfileWrapper.this, table);
	}
	}

	void columnChanged(DTPColumnWrapper column, int eventType) {
	for (Iterator<ConnectionListener> stream = this.listeners(); stream.hasNext(); ) {
	stream.next().columnChanged(DTPConnectionProfileWrapper.this, column);
	}
	}

	void foreignKeyChanged(DTPForeignKeyWrapper foreignKey, int eventType) {
	for (Iterator<ConnectionListener> stream = this.listeners(); stream.hasNext(); ) {
	stream.next().foreignKeyChanged(DTPConnectionProfileWrapper.this, foreignKey);
	}
	}

	}

	}