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 }