/*

  * $Source$

  * $Revision$

  *

  * Copyright (C) 2000 David Warnock

  * 

  * Part of Melati (http://melati.org), a framework for the rapid

  * development of clean, maintainable web applications.

  *

  * Melati is free software; Permission is granted to copy, distribute

  * and/or modify this software under the terms either:

  *

  * a) the GNU General Public License as published by the Free Software

  *    Foundation; either version 2 of the License, or (at your option)

  *    any later version,

  *

  *    or

  *

  * b) any version of the Melati Software License, as published

  *    at http://melati.org

  *

  * You should have received a copy of the GNU General Public License and

  * the Melati Software License along with this program;

  * if not, write to the Free Software Foundation, Inc.,

  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA to obtain the

  * GNU General Public License and visit http://melati.org to obtain the

  * Melati Software License.

  *

  * Feel free to contact the Developers of Melati (http://melati.org),

  * if you would like to work out a different arrangement than the options

  * outlined here.  It is our intention to allow Melati to be used by as

  * wide an audience as possible.

  *

  * This program is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  * GNU General Public License for more details.

  *

  * Contact details for copyright holder:

  *

  *     David Warnock (david At sundayta.co.uk)

  *     Sundayta Ltd

  *     International House, 

  *     174 Three Bridges Road, 

  *     Crawley, West Sussex 

  *     RH10 1LE, UK

  *

  */

 package org.melati.poem.dbms;

 import java.sql.DatabaseMetaData;

 import java.sql.ResultSet;

 import java.sql.SQLException;

 import org.melati.poem.Table;

 import org.melati.poem.PoemType;

 import org.melati.poem.SQLPoemType;

 import org.melati.poem.BinaryPoemType;

 import org.melati.poem.DoublePoemType;

 import org.melati.poem.IntegerPoemType;

 import org.melati.poem.LongPoemType;

 import org.melati.poem.NoSuchColumnPoemException;

 import org.melati.poem.SeriousPoemException;

 import org.melati.poem.SQLPoemException;

  /**

   * A Driver for Postgresql.

   * See http://www.postgresql.org/

   * 

   * <b>Backwards compatabilty</b>

   * Previous (7.4) versions allowed single quotes to be quoted using C style escaping.

   * In version 9.1 you need to explicitly allow this escaping by configuring the server:

   * <code>

   * backslash_quote = on

   * standard_conforming_strings = off

   * </code>

   **/

 public class Postgresql extends AnsiStandard {

   /**

    * Constructor.

    */

   public Postgresql() {

     setDriverClassName("org.postgresql.Driver");

   }

   /**

    * Whether this DBMS can drop columns. 

    * 

    * Postgresql has been able to since 7.4

    * 

    * @return true if we can

    */

   @Override

   public boolean canDropColumns() {

     return true;

   }

   /**

    * Accommodate casting in placeholders.

    *  

    * @param type the type to cast

    * @return the place holder string

    */

   @Override

   public String preparedStatementPlaceholder(PoemType<?> type) {

     if (type instanceof IntegerPoemType)

       return "CAST(? AS INT4)";

     else if (type instanceof LongPoemType)

       return "CAST(? AS INT8)";

     else if (type instanceof DoublePoemType)

       return "CAST(? AS FLOAT8)";

     else 

       return "?";

   }

   /**

    * Accommodate String/Text distinction. 

    * 

    * @param size the string length (-1 means no limit)

    * @return the SQL definition for a string of this size 

    * @throws SQLException

    * @see org.melati.poem.dbms.AnsiStandard#getStringSqlDefinition(int)

    */

   @Override

   public String getStringSqlDefinition(int size) throws SQLException {

     if (size < 0) { 

        return "TEXT";

     }

        return super.getStringSqlDefinition(size);

   }

   @Override

   public String getBinarySqlDefinition(int size) throws SQLException {

     return "BYTEA";

   }

 /*

   public String getBinarySqlDefinition(int size) {

    // BLOBs in Postgres are represented as OIDs pointing to the data

     return "OID";

   }

 */

   /**

    * An Object Id <code>PoemType</code>.

    */

 /*

   public static class OidPoemType extends IntegerPoemType {

       public OidPoemType(boolean nullable) {

           super(Types.INTEGER, "OID", nullable);

       }

       protected boolean _canRepresent(SQLPoemType other) {

           return other instanceof BinaryPoemType;

       }

       public PoemType canRepresent(PoemType other) {

           return other instanceof BinaryPoemType &&

                  !(!getNullable() && 

        ((BinaryPoemType)other).getNullable()) ? other : null;

       }

   }

 */

   @Override

   public SQLPoemType<?> defaultPoemTypeOfColumnMetaData(ResultSet md)

       throws SQLException {

     return

     md.getString("TYPE_NAME").equals("bytea") ?

             new BinaryPoemType(md.getInt("NULLABLE") ==

                                 DatabaseMetaData.columnNullable, -1) :

             super.defaultPoemTypeOfColumnMetaData(md);

 //    md.getString("TYPE_NAME").equals("oid") ?

 //            new OidPoemType(md.getInt("NULLABLE") ==

 //                                DatabaseMetaData.columnNullable) :

 //           super.defaultPoemTypeOfColumnMetaData(md);

   }

   @Override

   public SQLPoemException exceptionForUpdate(

       Table<?> table, String sql, boolean insert, SQLException e) {

     String m = e.getMessage();

       // Postgres's duplicate key message is:

       // "Cannot insert a duplicate key into unique index user_login_index"

     if (m != null &&

         m.indexOf("duplicate key") >= 0) {

       // We call POEM's own indexes <table>_<column>_index:

       // see Table.dbCreateIndex

       int s, u;

       if (m.endsWith("_index\n") &&

          (s = m.lastIndexOf(' ')) >= 0 && (u = m.indexOf('_', s+1)) >= 0) {

         String colname = m.substring(u+1, m.length() - 7);

         try {

           return new DuplicateKeySQLPoemException(table.getColumn(colname),

                                                   sql, insert, e);

         }

         catch (NoSuchColumnPoemException f) {

           throw new SeriousPoemException(

                "Duplicate Key exception thrown on a non-existant column",f);

         }

       }

       return new DuplicateKeySQLPoemException(table, sql, insert, e);

     }

       else

         return super.exceptionForUpdate(table, sql, insert, e);

   }

 }