added file extension php5
[phpeclipse.git] / archive / net.sourceforge.phpeclipse.quantum.sql / src / com / quantum / adapters / DatabaseAdapter.java
1 package com.quantum.adapters;
2
3 import com.quantum.Messages;
4 import com.quantum.sql.SQLHelper;
5 import com.quantum.util.StringUtil;
6
7 /**
8  * Abstract base class for all the adapter classes. Most functions can be redefined in
9  * the adapters for the different databases. If the functions is not redefined, the base
10  * implementation (usually a direct call to the JDBC driver) is used.
11  * 
12  * @author root
13  */
14 public abstract class DatabaseAdapter {
15     
16         private final String type;
17         
18         protected DatabaseAdapter(String type) {
19                 this.type = type;
20         }
21         
22         public String getDisplayName() {
23                 return Messages.getString(DatabaseAdapter.class, getType());
24         }
25         
26         /**
27          * Returns the SQL Query to get a list of the tables for the current user (schema) 
28          * @param info
29          * @return - A String with the SQL query 
30          */
31         public String getShowTableQuery(String schema) {
32                 return null;
33         }
34         /**
35          * Returns the SQL Query to get a list of the queries for the current user (schema) 
36          * @param info
37          * @return - A String with the SQL query
38          */
39         public String getShowViewQuery(String schema) {
40                 return null;
41         }
42         /**
43          * Returns the SQL Query to get a list of the sequences for the current user (schema) 
44          * @param info
45          * @return - A String with the SQL query
46          */
47         public String getShowSequenceQuery(String schema) {
48         return null;
49         }
50
51         /** Returns the SQL Query to access all the columns of a table (SELECT)
52          * @param info
53          * @param table
54          * @return - A String with the SQL query
55          */
56         public String getTableQuery( String table) {
57                         return "SELECT * FROM " + filterTableName(table); //$NON-NLS-1$
58         }
59     
60         /**
61          * Gets the SQL query to get the next value of a sequence, (incrementing it).
62          * @param sequence - The name of the sequence
63          * @param owner - The owner (schema) of it
64          * @return - A string with the SQL query
65          */
66         public String getNextValue(String sequence, String owner) {
67         return null;
68         }
69         /**
70          * Gets the SQL query to get the actual value (previously used) of a sequence, (the sequence is not altered).
71          * @param sequence - The name of the sequence
72          * @param owner - The owner (schema) of it
73          * @return - A string with the SQL query
74          */
75         public String getPrevValue(String sequence, String owner) {
76                 return null;
77         }
78         /**
79          * Returns a query to get the comments on the columns of a table. 
80          * Should return a query to generate a recordset with one row where
81          * the first and only column is the comment
82          * @param tableName - The full name of the table qualified with schema if applicable
83          * @param columnName - The name of the column
84          */
85         public String getCommentsQuery(String tableName, String columnName) {
86                 return null;
87         }
88
89         /**
90          * @param table
91          * @return : A query to get an empty ResultSet (null if failed) for that table or view.
92          * Subclassed if needed by the different database adapters
93          */
94         public String getEmptySetQuery(String table){
95                 return "SELECT * FROM " + filterTableName(table) + " WHERE (1 = 0)"; //$NON-NLS-1$ //$NON-NLS-2$
96         }
97     
98         /**
99          * Quotes a string according to the type of the column 
100          * @param string to be quoted
101          * @param type according to java.sql.Types
102          * @return
103          */
104         public String quote(String string, int type, String typeString) {
105                 if (isTextType(type, typeString)) {
106                         return "'" + StringUtil.substituteString(string, "'", "''") + "'";
107                 } else if (type == java.sql.Types.DATE || type == java.sql.Types.TIMESTAMP){            
108                         string = string.trim();
109                         //Check if we have to strip the millisecods
110                         String sub = string.substring(string.length() - 2, string.length() - 1);
111                         if (string.length() > 1 && sub.equals(".")) //$NON-NLS-1$
112                                 string = string.substring(0, string.length() - 2); // strip the milliseconds
113                                 
114                         return "'" + string + "'"; //$NON-NLS-1$ //$NON-NLS-2$
115
116                 }
117                 return string;
118         }
119     
120     /**
121      * Indicates whether or not a particular type should be quoted in 
122      * SQL statements.  Some databases support non-standard types such as
123      * TEXT that aren't normally recognized as quoted types.
124      * 
125      * @param type according to java.sql.Types
126      * @param typeString if the type is "Other".
127      * @return
128      */
129     protected boolean isTextType(int type, String typeString) {
130         return SQLHelper.isText(type);
131     }
132     
133     
134         /**
135          * Makes an SQL insert string with the given table, names of columns and values
136          * @param string
137          * @param namesClause
138          * @param valuesClause
139          * @return
140          */
141         public String getInsert(String tableName, String namesClause, String valuesClause) {
142                 String query = "INSERT INTO " + filterTableName(tableName);
143                 if (namesClause != "") {
144                                         query += " (" + namesClause + ")";
145                                         query += " VALUES " + "(" + valuesClause; //$NON-NLS-1$
146                                         query += " )"; //$NON-NLS-1$
147                                 }
148                 return query;
149         }
150         /**
151          * Changes the name of the table, usually to allow for lowercase situations.
152          * The parent implementation does nothing to the tableName, simply returns it.
153          * @param tableName
154          * @return
155          */
156         public String filterTableName(String tableName) {
157                 return tableName;
158         }
159         /**
160          * Returns a query to get the number of registers from a table
161          * @param tableName
162          * @return
163          */
164         public String getCountQuery(String tableName) {
165                 return "SELECT COUNT(*) FROM " + filterTableName(tableName);    
166         }
167         /**
168          * @param string
169          * @param string2
170          * @param whereClause
171          * @param string3
172          */
173         public void getUpdate(String tableName, String string2, StringBuffer whereClause, String string3) {
174                 // TODO Auto-generated method stub
175                 
176         }
177         /**
178          * Returns an SQL UPDATE statement
179          * @param string
180          * @param string2
181          * @param string3
182          */
183         public String getUpdate(String tableName, String setClause, String whereClause) {
184                 String query = "UPDATE " + filterTableName(tableName); //$NON-NLS-1$
185                 query += " SET " + setClause; //$NON-NLS-1$
186                 if (!whereClause.equals("")) query += " WHERE " + whereClause; //$NON-NLS-1$
187                 return query;
188         }
189         /**
190          * Returns an SQL DELETE statement
191          * @param string
192          * @param string2
193          * @return
194          */
195         public String getDelete(String tableName, String whereClause) {
196                 String query = "DELETE FROM " + filterTableName(tableName); //$NON-NLS-1$
197                 if (!whereClause.equals("")) {
198                         query += " WHERE " + whereClause; //$NON-NLS-1$
199                 }
200                 return query;
201         }
202     /**
203      * @param userid - the userid used to connect to the database
204      * @return the default schema for the database
205      */
206     public String getDefaultSchema(String userid) {
207         return userid;
208     }
209         /**
210          * @return Returns the type.
211          */
212         public String getType() {
213                 return this.type;
214         }
215 }