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