8973ffd4404b831b4f42c3f7dc8319178893582e
[phpeclipse.git] / archive / net.sourceforge.phpeclipse.quantum.sql / src / com / quantum / model / EntityImpl.java
1         package com.quantum.model;
2
3 import java.sql.Connection;
4 import java.sql.DatabaseMetaData;
5 import java.sql.ResultSet;
6 import java.sql.SQLException;
7 import java.sql.Statement;
8 import java.util.ArrayList;
9 import java.util.Collections;
10 import java.util.HashMap;
11 import java.util.List;
12 import java.util.Map;
13
14 import com.quantum.adapters.DatabaseAdapter;
15
16 /**
17  * This class models a table or view.
18  * 
19  * @author bcholmes
20  */
21 abstract class EntityImpl implements Entity {
22     private String schema;
23     private String name;
24     private String type;
25     private Bookmark bookmark;
26     private Boolean exists = Boolean.TRUE;
27     
28     public EntityImpl(Bookmark bookmark, String schema, String name, String type) {
29         this.schema = schema;
30         this.name = name;
31         this.type = type;
32         this.bookmark = bookmark;
33     }
34     public Bookmark getBookmark() {
35         return this.bookmark;
36     }
37     public String getName() {
38         return this.name;
39     }
40     public String getSchema() {
41         return this.schema;
42     }
43     public String getType() {
44         return this.type;
45     }
46     public String getQualifiedName() {
47         return (this.schema == null || this.schema.length() == 0) ?
48             this.name : this.schema + "." + this.name;
49     }
50     public Column getColumn(String columnName) throws NotConnectedException, SQLException  {
51         Column column = null;
52         Column[] columns = getColumns();
53         for (int i = 0, length = (columns == null) ? 0 : columns.length;
54             column == null && i < length;
55             i++) {
56             if (columnName != null && columnName.equals(columns[i].getName())) {
57                 column = columns[i];
58             }
59         }
60         return column;
61     }
62     public Column[] getColumns() throws NotConnectedException, SQLException {
63         
64         Map temp = new HashMap();
65         Connection connection = this.bookmark.getConnection();
66         DatabaseMetaData metaData = connection.getMetaData();
67         ResultSet resultSet = metaData.getColumns(null, getSchema(), getName(), null);
68         try {
69                 while (resultSet.next()) {
70                     ColumnImpl column = new ColumnImpl(
71                         this, 
72                         resultSet.getString("COLUMN_NAME"),
73                         resultSet.getString("TYPE_NAME"),
74                         resultSet.getInt("DATA_TYPE"),
75                         resultSet.getInt("COLUMN_SIZE"),
76                         resultSet.getInt("DECIMAL_DIGITS"),
77                         "YES".equalsIgnoreCase(resultSet.getString("IS_NULLABLE")),
78                         resultSet.getInt("ORDINAL_POSITION"),
79                                         getComments(resultSet.getString("REMARKS"),getQualifiedName(), resultSet.getString("COLUMN_NAME"))
80                         );
81                     temp.put(column.getName(), column);
82                 }
83         } finally {
84                 resultSet.close();
85         }
86
87         resultSet = metaData.getPrimaryKeys(null, getSchema(), getName());
88         try {
89                 while (resultSet.next()) {
90                     String name = resultSet.getString("COLUMN_NAME");
91                     short keySequence = resultSet.getShort("KEY_SEQ");
92                     ColumnImpl column = (ColumnImpl) temp.get(name);
93                     if (column != null) {
94                         column.setPrimaryKeyOrder(keySequence);
95                     }
96                 }
97                 resultSet.close();
98                 
99                 List columnList = Collections.synchronizedList(
100                     new ArrayList(temp.values()));
101                 Collections.sort(columnList);
102                 return (Column[]) columnList.toArray(new Column[columnList.size()]);
103         } finally {
104                 resultSet.close();
105         }
106     }
107     
108     /**
109      * Some JDBC drivers (Oracle for example) won't return the comments
110      * We recheck with a custom query, if it's defined
111          * @param iniComment The already got comment
112          * @param tableName The fully qualified table name
113          * @param columnName The column name
114          */
115         private String getComments( String iniComment, String tableName, String columnName) {
116                 if (iniComment != null && iniComment.length() > 0) 
117                         return iniComment;
118                 String comment = "";
119                 try {
120                         Connection con = this.bookmark.getConnection();
121                         Statement stmt = con.createStatement();
122                         DatabaseAdapter adapter = this.bookmark.getAdapter();
123                         if (adapter != null && stmt != null && adapter.getCommentsQuery(tableName, columnName) != null) {
124                         
125                                 stmt.execute(adapter.getCommentsQuery(tableName, columnName));
126                                 ResultSet set = stmt.getResultSet();
127                                 if (set.next())
128                                         comment = set.getString(1);
129                         }
130                 } catch (NotConnectedException e) {
131                 } catch (SQLException e) {
132                 }
133             
134                 return comment;
135         }
136         public Index[] getIndexes() {
137         
138         List indexList = new ArrayList();
139         Map temp = new HashMap();
140         try {
141             Connection connection = this.bookmark.getConnection();
142             DatabaseMetaData metaData = connection.getMetaData();
143             ResultSet resultSet = metaData.getIndexInfo(null, getSchema(), getName(), false, false);
144             
145             while (resultSet.next()) {
146                 String indexName = resultSet.getString("INDEX_NAME");
147                 IndexImpl index = (IndexImpl) temp.get(indexName);
148                 if (index == null) {
149                     index = new IndexImpl(this, indexName);
150                     temp.put(indexName, index);
151                 }
152                 String columnName = resultSet.getString("COLUMN_NAME");
153                 String ascending = resultSet.getString("ASC_OR_DESC");
154                 index.addColumn(columnName, ascending == null 
155                     ? null : (ascending.toUpperCase().startsWith("A") 
156                         ? Boolean.TRUE : Boolean.FALSE));
157             }
158             resultSet.close();
159             indexList.addAll(temp.values());
160             
161         } catch (NotConnectedException e) {
162         } catch (SQLException e) {
163         }
164         return (Index[]) indexList.toArray(new Index[indexList.size()]);
165     }
166     
167     public Boolean exists() {
168         return this.exists;
169     }
170     
171     
172     /**
173      * @see com.quantum.model.Entity#getQuotedTableName()
174      */
175     public String getQuotedTableName() {
176         return getBookmark().getAdapter().filterTableName(getQualifiedName());
177     }
178
179     public ForeignKey[] getExportedKeys() throws SQLException, NotConnectedException {
180         return this.bookmark.getDatabase().getExportedKeys(getSchema(), getName());
181     }
182
183     public ForeignKey[] getImportedKeys() throws SQLException, NotConnectedException {
184         return this.bookmark.getDatabase().getImportedKeys(getSchema(), getName());
185     }
186     public ForeignKey[] getReferences() throws SQLException, NotConnectedException {
187         ForeignKey[] importedKeys = getImportedKeys();
188         ForeignKey[] exportedKeys = getExportedKeys();
189         
190         List list = new ArrayList(); // if we could guarantee JDK 1.4, we'd use LinkedHashSet 
191         for (int i = 0, length = importedKeys == null ? 0 : importedKeys.length; i < length; i++) {
192                         list.add(importedKeys[i]);
193                 }
194         for (int i = 0, length = exportedKeys == null ? 0 : exportedKeys.length; i < length; i++) {
195                 if (!list.contains(exportedKeys[i])) {
196                         list.add(exportedKeys[i]);
197                 }
198                 }
199         return (ForeignKey[]) list.toArray(new ForeignKey[list.size()]);
200     }
201     
202     public int compareTo(Object object) {
203                 Entity that = (Entity) object;
204                 if (that.getQualifiedName() == null && this.getQualifiedName() != null) {
205                         return 1;
206                 } else if (this.getQualifiedName() == null && that.getQualifiedName() != null) {
207                         return -1;
208                 } else if (this.getQualifiedName() == null && that.getQualifiedName() == null) {
209                         return 0;
210                 } else {
211                         return this.getQualifiedName().compareTo(that.getQualifiedName());
212                 }
213         }
214 }