X-Git-Url: http://git.phpeclipse.com diff --git a/archive/net.sourceforge.phpeclipse.quantum.sql/src/com/quantum/model/Bookmark.java b/archive/net.sourceforge.phpeclipse.quantum.sql/src/com/quantum/model/Bookmark.java new file mode 100644 index 0000000..d2dff2b --- /dev/null +++ b/archive/net.sourceforge.phpeclipse.quantum.sql/src/com/quantum/model/Bookmark.java @@ -0,0 +1,525 @@ +package com.quantum.model; + +import java.beans.PropertyChangeListener; +import java.beans.PropertyChangeSupport; +import java.sql.Connection; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashSet; +import java.util.Hashtable; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import com.quantum.IQuantumConstants; +import com.quantum.QuantumPlugin; +import com.quantum.adapters.AdapterFactory; +import com.quantum.adapters.DatabaseAdapter; +import com.quantum.sql.ConnectionEstablisher; +import com.quantum.sql.MultiSQLServer; + +import org.eclipse.jface.preference.IPreferenceStore; + +/** + * Class Bookmark holds the "static" information of a bookmark, that is the data that + * is saved and loaded from the external file and describes a bookmark. This info will + * be filled up by the end user. + * + * @author root + */ +public class Bookmark { + + private PropertyChangeSupport propertyChangeSupport = new PropertyChangeSupport(this); + private String name = ""; //$NON-NLS-1$ + private String username = ""; //$NON-NLS-1$ + private String password = ""; //$NON-NLS-1$ + private String connect = ""; //$NON-NLS-1$ + private String driver = ""; //$NON-NLS-1$ + private String type = ""; //$NON-NLS-1$ + private String driverFile = ""; //$NON-NLS-1$ + + /** + * A quick list is a list of favourite tables that a person might want to view + * without having to look at the entire list of tables. + */ + private Map quickList = new Hashtable(); + private Set schemas = new HashSet(); + private Connection connection = null; + private ConnectionEstablisher connectionEstablisher; + private boolean changed = true; + private List queries = Collections.synchronizedList(new ArrayList()); + private boolean promptForPassword = false; + private boolean autoCommit = true; + private String autoCommitPreference = IQuantumConstants.autoCommitTrue; + + public Bookmark() { + this(MultiSQLServer.getInstance()); + } + + public Bookmark(ConnectionEstablisher connectionEstablisher) { + this.connectionEstablisher = connectionEstablisher; + } + + public Bookmark(Bookmark data) { + this(); + setName(data.getName()); + setUsername(data.getUsername()); + setPassword(data.getPassword()); + setConnect(data.getConnect()); + setDriver(data.getDriver()); + setType(data.getType()); + setDriverFile(data.getDriverFile()); + setPromptForPassword(data.getPromptForPassword()); + setAutoCommit(data.isAutoCommit()); + setAutoCommitPreference(data.getAutoCommitPreference()); + + this.schemas.addAll(data.schemas); + this.quickList = new Hashtable(data.quickList); + } + + /** + * Returns the JDBC URL. + * @return String + */ + public String getConnect() { + return connect; + } + + /** + * Returns the driver. + * @return String + */ + public String getDriver() { + return driver; + } + + /** + * Returns the driverFile. + * @return String + */ + public String getDriverFile() { + return driverFile; + } + + /** + * Returns the password. + * @return String + */ + public String getPassword() { + return password; + } + + /** + * Returns the username. + * @return String + */ + public String getUsername() { + return username; + } + + /** + * Sets the connect. + * @param connect The connect to set + */ + public void setConnect(String connect) { + if (connect == null) { + connect = ""; //$NON-NLS-1$ + } + this.connect = connect; + } + + /** + * Sets the driver. + * @param driver The driver to set + */ + public void setDriver(String driver) { + if (driver == null) { + driver = ""; //$NON-NLS-1$ + } + this.driver = driver; + } + + /** + * Sets the driverFile. + * @param driverFile The driverFile to set + */ + public void setDriverFile(String driverFile) { + if (driverFile == null) { + driverFile = ""; //$NON-NLS-1$ + } + this.driverFile = driverFile; + } + + /** + * Sets the password. + * @param password The password to set + */ + public void setPassword(String password) { + if (password == null) { + password = ""; //$NON-NLS-1$ + } + this.password = password; + } + + /** + * Sets the username. + * @param username The username to set + */ + public void setUsername(String username) { + if (username == null) { + username = ""; //$NON-NLS-1$ + } + this.username = username; + } + + /** + * Returns the name. + * @return String + */ + public String getName() { + return name; + } + + /** + * Sets the name. + * @param name The name to set + */ + public void setName(String name) { + if (name == null) { + name = ""; //$NON-NLS-1$ + } + if (!name.equals(this.name)) { + + String oldName = this.name; + this.name = name; + this.propertyChangeSupport.firePropertyChange("name", oldName, this.name); + this.changed = true; + } + } + + public boolean isEmpty() { + if (name.equals("") && //$NON-NLS-1$ + username.equals("") && //$NON-NLS-1$ + password.equals("") && //$NON-NLS-1$ + connect.equals("") && //$NON-NLS-1$ + driver.equals("") && //$NON-NLS-1$ + type.equals("") && //$NON-NLS-1$ + driverFile.equals("")) { //$NON-NLS-1$ + return true; + } + return false; + } + public String toString() { + StringBuffer buffer = new StringBuffer(); + buffer.append("["); //$NON-NLS-1$ + buffer.append("name="); //$NON-NLS-1$ + buffer.append(name); + buffer.append(", "); //$NON-NLS-1$ + buffer.append("username="); //$NON-NLS-1$ + buffer.append(username); + buffer.append(", "); //$NON-NLS-1$ + buffer.append("password=****"); //$NON-NLS-1$ + buffer.append(", "); //$NON-NLS-1$ + buffer.append("connect="); //$NON-NLS-1$ + buffer.append(connect); + buffer.append(", "); //$NON-NLS-1$ + buffer.append("driver="); //$NON-NLS-1$ + buffer.append(driver); + buffer.append(", "); //$NON-NLS-1$ + buffer.append("type="); //$NON-NLS-1$ + buffer.append(type); + buffer.append(", "); //$NON-NLS-1$ + buffer.append("driverFile="); //$NON-NLS-1$ + buffer.append(driverFile); + buffer.append("]"); //$NON-NLS-1$ + return buffer.toString(); + } + + public String getType() { + return type; + } + + public void setType(String type) { + this.type = type; + } + + public Connection connect(PasswordFinder passwordFinder) throws ConnectionException { + boolean isConnected = isConnected(); + if (this.connection == null) { + this.connection = this.connectionEstablisher.connect(this, passwordFinder); + } + + if (isConnected() != isConnected) { + this.propertyChangeSupport.firePropertyChange( + "connected", isConnected, isConnected()); + } + return this.connection; + } + + /** + * Returns the connection object. + * @return the Connection object associated with the current JDBC source. + * + */ + public Connection getConnection() throws NotConnectedException { + if (this.connection == null) { + throw new NotConnectedException(); + } + return this.connection; + } + + /** + * @return true if the BookmarkNode is connected to a JDBC source + */ + public boolean isConnected() { + return (connection != null); + } + + /** + * Sets the connection member. From that moment on the BookmarkNode is "connected" (open) + * @param connection : a valid connection to a JDBC source + */ + public void setConnection(Connection connection) { + this.connection = connection; + } + + public void disconnect() throws ConnectionException { + boolean isConnected = isConnected(); + try { + if (this.connection != null) { + this.connectionEstablisher.disconnect(this.connection); + } + } finally { + this.connection = null; + if (isConnected() != isConnected) { + this.propertyChangeSupport.firePropertyChange( + "connected", isConnected, isConnected()); + } + } + } + public void addSchema(String schema) { + if (schema != null && schema.trim().length() > 0) { + addSchema(new Schema(schema)); + } + } + + public void addSchema(Schema qualifier) { + if (qualifier != null) { + this.schemas.add(qualifier); + this.changed = true; + this.propertyChangeSupport.firePropertyChange("schemas", null, null); + } + } + + public void setSchemas(Schema[] schemas) { + this.schemas.clear(); + for (int i = 0, length = (schemas == null) ? 0 : schemas.length; + i < length; + i++) { + this.schemas.add(schemas[i]); + + } + this.changed = true; + this.propertyChangeSupport.firePropertyChange("schemas", null, null); + } + + /** + * @return a list of all the schemas that have been set up. + */ + public Schema[] getSchemas() { + Set set = new HashSet(); + set.addAll(this.schemas); + if (set.isEmpty()) { + set.add(new Schema(getAdapter().getDefaultSchema(this.username), + this.username, true)); + } + List list = new ArrayList(set); + Collections.sort(list); + return (Schema[]) list.toArray(new Schema[list.size()]); + } + + /** + * @see java.lang.Object#equals(java.lang.Object) + */ + public boolean equals(Object obj) { + if (!(obj instanceof Bookmark)) return false; + String name = ((Bookmark)obj).getName(); + if (name.equals(this.getName())) return true; + return false; + } + + /** + * @param listener + */ + public synchronized void addPropertyChangeListener(PropertyChangeListener listener) { + this.propertyChangeSupport.addPropertyChangeListener(listener); + } + + /** + * @param listener + */ + public synchronized void removePropertyChangeListener(PropertyChangeListener listener) { + this.propertyChangeSupport.removePropertyChangeListener(listener); + } + + public void addQuickListEntry(String type, String schemaName, String name) { + Entity entity = EntityFactory.getInstance().create(this, schemaName, name, type); + this.quickList.put(entity.getCondQualifiedName(), entity); + this.propertyChangeSupport.firePropertyChange("quickList", null, null); + this.changed = true; + } + + public void addQuickListEntry(Entity entity) { + addQuickListEntry(entity.getType(), entity.getSchema(), entity.getName()); + } + + public void removeQuickListEntry(Entity entity) { + if (entity != null && this.quickList.containsKey(entity.getCondQualifiedName())) { + this.quickList.remove(entity.getCondQualifiedName()); + this.propertyChangeSupport.firePropertyChange("quickList", null, null); + this.changed = true; + } + } + + public Entity[] getQuickListEntries() { + return (Entity[]) this.quickList.values().toArray(new Entity[this.quickList.size()]); + } + + public boolean hasQuickList() { + return !this.quickList.isEmpty(); + } + /** + * @return + */ + public boolean isChanged() { + return changed; + } + + /** + * @param b + */ + public void setChanged(boolean b) { + changed = b; + } + + public Database getDatabase() throws NotConnectedException { + if (!isConnected()) { + throw new NotConnectedException(); + } + return new Database(this); + } + + public DatabaseAdapter getAdapter() { + return AdapterFactory.getInstance().getAdapter(getType()); + } + + public Entity[] getEntitiesForSchema(Schema schema, String type) throws SQLException { + try { + Entity[] entities = getDatabase().getEntities(this, schema, type); + return entities; + } catch (NotConnectedException e) { + return new Entity[0]; + } + } + + public Entity getEntity(Schema schema, String name) throws SQLException { + Entity result = null; + if (schema != null && name != null) { + Entity[] entities = getEntitiesForSchema(schema, null); + for (int i = 0, length = (entities == null) ? 0 : entities.length; + result == null && i < length; + i++) { + if (schema.equals(entities[i].getSchema()) && + name.equals(entities[i].getName())) { + result = entities[i]; + } + } + } + return result; + } + + public boolean isInQuickList(Entity entity) { + return this.quickList.containsKey(entity.getCondQualifiedName()); + } + + /** + * + * @param queryString + */ + public void addQuery(String queryString) { + if (this.queries.contains(queryString)) { + this.queries.remove(queryString); + } + this.queries.add(queryString); + + int size = getQueryHistorySize(); + + while (this.queries.size() > size) { + this.queries.remove(0); + } + this.propertyChangeSupport.firePropertyChange("queries", null, null); + this.changed = true; + } + + public String[] getQueries() { + return (String[]) this.queries.toArray(new String[this.queries.size()]); + } + + private int getQueryHistorySize() { + IPreferenceStore store = + QuantumPlugin.getDefault().getPreferenceStore(); + return store.getInt(getClass().getName() + ".queryHistorySize"); //$NON-NLS-1$ + } + /** + * @return + */ + public boolean getPromptForPassword() { + return promptForPassword; + } + + /** + * @param b + */ + public void setPromptForPassword(boolean b) { + promptForPassword = b; + } + + /** + * @return + */ + public boolean isAutoCommit() { + return autoCommit; + } + + /** + * @return + */ + public String getAutoCommitPreference() { + return autoCommitPreference; + } + + /** + * @param b + */ + public void setAutoCommit(boolean b) { + autoCommit = b; + } + + /** + * @param string + */ + public void setAutoCommitPreference(String string) { + autoCommitPreference = string; + } + + // Returns true or false indicating whether this bookmark must be set to AutoCommit on connection or not + public boolean getDefaultAutoCommit(){ + if (autoCommitPreference.equals(IQuantumConstants.autoCommitTrue)) return true; + else if (autoCommitPreference.equals(IQuantumConstants.autoCommitFalse)) return false; + else if (autoCommitPreference.equals(IQuantumConstants.autoCommitSaved)) return autoCommit; + + return true; + } + +}