public PostgresDictionary() 
{
      
        platform = "PostgreSQL";
        validationSQL = "SELECT NOW()";
        datePrecision = CENTI;
        supportsAlterTableWithDropColumn = false;
        supportsDeferredConstraints = true;
        supportsSelectStartIndex = true;
        supportsSelectEndIndex = true;
        // PostgreSQL requires double-escape for strings
        searchStringEscape = "\\\\";
        maxTableNameLength = 63;
        maxColumnNameLength = 63;
        maxIndexNameLength = 63;
        maxConstraintNameLength = 63;
        maxAutoAssignNameLength = 63;
        schemaCase = SCHEMA_CASE_LOWER;
        rangePosition = RANGE_POST_LOCK;
        requiresAliasForSubselect = true;
        allowsAliasInBulkClause = false;
        // {2} is the result of getGeneratedKeySequenceName; the
        // single-quote escape will result in SELECT CURVAL('mysequence')
        lastGeneratedKeyQuery = "SELECT CURRVAL(''{2}'')";
        supportsAutoAssign = true;
        autoAssignTypeName = "BIGSERIAL";
        nextSequenceQuery = "SELECT NEXTVAL(''{0}'')";
        useGetBytesForBlobs = true;
        useSetBytesForBlobs = true;
        useGetStringForClobs = true;
        useSetStringForClobs = true;
        bitTypeName = "BOOL";
        smallintTypeName = "SMALLINT";
        realTypeName = "FLOAT8";
        tinyintTypeName = "SMALLINT";
        binaryTypeName = "BYTEA";
        blobTypeName = "BYTEA";
        longVarbinaryTypeName = "BYTEA";
        varbinaryTypeName = "BYTEA";
        clobTypeName = "TEXT";
        longVarcharTypeName = "TEXT";
        doubleTypeName = "DOUBLE PRECISION";
        varcharTypeName = "VARCHAR{0}";
        timestampTypeName = "ABSTIME";
        fixedSizeTypeNameSet.addAll(Arrays.asList(new String[]{
            "BOOL", "BYTEA", "NAME", "INT8", "INT2", "INT2VECTOR", "INT4",
            "REGPROC", "TEXT", "OID", "TID", "XID", "CID", "OIDVECTOR",
            "SET", "FLOAT4", "FLOAT8", "ABSTIME", "RELTIME", "TINTERVAL",
            "MONEY",
        }));
        supportsLockingWithDistinctClause = false;
        supportsLockingWithOuterJoin = false;
        supportsNullTableForGetImportedKeys = true;
        reservedWordSet.addAll(Arrays.asList(new String[]{
            "ABORT", "ACL", "AGGREGATE", "APPEND", "ARCHIVE", "ARCH_STORE",
            "BACKWARD", "BINARY", "CHANGE", "CLUSTER", "COPY", "DATABASE",
            "DELIMITER", "DELIMITERS", "DO", "EXPLAIN", "EXTEND",
            "FORWARD", "HEAVY", "INDEX", "INHERITS", "ISNULL", "LIGHT",
            "LISTEN", "LOAD", "MERGE", "NOTHING", "NOTIFY", "NOTNULL",
            "OID", "OIDS", "PURGE", "RECIPE", "RENAME", "REPLACE",
            "RETRIEVE", "RETURNS", "RULE", "SETOF", "STDIN", "STDOUT",
            "STORE", "VACUUM", "VERBOSE", "VERSION",
        }));
}

 protected  void appendSelectRange(SQLBuffer buf,
    long start,
    long end,
    boolean subselect) 
{
        if (end != Long.MAX_VALUE)
            buf.append(" LIMIT ").appendValue(end - start);
        if (start != 0)
            buf.append(" OFFSET ").appendValue(start);
}

 public Connection decorate(Connection conn) throws SQLException 
{
        return new PostgresConnection(super.decorate(conn), this);
}

 public  void deleteStream(JDBCStore store,
    Select sel) throws SQLException 
{
        SQLBuffer sql = sel.toSelect(true, store.getFetchConfiguration());
        ResultSet res = null;
        DelegatingConnection conn = 
            (DelegatingConnection) store.getConnection();
        PreparedStatement stmnt = null;
        try {
            stmnt = sql.prepareStatement(conn, store.getFetchConfiguration(),
                ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE);
            res = stmnt.executeQuery();
            if (!res.next()) {
                throw new InternalException(_loc.get("stream-exception"));
            }
            int oid = res.getInt(1);
            if (oid != -1) {
                conn.setAutoCommit(false);
                PGConnection pgconn = (PGConnection)conn
                    .getInnermostDelegate();
                LargeObjectManager lom = pgconn.getLargeObjectAPI();
                lom.delete(oid);
            }
        } finally {
            if (res != null)
                try { res.close (); } catch (SQLException e) {}
            if (stmnt != null)
                try { stmnt.close (); } catch (SQLException e) {}
            if (conn != null)
                try { conn.close (); } catch (SQLException e) {}
        }
}

 public byte getByte(ResultSet rs,
    int column) throws SQLException 
{
        // postgres does not perform automatic conversions, so attempting to
        // get a whole number out of a decimal will throw an exception.
        // fall back to performing manual conversion if the initial get fails
        try {
            return super.getByte(rs, column);
        } catch (SQLException sqle) {
            return super.getBigDecimal(rs, column).byteValue();
        }
}

 public String[] getCreateSequenceSQL(Sequence seq) 
{
        String[] sql = super.getCreateSequenceSQL(seq);
        if (seq.getAllocate()  > 1)
            sql[0] += " CACHE " + seq.getAllocate();
        return sql;
}

 public Date getDate(ResultSet rs,
    int column) throws SQLException 
{
        try {
            return super.getDate(rs, column);
        } catch (StringIndexOutOfBoundsException sioobe) {
            // there is a bug in some versions of the postgres JDBC
            // driver such that a date with not enough numbers in it
            // will throw a parsing exception: this tries to work
            // around it. The bug only occurs when there is a trailing
            // millisecond missing from the end. E.g., when the date is
            // like:
            // 2066-10-19 22:08:32.83
            // rather than what the driver expects:
            // 2066-10-19 22:08:32.830
            String dateStr = rs.getString(column);
            SimpleDateFormat fmt = new SimpleDateFormat(
                "yyyy-MM-dd hh:mm:ss.SS");
            try {
                return fmt.parse(dateStr);
            } catch (ParseException pe) {
                throw new SQLException(pe.toString());
            }
        }
}

 public int getInt(ResultSet rs,
    int column) throws SQLException 
{
        // postgres does not perform automatic conversions, so attempting to
        // get a whole number out of a decimal will throw an exception.
        // fall back to performing manual conversion if the initial get fails
        try {
            return super.getInt(rs, column);
        } catch (SQLException sqle) {
            return super.getBigDecimal(rs, column).intValue();
        }
}

 public InputStream getLOBStream(JDBCStore store,
    ResultSet rs,
    int column) throws SQLException 
{
        DelegatingConnection conn = (DelegatingConnection)store
            .getConnection();
        conn.setAutoCommit(false);
        LargeObjectManager lom = ((PGConnection)conn.getInnermostDelegate())
        .getLargeObjectAPI();
        if (rs.getInt(column) != -1) {
            LargeObject lo = lom.open(rs.getInt(column));
            return lo.getInputStream();
        } else {
            return null;
        }
}

 public long getLong(ResultSet rs,
    int column) throws SQLException 
{
        // postgres does not perform automatic conversions, so attempting to
        // get a whole number out of a decimal will throw an exception.
        // fall back to performing manual conversion if the initial get fails
        try {
            return super.getLong(rs, column);
        } catch (SQLException sqle) {
            return super.getBigDecimal(rs, column).longValue();
        }
}

 protected String getSequencesSQL(String schemaName,
    String sequenceName) 
{
        if (schemaName == null && sequenceName == null)
            return allSequencesSQL;
        else if (schemaName == null)
            return namedSequencesFromAllSchemasSQL;
        else if (sequenceName == null)
            return allSequencesFromOneSchemaSQL;
        else
            return namedSequenceFromOneSchemaSQL;
}

 public short getShort(ResultSet rs,
    int column) throws SQLException 
{
        // postgres does not perform automatic conversions, so attempting to
        // get a whole number out of a decimal will throw an exception.
        // fall back to performing manual conversion if the initial get fails
        try {
            return super.getShort(rs, column);
        } catch (SQLException sqle) {
            return super.getBigDecimal(rs, column).shortValue();
        }
}

 public  void indexOf(SQLBuffer buf,
    FilterValue str,
    FilterValue find,
    FilterValue start) 
{
        buf.append("(POSITION(");
        find.appendTo(buf);
        buf.append(" IN ");
        if (start != null)
            substring(buf, str, start, null);
        else
            str.appendTo(buf);
        buf.append(") - 1");
        if (start != null) {
            buf.append(" + ");
            start.appendTo(buf);
        }
        buf.append(")");
}

 public  void insertBlobForStreamingLoad(Row row,
    Column col,
    JDBCStore store,
    Object ob,
    Select sel) throws SQLException 
{
        if (row.getAction() == Row.ACTION_INSERT) {
            insertPostgresBlob(row, col, store, ob);
        } else if (row.getAction() == Row.ACTION_UPDATE) {
            updatePostgresBlob(row, col, store, ob, sel);
        }
}

 public boolean isSystemIndex(String name,
    Table table) 
{
        // names starting with "pg_" are reserved for Postgresql internal use
        return super.isSystemIndex(name, table)
            || (name != null && name.toLowerCase().startsWith("pg_"));
}

 public boolean isSystemSequence(String name,
    String schema,
    boolean targetSchema) 
{
        if (super.isSystemSequence(name, schema, targetSchema))
            return true;
        // filter out generated sequences used for bigserial cols, which are
        // of the form < table >_< col >_seq
        int idx = name.indexOf('_");
        return idx != -1 && idx != name.length() - 4
            && name.toUpperCase().endsWith("_SEQ");
}

 public boolean isSystemTable(String name,
    String schema,
    boolean targetSchema) 
{
        // names starting with "pg_" are reserved for Postgresql internal use
        return super.isSystemTable(name, schema, targetSchema)
            || (name != null && name.toLowerCase().startsWith("pg_"));
}

 public  void setBoolean(PreparedStatement stmnt,
    int idx,
    boolean val,
    Column col) throws SQLException 
{
        // postgres actually requires that a boolean be set: it cannot
        // handle a numeric argument.
        stmnt.setBoolean(idx, val);
}

 public  void setNull(PreparedStatement stmnt,
    int idx,
    int colType,
    Column col) throws SQLException 
{
        // OPENJPA-
        if (colType == Types.BLOB)
            colType = Types.BINARY;
        stmnt.setNull(idx, colType);
}

 protected boolean supportsDeferredUniqueConstraints() 
{
        // Postgres only supports deferred foreign key constraints.
        return false;
}

 public  void updateBlob(Select sel,
    JDBCStore store,
    InputStream is) throws SQLException 
{
        //Do nothing
}