archive/net.sourceforge.phpeclipse.quantum.sql/src/com/quantum/adapters/DatabaseAdapter.java

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