<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE jbosscmp-jdbc PUBLIC
   "-//JBoss//DTD JBOSSCMP-JDBC 4.0//EN"
   "http://www.jboss.org/j2ee/dtd/jbosscmp-jdbc_4_0.dtd">

<!-- ===================================================================== -->
<!--                                                                       -->
<!--  Standard JBossCMP-JDBC Configuration                                 -->
<!--                                                                       -->
<!-- ===================================================================== -->

<!-- $Id: standardjbosscmp-jdbc.xml 87078 2009-04-09 14:23:47Z bstansberry@jboss.com $ -->

<jbosscmp-jdbc>

   <defaults>
      <datasource>java:/DefaultDS</datasource>
      <!-- optional since 4.0 <datasource-mapping>Hypersonic SQL</datasource-mapping> -->

      <create-table>true</create-table>
      <remove-table>false</remove-table>
      <read-only>false</read-only>
      <read-time-out>300000</read-time-out>
      <row-locking>false</row-locking>
      <pk-constraint>true</pk-constraint>
      <fk-constraint>false</fk-constraint>
      <preferred-relation-mapping>foreign-key</preferred-relation-mapping>
      <read-ahead>
         <strategy>on-load</strategy>
         <page-size>1000</page-size>
         <eager-load-group>*</eager-load-group>
      </read-ahead>
      <list-cache-max>1000</list-cache-max>
      <clean-read-ahead-on-load>false</clean-read-ahead-on-load>

      <unknown-pk>
         <key-generator-factory>UUIDKeyGeneratorFactory</key-generator-factory>
         <unknown-pk-class>java.lang.String</unknown-pk-class>
         <jdbc-type>VARCHAR</jdbc-type>
         <sql-type>VARCHAR(32)</sql-type>
      </unknown-pk>

      <entity-command name="default"/>
      <ql-compiler>org.jboss.ejb.plugins.cmp.jdbc.JDBCEJBQLCompiler</ql-compiler>
      <throw-runtime-exceptions>false</throw-runtime-exceptions>
   </defaults>

   <type-mappings>
      <type-mapping>
         <name>FirstSQL/J</name>
         <row-locking-template/>
         <pk-constraint-template>PRIMARY KEY (?2)</pk-constraint-template>
         <fk-constraint-template>FOREIGN KEY (?3) REFERENCES ?4 (?5)</fk-constraint-template>
         <alias-header-prefix>t</alias-header-prefix>
         <alias-header-suffix>_</alias-header-suffix>
         <alias-max-length>32</alias-max-length>
         <subquery-supported>true</subquery-supported>
         <true-mapping>1</true-mapping>
         <false-mapping>0</false-mapping>

         <function-mapping>
            <function-name>concat</function-name>
            <function-sql>(?1 || ?2)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>substring</function-name>
            <function-sql>substring(?1 FROM ?2 FOR ?3)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>lcase</function-name>
            <function-sql>lower(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>length</function-name>
            <function-sql>char_length(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>locate</function-name>
            <function-sql>position(?1 IN ?2)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>abs</function-name>
            <function-sql>math.abs(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>sqrt</function-name>
            <function-sql>math.sqrt(CAST(?1 AS DOUBLE))</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>ucase</function-name>
            <function-sql>upper(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>count</function-name>
            <function-sql>count(?1)</function-sql>
         </function-mapping>

         <mapping>
            <java-type>java.lang.Boolean</java-type>
            <jdbc-type>TINYINT</jdbc-type>
            <sql-type>TINYINT</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Byte</java-type>
            <jdbc-type>TINYINT</jdbc-type>
            <sql-type>TINYINT</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Short</java-type>
            <jdbc-type>SMALLINT</jdbc-type>
            <sql-type>SMALLINT</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Integer</java-type>
            <jdbc-type>INTEGER</jdbc-type>
            <sql-type>INTEGER</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Long</java-type>
            <jdbc-type>BIGINT</jdbc-type>
            <sql-type>BIGINT</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Float</java-type>
            <jdbc-type>REAL</jdbc-type>
            <sql-type>REAL</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Double</java-type>
            <jdbc-type>DOUBLE</jdbc-type>
            <sql-type>DOUBLE</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Character</java-type>
            <jdbc-type>CHAR</jdbc-type>
            <sql-type>CHAR</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.String</java-type>
            <jdbc-type>VARCHAR</jdbc-type>
            <!-- or <sql-type>VARCHAR(2147483500)</sql-type> -->
            <sql-type>VARCHAR(256)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Date</java-type>
            <jdbc-type>DATE</jdbc-type>
            <sql-type>DATE</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Time</java-type>
            <jdbc-type>TIME</jdbc-type>
            <sql-type>TIME</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Timestamp</java-type>
            <jdbc-type>TIMESTAMP</jdbc-type>
            <sql-type>TIMESTAMP</sql-type>
         </mapping>
         <mapping>
            <java-type>java.util.Date</java-type>
            <jdbc-type>TIMESTAMP</jdbc-type>
            <sql-type>TIMESTAMP</sql-type>
         </mapping>
         <mapping>
            <java-type>java.math.BigDecimal</java-type>
            <jdbc-type>DECIMAL</jdbc-type>
            <sql-type>DECIMAL</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Object</java-type>
            <!-- FirstSQL/J only supports directly serializable objects for classes declared with CREATE CLASS -->
            <jdbc-type>LONGVARBINARY</jdbc-type>
            <sql-type>VARCHAR(2147483500)</sql-type>
         </mapping>
      </type-mapping>

      <type-mapping>
         <name>Ingres</name>
         <row-locking-template>SELECT ?1 FROM ?2 WHERE ?3 ORDER BY ?4 FOR UPDATE</row-locking-template>
         <pk-constraint-template>ALTER TABLE ?1 ADD CONSTRAINT ?2 PRIMARY KEY (?3)</pk-constraint-template>
         <fk-constraint-template>ALTER TABLE ?1 ADD CONSTRAINT ?2 FOREIGN KEY (?3) REFERENCES ?4 (?5)</fk-constraint-template>
         <alias-header-prefix>t</alias-header-prefix>
         <alias-header-suffix>_</alias-header-suffix>
         <alias-max-length>32</alias-max-length>
         <subquery-supported>true</subquery-supported>
         <true-mapping>TRUE</true-mapping>
         <false-mapping>FALSE</false-mapping>

         <function-mapping>
            <function-name>concat</function-name>
            <function-sql>concat(?1,?2)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>substring</function-name>
            <function-sql>left(?1,?2)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>lcase</function-name>
            <function-sql>lower(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>length</function-name>
            <function-sql>length(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>locate</function-name>
            <function-sql>locate(?1,?2)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>abs</function-name>
            <function-sql>abs(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>sqrt</function-name>
            <function-sql>sqrt(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>ucase</function-name>
            <function-sql>upper(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>count</function-name>
            <function-sql>count(?1)</function-sql>
         </function-mapping>

         <!-- change from bit to integer , 10.12.2002 heb -->
         <mapping>
            <java-type>java.lang.Boolean</java-type>
            <jdbc-type>INTEGER</jdbc-type>
            <sql-type>INTEGER</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Byte</java-type>
            <jdbc-type>TINYINT</jdbc-type>
            <sql-type>INT1</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Short</java-type>
            <jdbc-type>SMALLINT</jdbc-type>
            <sql-type>SMALLINT</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Integer</java-type>
            <jdbc-type>INTEGER</jdbc-type>
            <sql-type>INTEGER</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Long</java-type>
            <jdbc-type>BIGINT</jdbc-type>
            <sql-type>INTEGER4</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Float</java-type>
            <jdbc-type>FLOAT</jdbc-type>
            <sql-type>FLOAT4</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Double</java-type>
            <jdbc-type>DOUBLE</jdbc-type>
            <sql-type>FLOAT8</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Character</java-type>
            <jdbc-type>CHAR</jdbc-type>
            <sql-type>CHAR</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.String</java-type>
            <jdbc-type>VARCHAR</jdbc-type>
            <sql-type>VARCHAR(256)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.util.Date</java-type>
            <jdbc-type>TIMESTAMP</jdbc-type>
            <sql-type>DATE</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Date</java-type>
            <jdbc-type>DATE</jdbc-type>
            <sql-type>DATE</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Time</java-type>
            <jdbc-type>TIME</jdbc-type>
            <sql-type>DATE</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Timestamp</java-type>
            <jdbc-type>TIMESTAMP</jdbc-type>
            <sql-type>DATE</sql-type>
         </mapping>
         <mapping>
            <java-type>java.math.BigDecimal</java-type>
            <jdbc-type>DOUBLE</jdbc-type>
            <sql-type>FLOAT8</sql-type>
         </mapping>
<!--
Mapping proposed by Computer Associates, but does not work with JBoss properly
28.03.2003 hou
         <mapping>
            <java-type>java.math.BigDecimal</java-type>
            <jdbc-type>NUMERIC</jdbc-type>
            <sql-type>DECIMAL(24,6)</sql-type>
         </mapping>
-->
         <mapping>
            <java-type>java.lang.Object</java-type>
            <jdbc-type>JAVA_OBJECT</jdbc-type>
            <sql-type>LONG VARCHAR</sql-type>
         </mapping>
      </type-mapping>
     <type-mapping>
      <name>McKoi</name>
      <row-locking-template>SELECT ?1 FROM ?2 WHERE ?3 ORDER BY ?4 FOR UPDATE</row-locking-template>
      <pk-constraint-template>CONSTRAINT ?1 PRIMARY KEY (?2)</pk-constraint-template>
      <fk-constraint-template>ALTER TABLE ?1 ADD CONSTRAINT ?2 FOREIGN KEY (?3) REFERENCES ?4 (?5)</fk-constraint-template>
      <alias-header-prefix>t</alias-header-prefix>
      <alias-header-suffix>_</alias-header-suffix>
      <alias-max-length>32</alias-max-length>
      <subquery-supported>true</subquery-supported>
      <true-mapping>TRUE</true-mapping>
      <false-mapping>FALSE</false-mapping>

         <function-mapping>
            <function-name>count</function-name>
            <function-sql>count(?1)</function-sql>
         </function-mapping>

      <mapping>
         <java-type>java.lang.Boolean</java-type>
         <jdbc-type>BIT</jdbc-type>
         <sql-type>BOOLEAN</sql-type>
      </mapping>
      <mapping>
         <java-type>java.lang.Byte</java-type>
         <jdbc-type>TINYINT</jdbc-type>
         <sql-type>SMALLINT</sql-type>
      </mapping>
      <mapping>
         <java-type>java.lang.Short</java-type>
         <jdbc-type>SMALLINT</jdbc-type>
         <sql-type>SMALLINT</sql-type>
      </mapping>
      <mapping>
         <java-type>java.lang.Integer</java-type>
         <jdbc-type>INTEGER</jdbc-type>
         <sql-type>INTEGER</sql-type>
      </mapping>
      <mapping>
         <java-type>java.lang.Long</java-type>
         <jdbc-type>BIGINT</jdbc-type>
         <sql-type>BIGINT</sql-type>
      </mapping>
      <mapping>
         <java-type>java.lang.Float</java-type>
         <jdbc-type>REAL</jdbc-type>
         <sql-type>FLOAT</sql-type>
      </mapping>
      <mapping>
         <java-type>java.lang.Double</java-type>
         <jdbc-type>DOUBLE</jdbc-type>
         <sql-type>DOUBLE</sql-type>
      </mapping>
      <mapping>
         <java-type>java.lang.Character</java-type>
         <jdbc-type>CHAR</jdbc-type>
         <sql-type>CHAR</sql-type>
      </mapping>
      <mapping>
         <java-type>java.lang.String</java-type>
         <jdbc-type>VARCHAR</jdbc-type>
         <sql-type>VARCHAR(64)</sql-type>
      </mapping>
      <mapping>
         <java-type>java.sql.Date</java-type>
         <jdbc-type>DATE</jdbc-type>
         <sql-type>DATE</sql-type>
      </mapping>
      <mapping>
         <java-type>java.sql.Time</java-type>
         <jdbc-type>TIME</jdbc-type>
         <sql-type>TIME</sql-type>
      </mapping>
      <mapping>
         <java-type>java.sql.Timestamp</java-type>
         <jdbc-type>TIMESTAMP</jdbc-type>
         <sql-type>TIMESTAMP</sql-type>
      </mapping>
      <mapping>
         <java-type>java.lang.Object</java-type>
         <jdbc-type>JAVA_OBJECT</jdbc-type>
         <sql-type>JAVA_OBJECT</sql-type>
      </mapping>
     </type-mapping>

      <type-mapping>
         <name>Firebird</name>
         <row-locking-template>SELECT ?1 FROM ?2 WHERE ?3 ORDER BY ?4 FOR UPDATE</row-locking-template>
         <pk-constraint-template>CONSTRAINT ?1 PRIMARY KEY (?2)</pk-constraint-template>
         <fk-constraint-template>ALTER TABLE ?1 ADD CONSTRAINT ?2 FOREIGN KEY (?3) REFERENCES ?4 (?5)</fk-constraint-template>
         <alias-header-prefix>t</alias-header-prefix>
         <alias-header-suffix>_</alias-header-suffix>
         <alias-max-length>31</alias-max-length>
         <subquery-supported>true</subquery-supported>
         <true-mapping>1</true-mapping>
         <false-mapping>0</false-mapping>

         <function-mapping>
            <function-name>count</function-name>
            <function-sql>count(?1)</function-sql>
         </function-mapping>

         <mapping>
            <java-type>java.lang.Boolean</java-type>
            <jdbc-type>BIT</jdbc-type>
            <sql-type>SMALLINT default 0</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Byte</java-type>
            <jdbc-type>TINYINT</jdbc-type>
            <sql-type>SMALLINT default 0</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Short</java-type>
            <jdbc-type>SMALLINT</jdbc-type>
            <sql-type>SMALLINT default 0</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Integer</java-type>
            <jdbc-type>INTEGER</jdbc-type>
            <sql-type>INTEGER default 0</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Long</java-type>
            <jdbc-type>BIGINT</jdbc-type>
            <sql-type>NUMERIC(18,0) default 0</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Float</java-type>
            <jdbc-type>REAL</jdbc-type>
            <sql-type>FLOAT default 0</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Double</java-type>
            <jdbc-type>DOUBLE</jdbc-type>
            <sql-type>DOUBLE PRECISION default 0</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Character</java-type>
            <jdbc-type>VARCHAR</jdbc-type>
            <sql-type>CHAR</sql-type>
         </mapping>
         <mapping>
            <!-- The small default length is due to the 128 byte max index key size -->
            <java-type>java.lang.String</java-type>
            <jdbc-type>VARCHAR</jdbc-type>
            <sql-type>VARCHAR(64)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Date</java-type>
            <jdbc-type>DATE</jdbc-type>
            <sql-type>DATE</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Time</java-type>
            <jdbc-type>TIME</jdbc-type>
            <sql-type>TIME</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Timestamp</java-type>
            <jdbc-type>TIMESTAMP</jdbc-type>
            <sql-type>TIMESTAMP</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Object</java-type>
            <jdbc-type>JAVA_OBJECT</jdbc-type>
            <sql-type>BLOB</sql-type>
         </mapping>
      </type-mapping>

      <type-mapping>
         <name>InterBase</name>
         <row-locking-template>SELECT ?1 FROM ?2 WHERE ?3 ORDER BY ?4 FOR UPDATE</row-locking-template>
         <pk-constraint-template>CONSTRAINT ?1 PRIMARY KEY (?2)</pk-constraint-template>
         <fk-constraint-template>ALTER TABLE ?1 ADD CONSTRAINT ?2 FOREIGN KEY (?3) REFERENCES ?4 (?5)</fk-constraint-template>
         <alias-header-prefix>t</alias-header-prefix>
         <alias-header-suffix>_</alias-header-suffix>
         <alias-max-length>31</alias-max-length>
         <subquery-supported>true</subquery-supported>
         <true-mapping>1</true-mapping>
         <false-mapping>0</false-mapping>

         <function-mapping>
            <function-name>count</function-name>
            <function-sql>count(?1)</function-sql>
         </function-mapping>

         <mapping>
            <java-type>java.lang.Boolean</java-type>
            <jdbc-type>BIT</jdbc-type>
            <sql-type>SMALLINT default 0</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Byte</java-type>
            <jdbc-type>TINYINT</jdbc-type>
            <sql-type>SMALLINT default 0</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Short</java-type>
            <jdbc-type>SMALLINT</jdbc-type>
            <sql-type>SMALLINT default 0</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Integer</java-type>
            <jdbc-type>INTEGER</jdbc-type>
            <sql-type>INTEGER default 0</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Long</java-type>
            <jdbc-type>BIGINT</jdbc-type>
            <sql-type>NUMERIC(18,0) default 0</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Float</java-type>
            <jdbc-type>REAL</jdbc-type>
            <sql-type>FLOAT default 0</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Double</java-type>
            <jdbc-type>DOUBLE</jdbc-type>
            <sql-type>DOUBLE PRECISION default 0</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Character</java-type>
            <jdbc-type>VARCHAR</jdbc-type>
            <sql-type>CHAR</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.String</java-type>
            <jdbc-type>VARCHAR</jdbc-type>
            <sql-type>VARCHAR(64)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Date</java-type>
            <jdbc-type>DATE</jdbc-type>
            <sql-type>DATE</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Time</java-type>
            <jdbc-type>TIME</jdbc-type>
            <sql-type>TIME</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Timestamp</java-type>
            <jdbc-type>TIMESTAMP</jdbc-type>
            <sql-type>TIMESTAMP</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Object</java-type>
            <jdbc-type>JAVA_OBJECT</jdbc-type>
            <sql-type>VARCHAR(2000)</sql-type>
         </mapping>
      </type-mapping>

      <type-mapping>
         <name>DB2</name>
         <row-locking-template/>
         <pk-constraint-template>CONSTRAINT ?1 PRIMARY KEY (?2)</pk-constraint-template>
         <fk-constraint-template>ALTER TABLE ?1 ADD CONSTRAINT ?2 FOREIGN KEY (?3) REFERENCES ?4 (?5)</fk-constraint-template>
         <alias-header-prefix>t</alias-header-prefix>
         <alias-header-suffix>_</alias-header-suffix>
         <alias-max-length>18</alias-max-length>
         <subquery-supported>true</subquery-supported>
         <true-mapping>1</true-mapping>
         <false-mapping>0</false-mapping>

         <function-mapping>
            <function-name>count</function-name>
            <function-sql>count(?1)</function-sql>
         </function-mapping>
		 <function-mapping>
			 <function-name>locate</function-name>
			 <function-sql>locate(CAST(?1 as VARCHAR(254)),
				 CAST(?2 as VaRCHAR(254)),?3)</function-sql>
		 </function-mapping>

         <mapping>
            <java-type>java.lang.Boolean</java-type>
            <jdbc-type>BIT</jdbc-type>
            <sql-type>SMALLINT</sql-type>
         </mapping>
    <!--  DB2 does not appear to support columns of type "byte"
    Regrettably, this means they'll be serialized.
         <mapping>
            <java-type>java.lang.Byte</java-type>
            <jdbc-type>CHAR</jdbc-type>
            <sql-type>CHAR(1) FOR BIT DATA</sql-type>
         </mapping>
    -->
         <mapping>
            <java-type>java.lang.Short</java-type>
            <jdbc-type>SMALLINT</jdbc-type>
            <sql-type>SMALLINT</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Integer</java-type>
            <jdbc-type>INTEGER</jdbc-type>
            <sql-type>INTEGER</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Long</java-type>
            <jdbc-type>BIGINT</jdbc-type>
            <sql-type>BIGINT</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Float</java-type>
            <jdbc-type>REAL</jdbc-type>
            <sql-type>REAL</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Double</java-type>
            <jdbc-type>DOUBLE</jdbc-type>
            <sql-type>DOUBLE</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Character</java-type>
            <jdbc-type>CHAR</jdbc-type>
            <sql-type>CHAR</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.String</java-type>
            <jdbc-type>VARCHAR</jdbc-type>
            <sql-type>VARCHAR(254)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Date</java-type>
            <jdbc-type>DATE</jdbc-type>
            <sql-type>DATE</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Time</java-type>
            <jdbc-type>TIME</jdbc-type>
            <sql-type>TIME</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Timestamp</java-type>
            <jdbc-type>TIMESTAMP</jdbc-type>
            <sql-type>TIMESTAMP</sql-type>
         </mapping>
         <!-- this one gives errors with DB2 V8.1
         		and at least the NET driver
         <mapping>
            <java-type>java.lang.Object</java-type>
            <jdbc-type>JAVA_OBJECT</jdbc-type>
            <sql-type>BLOB(2000)</sql-type>
         </mapping>
         -->
      	<mapping>
            <java-type>java.lang.Object</java-type>
            <jdbc-type>VARBINARY</jdbc-type>
            <sql-type>BLOB(2000)</sql-type>
         </mapping>
      </type-mapping>

      <type-mapping>
         <name>Derby</name>
         <row-locking-template/>
         <pk-constraint-template>CONSTRAINT ?1 PRIMARY KEY (?2)</pk-constraint-template>
         <fk-constraint-template>ALTER TABLE ?1 ADD CONSTRAINT ?2 FOREIGN KEY (?3) REFERENCES ?4 (?5)</fk-constraint-template>
         <alias-header-prefix>t</alias-header-prefix>
         <alias-header-suffix>_</alias-header-suffix>
         <alias-max-length>18</alias-max-length>
         <subquery-supported>true</subquery-supported>
         <true-mapping>1</true-mapping>
         <false-mapping>0</false-mapping>

         <function-mapping>
            <function-name>concat</function-name>
            <function-sql>(?1 || ?2)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>substr</function-name>
            <function-sql>substr(?1, ?2, ?3)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>lcase</function-name>
            <function-sql>lower(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>length</function-name>
            <function-sql>length(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>locate</function-name>
            <function-sql>locate(?2, ?1, ?3)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>abs</function-name>
            <function-sql>abs(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>sqrt</function-name>
            <function-sql>sqrt(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>ucase</function-name>
            <function-sql>upper(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>count</function-name>
            <function-sql>count(?1)</function-sql>
         </function-mapping>

         <mapping>
            <java-type>java.math.BigDecimal</java-type>
            <jdbc-type>NUMERIC</jdbc-type>
            <sql-type>DECIMAL</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Boolean</java-type>
            <jdbc-type>BIT</jdbc-type>
            <sql-type>BOOLEAN</sql-type>
         </mapping>
<!-- if someone knows the mapping for byte, please, let us know!
         <mapping>
            <java-type>java.lang.Byte</java-type>
            <jdbc-type>SMALLINT</jdbc-type>
            <sql-type>SMALLINT</sql-type>
         </mapping>
-->
         <mapping>
            <java-type>java.lang.Short</java-type>
            <jdbc-type>SMALLINT</jdbc-type>
            <sql-type>SMALLINT</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Integer</java-type>
            <jdbc-type>INTEGER</jdbc-type>
            <sql-type>INTEGER</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Long</java-type>
            <jdbc-type>BIGINT</jdbc-type>
            <sql-type>BIGINT</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Float</java-type>
            <jdbc-type>REAL</jdbc-type>
            <sql-type>REAL</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Double</java-type>
            <jdbc-type>DOUBLE</jdbc-type>
            <sql-type>DOUBLE PRECISION</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Character</java-type>
            <jdbc-type>CHAR</jdbc-type>
            <sql-type>CHAR</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.String</java-type>
            <jdbc-type>VARCHAR</jdbc-type>
            <sql-type>VARCHAR(256)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Date</java-type>
            <jdbc-type>DATE</jdbc-type>
            <sql-type>DATE</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Time</java-type>
            <jdbc-type>TIME</jdbc-type>
            <sql-type>TIME</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Timestamp</java-type>
            <jdbc-type>TIMESTAMP</jdbc-type>
            <sql-type>TIMESTAMP</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Object</java-type>
            <jdbc-type>BLOB</jdbc-type>
            <sql-type>BLOB</sql-type>
         </mapping>
      </type-mapping>

      <type-mapping>
         <name>Oracle9i</name>
         <!--
         | Make sure that you have the Oracle 9i version of classes12.jar
         | or you will suffer
         -->
         <row-locking-template>SELECT ?1 FROM ?2 WHERE ?3 ORDER BY ?4 FOR UPDATE</row-locking-template>
         <pk-constraint-template>CONSTRAINT ?1 PRIMARY KEY (?2)</pk-constraint-template>
         <fk-constraint-template>ALTER TABLE ?1 ADD CONSTRAINT ?2 FOREIGN KEY (?3) REFERENCES ?4 (?5)</fk-constraint-template>
         <alias-header-prefix>t</alias-header-prefix>
         <alias-header-suffix>_</alias-header-suffix>
         <alias-max-length>30</alias-max-length>
         <subquery-supported>true</subquery-supported>
         <true-mapping>1</true-mapping>
         <false-mapping>0</false-mapping>

         <function-mapping>
            <function-name>concat</function-name>
            <function-sql>(?1 || ?2)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>substring</function-name>
            <function-sql>substr(?1, ?2, ?3)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>lcase</function-name>
            <function-sql>lower(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>length</function-name>
            <function-sql>length(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>locate</function-name>
            <function-sql>instr(?2, ?1, ?3)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>abs</function-name>
            <function-sql>abs(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>sqrt</function-name>
            <function-sql>sqrt(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>ucase</function-name>
            <function-sql>upper(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>count</function-name>
            <function-sql>count(?1)</function-sql>
         </function-mapping>

         <mapping>
            <java-type>java.lang.Boolean</java-type>
            <jdbc-type>BIT</jdbc-type>
            <sql-type>NUMBER(1)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Byte</java-type>
            <jdbc-type>SMALLINT</jdbc-type>
            <sql-type>NUMBER(3)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Short</java-type>
            <jdbc-type>NUMERIC</jdbc-type>
            <!-- <jdbc-type>SMALLINT</jdbc-type> this resulted in a ClassCastException -->
            <sql-type>NUMBER(5)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Integer</java-type>
            <jdbc-type>INTEGER</jdbc-type>
            <sql-type>NUMBER(10)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Long</java-type>
            <jdbc-type>BIGINT</jdbc-type>
            <sql-type>NUMBER(19)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Float</java-type>
            <jdbc-type>REAL</jdbc-type>
            <sql-type>NUMBER(38,7)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.math.BigDecimal</java-type>
            <jdbc-type>DECIMAL</jdbc-type>
            <sql-type>NUMBER(38,15)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Double</java-type>
            <jdbc-type>DOUBLE</jdbc-type>
            <sql-type>NUMBER(38,15)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Character</java-type>
            <jdbc-type>VARCHAR</jdbc-type>
            <sql-type>CHAR</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.String</java-type>
            <jdbc-type>VARCHAR</jdbc-type>
            <sql-type>VARCHAR2(255)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.util.Date</java-type>
            <jdbc-type>TIMESTAMP</jdbc-type>
            <sql-type>TIMESTAMP(3)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Date</java-type>
            <jdbc-type>DATE</jdbc-type>
            <sql-type>DATE</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Time</java-type>
            <jdbc-type>TIME</jdbc-type>
            <sql-type>DATE</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Timestamp</java-type>
            <jdbc-type>TIMESTAMP</jdbc-type>
            <sql-type>TIMESTAMP(9)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Object</java-type>
            <jdbc-type>BLOB</jdbc-type>
            <sql-type>BLOB</sql-type>
            <!--
            | Change this from BLOB to RAW(n) if you know your
            | serialized object will be <= n bytes and n <= 2000
            -->
         </mapping>
      </type-mapping>

      <type-mapping>
         <name>Oracle8</name>
         <row-locking-template>SELECT ?1 FROM ?2 WHERE ?3 ORDER BY ?4 FOR UPDATE</row-locking-template>
         <pk-constraint-template>CONSTRAINT ?1 PRIMARY KEY (?2)</pk-constraint-template>
         <fk-constraint-template>ALTER TABLE ?1 ADD CONSTRAINT ?2 FOREIGN KEY (?3) REFERENCES ?4 (?5)</fk-constraint-template>
         <alias-header-prefix>t</alias-header-prefix>
         <alias-header-suffix>_</alias-header-suffix>
         <alias-max-length>30</alias-max-length>
         <subquery-supported>true</subquery-supported>
         <true-mapping>1</true-mapping>
         <false-mapping>0</false-mapping>

         <function-mapping>
            <function-name>concat</function-name>
            <function-sql>(?1 || ?2)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>substring</function-name>
            <function-sql>substr(?1, ?2, ?3)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>lcase</function-name>
            <function-sql>lower(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>length</function-name>
            <function-sql>length(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>locate</function-name>
            <function-sql>instr(?2, ?1, ?3)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>abs</function-name>
            <function-sql>abs(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>sqrt</function-name>
            <function-sql>sqrt(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>ucase</function-name>
            <function-sql>upper(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>count</function-name>
            <function-sql>count(?1)</function-sql>
         </function-mapping>

         <mapping>
            <java-type>java.lang.Boolean</java-type>
            <jdbc-type>BIT</jdbc-type>
            <sql-type>NUMBER(1)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Byte</java-type>
            <jdbc-type>NUMERIC</jdbc-type>
            <sql-type>NUMBER(3)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Short</java-type>
            <jdbc-type>NUMERIC</jdbc-type>
            <sql-type>NUMBER(5)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Integer</java-type>
            <jdbc-type>INTEGER</jdbc-type>
            <sql-type>NUMBER(10)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Long</java-type>
            <jdbc-type>BIGINT</jdbc-type>
            <sql-type>NUMBER(19)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Float</java-type>
            <jdbc-type>REAL</jdbc-type>
            <sql-type>NUMBER(38,7)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.math.BigDecimal</java-type>
            <jdbc-type>DECIMAL</jdbc-type>
            <sql-type>NUMBER(38,15)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Double</java-type>
            <jdbc-type>DOUBLE</jdbc-type>
            <sql-type>NUMBER(38,15)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Character</java-type>
            <jdbc-type>VARCHAR</jdbc-type>
            <sql-type>CHAR</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.String</java-type>
            <jdbc-type>VARCHAR</jdbc-type>
            <sql-type>VARCHAR2(255)</sql-type>
         </mapping>
         <mapping>
            <!--
            | Note that you lose granularity here
            | Use a numeric type and store milliseconds if you really need it
            -->
            <java-type>java.util.Date</java-type>
            <jdbc-type>TIMESTAMP</jdbc-type>
            <sql-type>DATE</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Date</java-type>
            <jdbc-type>DATE</jdbc-type>
            <sql-type>DATE</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Time</java-type>
            <jdbc-type>TIME</jdbc-type>
            <sql-type>DATE</sql-type>
         </mapping>
         <mapping>
            <!--
            | Note that you lose granularity here
            | Use a numeric type and store milliseconds if you really need it
            -->
            <java-type>java.sql.Timestamp</java-type>
            <jdbc-type>TIMESTAMP</jdbc-type>
            <sql-type>DATE</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Object</java-type>
            <jdbc-type>BLOB</jdbc-type>
            <sql-type>BLOB</sql-type>
            <!--
            | Change this from BLOB to RAW(n) if you know your
            | serialized object will be <= n bytes and n <= 2000
            -->
         </mapping>
      </type-mapping>

      <type-mapping>
         <name>Oracle7</name>
         <row-locking-template>SELECT ?1 FROM ?2 WHERE ?3 ORDER BY ?4 FOR UPDATE</row-locking-template>
         <pk-constraint-template>CONSTRAINT ?1 PRIMARY KEY (?2)</pk-constraint-template>
         <fk-constraint-template>ALTER TABLE ?1 ADD CONSTRAINT ?2 FOREIGN KEY (?3) REFERENCES ?4 (?5)</fk-constraint-template>
         <alias-header-prefix>t</alias-header-prefix>
         <alias-header-suffix>_</alias-header-suffix>
         <alias-max-length>30</alias-max-length>
         <subquery-supported>true</subquery-supported>
         <true-mapping>1</true-mapping>
         <false-mapping>0</false-mapping>

         <function-mapping>
            <function-name>concat</function-name>
            <function-sql>(?1 || ?2)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>substring</function-name>
            <function-sql>substr(?1, ?2, ?3)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>lcase</function-name>
            <function-sql>lower(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>length</function-name>
            <function-sql>length(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>locate</function-name>
            <function-sql>instr(?2, ?1, ?3)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>abs</function-name>
            <function-sql>abs(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>sqrt</function-name>
            <function-sql>sqrt(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>ucase</function-name>
            <function-sql>upper(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>count</function-name>
            <function-sql>count(?1)</function-sql>
         </function-mapping>

         <mapping>
            <java-type>java.lang.Boolean</java-type>
            <jdbc-type>BIT</jdbc-type>
            <sql-type>NUMBER(1)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Byte</java-type>
            <jdbc-type>NUMERIC</jdbc-type>
            <sql-type>NUMBER(3)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Short</java-type>
            <jdbc-type>NUMERIC</jdbc-type>
            <sql-type>NUMBER(5)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Integer</java-type>
            <jdbc-type>INTEGER</jdbc-type>
            <sql-type>NUMBER(10)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Long</java-type>
            <jdbc-type>BIGINT</jdbc-type>
            <sql-type>NUMBER(19)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Float</java-type>
            <jdbc-type>REAL</jdbc-type>
            <sql-type>NUMBER(38,7)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Double</java-type>
            <jdbc-type>DOUBLE</jdbc-type>
            <sql-type>NUMBER(38,15)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Character</java-type>
            <jdbc-type>VARCHAR</jdbc-type>
            <sql-type>CHAR</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.String</java-type>
            <jdbc-type>VARCHAR</jdbc-type>
            <sql-type>VARCHAR2(255)</sql-type>
         </mapping>
         <mapping>
            <!--
            | Note that you lose granularity here
            | Use a numeric type and store milliseconds if you really need it
            -->
            <java-type>java.util.Date</java-type>
            <jdbc-type>TIMESTAMP</jdbc-type>
            <sql-type>DATE</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Date</java-type>
            <jdbc-type>DATE</jdbc-type>
            <sql-type>DATE</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Time</java-type>
            <jdbc-type>TIME</jdbc-type>
            <sql-type>DATE</sql-type>
         </mapping>
         <mapping>
            <!--
            | Note that you lose granularity here
            | Use a numeric type and store milliseconds if you really need it
            -->
            <java-type>java.sql.Timestamp</java-type>
            <jdbc-type>TIMESTAMP</jdbc-type>
            <sql-type>DATE</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Object</java-type>
            <jdbc-type>LONGVARBINARY</jdbc-type>
            <sql-type>LONG RAW</sql-type>
            <!--
            | Change this from LONG RAW to RAW(n) if you know your
            | serialized object will be <= n bytes and n <= 2000
            | Oracle only permits one LONG type per table
            -->
         </mapping>
      </type-mapping>

      <type-mapping>
         <name>Sybase</name>
         <row-locking-template/>
         <pk-constraint-template>CONSTRAINT ?1 PRIMARY KEY (?2)</pk-constraint-template>
         <fk-constraint-template>ALTER TABLE ?1 ADD CONSTRAINT ?2 FOREIGN KEY (?3) REFERENCES ?4 (?5)</fk-constraint-template>
         <alias-header-prefix>t</alias-header-prefix>
         <alias-header-suffix>_</alias-header-suffix>
         <alias-max-length>30</alias-max-length>
         <subquery-supported>true</subquery-supported>
         <true-mapping>1</true-mapping>
         <false-mapping>0</false-mapping>

         <function-mapping>
            <function-name>count</function-name>
            <function-sql>count(?1)</function-sql>
         </function-mapping>
         <function-mapping>
         	<function-name>length</function-name>
         	<function-sql>char_length(?1)</function-sql>
         </function-mapping>

         <mapping>
            <java-type>java.lang.Boolean</java-type>
            <jdbc-type>BIT</jdbc-type>
            <sql-type>BIT</sql-type>
         </mapping>
    <!-- Current Sybase JDBC drivers (jConnect 5.2) don't support
    byte or short.  Unfortunately they'll be serialized.
         <mapping>
            <java-type>java.lang.Byte</java-type>
            <jdbc-type>TINYINT</jdbc-type>
            <sql-type>TINYINT</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Short</java-type>
            <jdbc-type>SMALLINT</jdbc-type>
            <sql-type>SMALLINT</sql-type>
         </mapping>
    -->
         <mapping>
            <java-type>java.lang.Integer</java-type>
            <jdbc-type>INTEGER</jdbc-type>
            <sql-type>INTEGER</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Long</java-type>
            <jdbc-type>NUMERIC</jdbc-type>
            <sql-type>NUMERIC(38,0)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Float</java-type>
            <jdbc-type>REAL</jdbc-type>
            <sql-type>REAL</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Double</java-type>
            <jdbc-type>DOUBLE</jdbc-type>
            <sql-type>DOUBLE PRECISION</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Character</java-type>
            <jdbc-type>CHAR</jdbc-type>
            <sql-type>CHAR</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.String</java-type>
            <jdbc-type>VARCHAR</jdbc-type>
            <sql-type>VARCHAR(255)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.util.Date</java-type>
            <jdbc-type>TIMESTAMP</jdbc-type>
            <sql-type>DATETIME</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Date</java-type>
            <jdbc-type>DATE</jdbc-type>
            <sql-type>DATETIME</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Time</java-type>
            <jdbc-type>TIME</jdbc-type>
            <sql-type>SMALLDATETIME</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Timestamp</java-type>
            <jdbc-type>TIMESTAMP</jdbc-type>
            <sql-type>DATETIME</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Object</java-type>
            <jdbc-type>JAVA_OBJECT</jdbc-type>
            <sql-type>IMAGE</sql-type>
         </mapping>
      </type-mapping>

      <type-mapping>
         <name>PostgreSQL</name>
         <row-locking-template>SELECT ?1 FROM ?2 WHERE ?3 ORDER BY ?4 FOR UPDATE</row-locking-template>
         <pk-constraint-template>CONSTRAINT ?1 PRIMARY KEY (?2)</pk-constraint-template>
         <fk-constraint-template>ALTER TABLE ?1 ADD CONSTRAINT ?2 FOREIGN KEY (?3) REFERENCES ?4 (?5)</fk-constraint-template>
         <auto-increment-template>?1</auto-increment-template>
         <alias-header-prefix>t</alias-header-prefix>
         <alias-header-suffix>_</alias-header-suffix>
         <alias-max-length>32</alias-max-length>
         <subquery-supported>true</subquery-supported>
         <true-mapping>TRUE</true-mapping>
         <false-mapping>FALSE</false-mapping>

         <function-mapping>
            <function-name>concat</function-name>
            <function-sql>(?1 || ?2)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>substring</function-name>
            <function-sql>substring(?1 FROM ?2 FOR ?3)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>lcase</function-name>
            <function-sql>lower(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>length</function-name>
            <function-sql>length(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>locate</function-name>
            <function-sql>(CASE position(?1 in substring(?2 from ?3)) WHEN 0 THEN 0 ELSE position(?1 in substring(?2 from ?3)) + ?3 - 1 END)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>abs</function-name>
            <function-sql>abs(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>sqrt</function-name>
            <function-sql>sqrt(CAST(?1 AS double precision))</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>ucase</function-name>
            <function-sql>upper(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>count</function-name>
            <function-sql>count(?1)</function-sql>
         </function-mapping>

         <mapping>
            <java-type>java.lang.Boolean</java-type>
            <jdbc-type>CHAR</jdbc-type>
            <sql-type>BOOLEAN</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Byte</java-type>
            <jdbc-type>TINYINT</jdbc-type>
            <sql-type>INT2</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Short</java-type>
            <jdbc-type>SMALLINT</jdbc-type>
            <sql-type>INT2</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Integer</java-type>
            <jdbc-type>INTEGER</jdbc-type>
            <sql-type>INT4</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Long</java-type>
            <jdbc-type>BIGINT</jdbc-type>
            <sql-type>INT8</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Float</java-type>
            <jdbc-type>FLOAT</jdbc-type>
            <sql-type>FLOAT(7)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Double</java-type>
            <jdbc-type>DOUBLE</jdbc-type>
            <sql-type>FLOAT8</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Character</java-type>
            <jdbc-type>CHAR</jdbc-type>
            <sql-type>CHAR(1)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.String</java-type>
            <jdbc-type>VARCHAR</jdbc-type>
            <sql-type>TEXT</sql-type>
         </mapping>
         <mapping>
            <java-type>java.util.Date</java-type>
            <jdbc-type>TIMESTAMP</jdbc-type>
            <sql-type>TIMESTAMP with time zone</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Date</java-type>
            <jdbc-type>DATE</jdbc-type>
            <sql-type>DATE</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Time</java-type>
            <jdbc-type>TIME</jdbc-type>
            <sql-type>TIME</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Timestamp</java-type>
            <jdbc-type>TIMESTAMP</jdbc-type>
            <sql-type>TIMESTAMP with time zone</sql-type>
         </mapping>
         <mapping>
            <java-type>java.math.BigDecimal</java-type>
            <jdbc-type>NUMERIC</jdbc-type>
            <sql-type>NUMERIC</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Object</java-type>
            <jdbc-type>VARBINARY</jdbc-type>
            <sql-type>BYTEA</sql-type>
         </mapping>
      </type-mapping>

      <type-mapping>
         <name>PostgreSQL 8.0</name>
         <row-locking-template>SELECT ?1 FROM ?2 WHERE ?3 ORDER BY ?4 FOR UPDATE</row-locking-template>
         <pk-constraint-template>CONSTRAINT ?1 PRIMARY KEY (?2)</pk-constraint-template>
         <fk-constraint-template>ALTER TABLE ?1 ADD CONSTRAINT ?2 FOREIGN KEY (?3) REFERENCES ?4 (?5)</fk-constraint-template>
         <auto-increment-template>?1</auto-increment-template>
         <alias-header-prefix>t</alias-header-prefix>
         <alias-header-suffix>_</alias-header-suffix>
         <alias-max-length>32</alias-max-length>
         <subquery-supported>true</subquery-supported>
         <true-mapping>TRUE</true-mapping>
         <false-mapping>FALSE</false-mapping>

         <function-mapping>
            <function-name>concat</function-name>
            <function-sql>(?1 || ?2)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>substring</function-name>
            <function-sql>substring(?1 FROM ?2 FOR ?3)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>lcase</function-name>
            <function-sql>lower(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>length</function-name>
            <function-sql>length(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>locate</function-name>
            <function-sql>(CASE position(?1 in substring(?2 from ?3)) WHEN 0 THEN 0 ELSE position(?1 in substring(?2 from ?3)) + ?3 - 1 END)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>abs</function-name>
            <function-sql>abs(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>sqrt</function-name>
            <function-sql>sqrt(CAST(?1 AS double precision))</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>ucase</function-name>
            <function-sql>upper(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>count</function-name>
            <function-sql>count(?1)</function-sql>
         </function-mapping>

         <mapping>
            <java-type>java.lang.Boolean</java-type>
            <jdbc-type>BOOLEAN</jdbc-type>
            <sql-type>BOOLEAN</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Byte</java-type>
            <jdbc-type>TINYINT</jdbc-type>
            <sql-type>INT2</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Short</java-type>
            <jdbc-type>SMALLINT</jdbc-type>
            <sql-type>INT2</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Integer</java-type>
            <jdbc-type>INTEGER</jdbc-type>
            <sql-type>INT4</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Long</java-type>
            <jdbc-type>BIGINT</jdbc-type>
            <sql-type>INT8</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Float</java-type>
            <jdbc-type>FLOAT</jdbc-type>
            <sql-type>FLOAT(7)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Double</java-type>
            <jdbc-type>DOUBLE</jdbc-type>
            <sql-type>FLOAT8</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Character</java-type>
            <jdbc-type>CHAR</jdbc-type>
            <sql-type>CHAR(1)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.String</java-type>
            <jdbc-type>VARCHAR</jdbc-type>
            <sql-type>TEXT</sql-type>
         </mapping>
         <mapping>
            <java-type>java.util.Date</java-type>
            <jdbc-type>TIMESTAMP</jdbc-type>
            <sql-type>TIMESTAMP</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Date</java-type>
            <jdbc-type>DATE</jdbc-type>
            <sql-type>DATE</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Time</java-type>
            <jdbc-type>TIME</jdbc-type>
            <sql-type>TIME</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Timestamp</java-type>
            <jdbc-type>TIMESTAMP</jdbc-type>
            <sql-type>TIMESTAMP</sql-type>
         </mapping>
         <mapping>
            <java-type>java.math.BigDecimal</java-type>
            <jdbc-type>NUMERIC</jdbc-type>
            <sql-type>NUMERIC</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Object</java-type>
            <jdbc-type>VARBINARY</jdbc-type>
            <sql-type>BYTEA</sql-type>
         </mapping>
      </type-mapping>

      <type-mapping>
         <name>PostgreSQL 7.2</name>
         <row-locking-template>SELECT ?1 FROM ?2 WHERE ?3 ORDER BY ?4 FOR UPDATE</row-locking-template>
         <pk-constraint-template>CONSTRAINT ?1 PRIMARY KEY (?2)</pk-constraint-template>
         <fk-constraint-template>ALTER TABLE ?1 ADD CONSTRAINT ?2 FOREIGN KEY (?3) REFERENCES ?4 (?5)</fk-constraint-template>
         <auto-increment-template>?1</auto-increment-template>
         <alias-header-prefix>t</alias-header-prefix>
         <alias-header-suffix>_</alias-header-suffix>
         <alias-max-length>32</alias-max-length>
         <subquery-supported>true</subquery-supported>
         <true-mapping>TRUE</true-mapping>
         <false-mapping>FALSE</false-mapping>

         <function-mapping>
            <function-name>concat</function-name>
            <function-sql>(?1 || ?2)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>substring</function-name>
            <function-sql>substring(?1 FROM ?2 FOR ?3)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>lcase</function-name>
            <function-sql>lower(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>length</function-name>
            <function-sql>length(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>locate</function-name>
            <function-sql>(CASE position(?1 in substring(?2 from ?3)) WHEN 0 THEN 0 ELSE position(?1 in substring(?2 from ?3)) + ?3 - 1 END)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>abs</function-name>
            <function-sql>abs(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>sqrt</function-name>
            <function-sql>sqrt(CAST(?1 AS double precision))</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>ucase</function-name>
            <function-sql>upper(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>count</function-name>
            <function-sql>count(?1)</function-sql>
         </function-mapping>

         <mapping>
            <java-type>java.lang.Boolean</java-type>
            <jdbc-type>CHAR</jdbc-type>
            <sql-type>BOOLEAN</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Byte</java-type>
            <jdbc-type>TINYINT</jdbc-type>
            <sql-type>INT2</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Short</java-type>
            <jdbc-type>SMALLINT</jdbc-type>
            <sql-type>INT2</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Integer</java-type>
            <jdbc-type>INTEGER</jdbc-type>
            <sql-type>INT4</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Long</java-type>
            <jdbc-type>BIGINT</jdbc-type>
            <sql-type>INT8</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Float</java-type>
            <jdbc-type>FLOAT</jdbc-type>
            <sql-type>FLOAT(7)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Double</java-type>
            <jdbc-type>DOUBLE</jdbc-type>
            <sql-type>FLOAT8</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Character</java-type>
            <jdbc-type>CHAR</jdbc-type>
            <sql-type>CHAR(1)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.String</java-type>
            <jdbc-type>VARCHAR</jdbc-type>
            <sql-type>TEXT</sql-type>
         </mapping>
         <mapping>
            <java-type>java.util.Date</java-type>
            <jdbc-type>TIMESTAMP</jdbc-type>
            <sql-type>TIMESTAMP</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Date</java-type>
            <jdbc-type>DATE</jdbc-type>
            <sql-type>DATE</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Time</java-type>
            <jdbc-type>TIME</jdbc-type>
            <sql-type>TIME</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Timestamp</java-type>
            <jdbc-type>TIMESTAMP</jdbc-type>
            <sql-type>TIMESTAMP</sql-type>
         </mapping>
         <mapping>
            <java-type>java.math.BigDecimal</java-type>
            <jdbc-type>NUMERIC</jdbc-type>
            <sql-type>NUMERIC</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Object</java-type>
            <jdbc-type>VARBINARY</jdbc-type>
            <sql-type>BYTEA</sql-type>
         </mapping>
      </type-mapping>

      <type-mapping>
         <name>Hypersonic SQL</name>
         <row-locking-template/>
         <pk-constraint-template>CONSTRAINT ?1 PRIMARY KEY (?2)</pk-constraint-template>
         <fk-constraint-template>ALTER TABLE ?1 ADD CONSTRAINT ?2 FOREIGN KEY (?3) REFERENCES ?4 (?5)</fk-constraint-template>
         <auto-increment-template>?1 IDENTITY</auto-increment-template>
         <add-column-template>ALTER TABLE ?1 ADD COLUMN ?2 ?3</add-column-template>
         <drop-column-template>ALTER TABLE ?1 DROP COLUMN ?2</drop-column-template>
         <alias-header-prefix>t</alias-header-prefix>
         <alias-header-suffix>_</alias-header-suffix>
         <alias-max-length>32</alias-max-length>
         <subquery-supported>true</subquery-supported>
         <true-mapping>(1=1)</true-mapping>
         <false-mapping>(1=0)</false-mapping>

         <function-mapping>
            <function-name>concat</function-name>
            <function-sql>(?1 || ?2)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>substring</function-name>
            <function-sql>SUBSTRING(?1, ?2, ?3)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>lcase</function-name>
            <function-sql>lcase(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>length</function-name>
            <function-sql>LENGTH(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>locate</function-name>
            <function-sql>LOCATE(?1, ?2, ?3)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>abs</function-name>
            <function-sql>ABS(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>sqrt</function-name>
            <function-sql>SQRT(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>ucase</function-name>
            <function-sql>ucase(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>count</function-name>
            <function-sql>count(?1)</function-sql>
         </function-mapping>

         <mapping>
            <java-type>java.lang.Byte</java-type>
            <jdbc-type>SMALLINT</jdbc-type>
            <sql-type>SMALLINT</sql-type>
         </mapping>
         <mapping>
            <java-type>java.util.Date</java-type>
            <jdbc-type>TIMESTAMP</jdbc-type>
            <sql-type>TIMESTAMP</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Boolean</java-type>
            <jdbc-type>BIT</jdbc-type>
            <sql-type>BIT</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Integer</java-type>
            <jdbc-type>INTEGER</jdbc-type>
            <sql-type>INTEGER</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Object</java-type>
            <!-- hsqldb only supports directly serializable objects for sql type OBJECT -->
            <jdbc-type>VARBINARY</jdbc-type>
            <sql-type>VARBINARY</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Short</java-type>
            <jdbc-type>SMALLINT</jdbc-type>
            <sql-type>SMALLINT</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Character</java-type>
            <jdbc-type>CHAR</jdbc-type>
            <sql-type>CHAR</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.String</java-type>
            <jdbc-type>VARCHAR</jdbc-type>
            <sql-type>VARCHAR(256)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Date</java-type>
            <jdbc-type>DATE</jdbc-type>
            <sql-type>DATE</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Time</java-type>
            <jdbc-type>TIME</jdbc-type>
            <sql-type>TIME</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Timestamp</java-type>
            <jdbc-type>TIMESTAMP</jdbc-type>
            <sql-type>TIMESTAMP</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Float</java-type>
            <jdbc-type>REAL</jdbc-type>
            <sql-type>REAL</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Long</java-type>
            <jdbc-type>BIGINT</jdbc-type>
            <sql-type>BIGINT</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Double</java-type>
            <jdbc-type>DOUBLE</jdbc-type>
            <sql-type>DOUBLE</sql-type>
         </mapping>
         <mapping>
            <java-type>java.math.BigDecimal</java-type>
            <jdbc-type>DECIMAL</jdbc-type>
            <sql-type>DECIMAL</sql-type>
         </mapping>
      </type-mapping>

      <type-mapping>
         <name>PointBase</name>
         <row-locking-template>SELECT ?1 FROM ?2 WHERE ?3 ORDER BY ?4 FOR UPDATE</row-locking-template>
         <pk-constraint-template>CONSTRAINT ?1 PRIMARY KEY (?2)</pk-constraint-template>
         <fk-constraint-template>ALTER TABLE ?1 ADD CONSTRAINT ?2 FOREIGN KEY (?3) REFERENCES ?4 (?5)</fk-constraint-template>
         <alias-header-prefix>t</alias-header-prefix>
         <alias-header-suffix>_</alias-header-suffix>
         <alias-max-length>32</alias-max-length>
         <subquery-supported>true</subquery-supported>
         <true-mapping>TRUE</true-mapping>
         <false-mapping>FALSE</false-mapping>

         <function-mapping>
            <function-name>lcase</function-name>
            <function-sql>lower(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>ucase</function-name>
            <function-sql>upper(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>count</function-name>
            <function-sql>count(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>locate</function-name>
            <function-sql>position(?1 IN ?2)</function-sql>
         </function-mapping>

         <mapping>
            <java-type>java.lang.Character</java-type>
            <jdbc-type>CHAR</jdbc-type>
            <sql-type>CHAR</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Short</java-type>
            <jdbc-type>SMALLINT</jdbc-type>
            <sql-type>SMALLINT</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Long</java-type>
            <jdbc-type>BIGINT</jdbc-type>
            <sql-type>INTEGER</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Double</java-type>
            <jdbc-type>DOUBLE</jdbc-type>
            <sql-type>FLOAT</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Float</java-type>
            <jdbc-type>FLOAT</jdbc-type>
            <sql-type>FLOAT</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Boolean</java-type>
            <jdbc-type>BIT</jdbc-type>
            <sql-type>BOOLEAN</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.String</java-type>
            <jdbc-type>VARCHAR</jdbc-type>
            <sql-type>VARCHAR(256)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Byte</java-type>
            <jdbc-type>SMALLINT</jdbc-type>
            <sql-type>SMALLINT</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Object</java-type>
            <jdbc-type>BLOB</jdbc-type>
            <sql-type>BLOB</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Integer</java-type>
            <jdbc-type>INTEGER</jdbc-type>
            <sql-type>INTEGER</sql-type>
         </mapping>
         <mapping>
            <java-type>java.util.Date</java-type>
            <jdbc-type>DATE</jdbc-type>
            <sql-type>DATE</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Timestamp</java-type>
            <jdbc-type>TIMESTAMP</jdbc-type>
            <sql-type>TIMESTAMP</sql-type>
         </mapping>
      </type-mapping>

      <type-mapping>
         <name>SOLID</name>
         <row-locking-template/>
         <pk-constraint-template>PRIMARY KEY (?2)</pk-constraint-template>
         <fk-constraint-template>ALTER TABLE ?1 ADD CONSTRAINT ?2 FOREIGN KEY (?3) REFERENCES ?4 (?5)</fk-constraint-template>
         <alias-header-prefix>t</alias-header-prefix>
         <alias-header-suffix>_</alias-header-suffix>
         <alias-max-length>32</alias-max-length>
         <subquery-supported>true</subquery-supported>
         <true-mapping>1</true-mapping>
         <false-mapping>0</false-mapping>

         <function-mapping>
            <function-name>count</function-name>
            <function-sql>count(?1)</function-sql>
         </function-mapping>

         <mapping>
            <java-type>java.lang.Character</java-type>
            <jdbc-type>CHAR</jdbc-type>
            <sql-type>CHAR</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Byte</java-type>
            <jdbc-type>TINYINT</jdbc-type>
            <sql-type>TINYINT</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Short</java-type>
            <jdbc-type>INTEGER</jdbc-type>
            <sql-type>INTEGER</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Double</java-type>
            <jdbc-type>DOUBLE</jdbc-type>
            <sql-type>DOUBLE</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Object</java-type>
            <jdbc-type>BLOB</jdbc-type>
            <sql-type>BLOB</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.String</java-type>
            <jdbc-type>VARCHAR</jdbc-type>
            <sql-type>VARCHAR(256)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Integer</java-type>
            <jdbc-type>INTEGER</jdbc-type>
            <sql-type>INTEGER</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Timestamp</java-type>
            <jdbc-type>TIMESTAMP</jdbc-type>
            <sql-type>TIMESTAMP</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Boolean</java-type>
            <jdbc-type>BIT</jdbc-type>
            <sql-type>BIT</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Float</java-type>
            <jdbc-type>FLOAT</jdbc-type>
            <sql-type>FLOAT</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Long</java-type>
            <jdbc-type>BIGINT</jdbc-type>
            <sql-type>BIGINT</sql-type>
         </mapping>
         <mapping>
            <java-type>java.util.Date</java-type>
            <jdbc-type>TIMESTAMP</jdbc-type>
            <sql-type>TIMESTAMP</sql-type>
         </mapping>
      </type-mapping>

      <type-mapping>
         <name>mySQL</name>
         <row-locking-template>SELECT ?1 FROM ?2 WHERE ?3 ORDER BY ?4 FOR UPDATE</row-locking-template>
         <pk-constraint-template>CONSTRAINT ?1 PRIMARY KEY (?2)</pk-constraint-template>
         <!-- does not work for compound keys <fk-constraint-template>ALTER TABLE ?1 ADD INDEX ind_?3 (?3), ADD CONSTRAINT ?2 FOREIGN KEY (?3) REFERENCES ?4 (?5)</fk-constraint-template>
              <fk-constraint-template>ALTER TABLE ?1 ADD CONSTRAINT ?2 FOREIGN KEY (?3) REFERENCES ?4 (?5)</fk-constraint-template>
         -->
         <fk-constraint-template>ALTER TABLE ?1 ADD INDEX (?3), ADD CONSTRAINT ?2 FOREIGN KEY (?3) REFERENCES ?4 (?5)</fk-constraint-template>
         <auto-increment-template>?1 auto_increment</auto-increment-template>
         <alter-column-template>ALTER TABLE ?1 MODIFY ?2 ?3</alter-column-template>
         <alias-header-prefix>t</alias-header-prefix>
         <alias-header-suffix>_</alias-header-suffix>
         <alias-max-length>32</alias-max-length>
         <subquery-supported>false</subquery-supported>
         <true-mapping>1</true-mapping>
         <false-mapping>0</false-mapping>

         <function-mapping>
            <function-name>concat</function-name>
            <function-sql>concat(?1, ?2)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>substring</function-name>
            <function-sql>substring(?1 FROM ?2 FOR ?3)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>lcase</function-name>
            <function-sql>lower(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>length</function-name>
            <function-sql>length(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>locate</function-name>
            <function-sql>locate(?1, ?2, ?3)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>abs</function-name>
            <function-sql>abs(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>sqrt</function-name>
            <function-sql>sqrt(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>ucase</function-name>
            <function-sql>upper(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>count</function-name>
            <function-sql>count(?1)</function-sql>
         </function-mapping>

         <mapping>
            <java-type>java.lang.Float</java-type>
            <jdbc-type>FLOAT</jdbc-type>
            <sql-type>FLOAT</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Double</java-type>
            <jdbc-type>DOUBLE</jdbc-type>
            <sql-type>DOUBLE</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Boolean</java-type>
            <jdbc-type>TINYINT</jdbc-type>
            <sql-type>TINYINT</sql-type>
         </mapping>
         <mapping>
            <java-type>java.math.BigDecimal</java-type>
            <jdbc-type>DOUBLE</jdbc-type>
            <sql-type>DOUBLE</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Object</java-type>
            <jdbc-type>BLOB</jdbc-type>
            <sql-type>LONGBLOB</sql-type>
            <!--
            | Change this from LONGBLOB to BLOB if you know your
            | serialized object will be <= 2^16 bytes
            -->
         </mapping>
         <mapping>
            <java-type>java.lang.Integer</java-type>
            <jdbc-type>INTEGER</jdbc-type>
            <sql-type>INTEGER</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Short</java-type>
            <jdbc-type>SMALLINT</jdbc-type>
            <sql-type>SMALLINT</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Timestamp</java-type>
            <jdbc-type>TIMESTAMP</jdbc-type>
            <sql-type>TIMESTAMP</sql-type>
            <!--
            | This type is problematical because mysql does not have any
            | date/time types that store milliseconds. You should avoid it.
            -->
         </mapping>
         <mapping>
            <java-type>java.lang.Byte</java-type>
            <jdbc-type>TINYINT</jdbc-type>
            <sql-type>TINYINT</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Character</java-type>
            <jdbc-type>CHAR</jdbc-type>
            <sql-type>CHAR</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Long</java-type>
            <jdbc-type>BIGINT</jdbc-type>
            <sql-type>BIGINT</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.String</java-type>
            <jdbc-type>VARCHAR</jdbc-type>
            <sql-type>VARCHAR(250) BINARY</sql-type>
         </mapping>
         <mapping>
            <java-type>java.util.Date</java-type>
            <jdbc-type>TIMESTAMP</jdbc-type>
            <sql-type>DATETIME</sql-type>
            <!--
            | Note that you lose granularity here
            | Use a numeric type and store milliseconds if you really need it
            -->
         </mapping>
         <mapping>
            <java-type>java.sql.Date</java-type>
            <jdbc-type>DATE</jdbc-type>
            <sql-type>DATETIME</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Time</java-type>
            <jdbc-type>TIME</jdbc-type>
            <sql-type>TIME</sql-type>
         </mapping>
      </type-mapping>

      <type-mapping>
         <name>MS SQLSERVER</name>
         <row-locking-template>SELECT ?1 FROM ?2 with (updlock) WHERE ?3 ORDER BY ?4</row-locking-template>
         <pk-constraint-template>CONSTRAINT ?1 PRIMARY KEY (?2)</pk-constraint-template>
         <fk-constraint-template>ALTER TABLE ?1 ADD CONSTRAINT ?2 FOREIGN KEY (?3) REFERENCES ?4 (?5)</fk-constraint-template>
         <auto-increment-template>?1 IDENTITY</auto-increment-template>
         <alter-column-template>ALTER TABLE ?1 ALTER COLUMN ?2 ?3</alter-column-template>
         <alias-header-prefix>t</alias-header-prefix>
         <alias-header-suffix>_</alias-header-suffix>
         <alias-max-length>32</alias-max-length>
         <subquery-supported>true</subquery-supported>
         <true-mapping>1</true-mapping>
         <false-mapping>0</false-mapping>

         <function-mapping>
            <function-name>concat</function-name>
            <function-sql>(?1 + ?2)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>substring</function-name>
            <function-sql>substring(?1, ?2, ?3)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>lcase</function-name>
            <function-sql>lower(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>length</function-name>
            <function-sql>len(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>locate</function-name>
            <function-sql>charindex(?1, ?2, ?3)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>abs</function-name>
            <function-sql>abs(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>sqrt</function-name>
            <function-sql>sqrt(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>ucase</function-name>
            <function-sql>upper(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>count</function-name>
            <function-sql>count(?1)</function-sql>
         </function-mapping>

         <mapping>
            <java-type>java.lang.Integer</java-type>
            <jdbc-type>INTEGER</jdbc-type>
            <sql-type>INTEGER</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Character</java-type>
            <jdbc-type>CHAR</jdbc-type>
            <sql-type>CHAR</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Short</java-type>
            <jdbc-type>SMALLINT</jdbc-type>
            <sql-type>SMALLINT</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Double</java-type>
            <jdbc-type>DOUBLE</jdbc-type>
            <sql-type>DOUBLE</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Long</java-type>
            <jdbc-type>DECIMAL</jdbc-type>
            <sql-type>DECIMAL(20)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.math.BigDecimal</java-type>
            <jdbc-type>VARCHAR</jdbc-type>
            <sql-type>VARCHAR(256)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.String</java-type>
            <jdbc-type>VARCHAR</jdbc-type>
            <sql-type>VARCHAR(256)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Object</java-type>
            <jdbc-type>JAVA_OBJECT</jdbc-type>
            <sql-type>IMAGE</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Byte</java-type>
            <jdbc-type>TINYINT</jdbc-type>
            <sql-type>TINYINT</sql-type>
         </mapping>
         <mapping>
            <!--
            | Note that you lose granularity here
            | Use a numeric type and store milliseconds if you really need it
            -->
            <java-type>java.sql.Timestamp</java-type>
            <jdbc-type>TIMESTAMP</jdbc-type>
            <sql-type>DATETIME</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Date</java-type>
            <jdbc-type>DATE</jdbc-type>
            <sql-type>DATETIME</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Time</java-type>
            <jdbc-type>TIME</jdbc-type>
            <sql-type>DATETIME</sql-type>
         </mapping>
         <mapping>
            <java-type>java.util.Date</java-type>
            <jdbc-type>TIMESTAMP</jdbc-type>
            <sql-type>DATETIME</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Boolean</java-type>
            <jdbc-type>BIT</jdbc-type>
            <sql-type>BIT</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Float</java-type>
            <jdbc-type>FLOAT</jdbc-type>
            <sql-type>FLOAT</sql-type>
         </mapping>
      </type-mapping>

      <type-mapping>
         <name>MS SQLSERVER2000</name>
         <!--
         | This type-mapping applies both to MS SQLSERVER 2000 and MS SQLSERVER 2005
         -->          
         <row-locking-template>SELECT ?1 FROM ?2 with (xlock) WHERE ?3 ORDER BY ?4</row-locking-template>
         <pk-constraint-template>CONSTRAINT ?1 PRIMARY KEY (?2)</pk-constraint-template>
         <fk-constraint-template>ALTER TABLE ?1 ADD CONSTRAINT ?2 FOREIGN KEY (?3) REFERENCES ?4 (?5)</fk-constraint-template>
         <auto-increment-template>?1 IDENTITY</auto-increment-template>
         <alias-header-prefix>t</alias-header-prefix>
         <alias-header-suffix>_</alias-header-suffix>
         <alias-max-length>32</alias-max-length>
         <subquery-supported>true</subquery-supported>
         <true-mapping>1</true-mapping>
         <false-mapping>0</false-mapping>

         <function-mapping>
            <function-name>concat</function-name>
            <function-sql>(?1 + ?2)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>substring</function-name>
            <function-sql>substring(?1, ?2, ?3)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>lcase</function-name>
            <function-sql>lower(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>length</function-name>
            <function-sql>len(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>locate</function-name>
            <function-sql>charindex(?1, ?2, ?3)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>abs</function-name>
            <function-sql>abs(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>sqrt</function-name>
            <function-sql>sqrt(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>ucase</function-name>
            <function-sql>upper(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>count</function-name>
            <function-sql>count(?1)</function-sql>
         </function-mapping>
         <function-mapping>
            <function-name>mod</function-name>
            <function-sql>(?1 % ?2)</function-sql>
         </function-mapping>
         
         <mapping>
            <java-type>java.lang.Integer</java-type>
            <jdbc-type>INTEGER</jdbc-type>
            <sql-type>INTEGER</sql-type>
         </mapping>

         <mapping>
            <java-type>java.lang.Character</java-type>
            <jdbc-type>CHAR</jdbc-type>
            <sql-type>CHAR</sql-type>
         </mapping>

         <mapping>
            <java-type>java.lang.Short</java-type>
            <jdbc-type>SMALLINT</jdbc-type>
            <sql-type>SMALLINT</sql-type>
         </mapping>

         <mapping>
            <java-type>java.lang.Long</java-type>
            <jdbc-type>BIGINT</jdbc-type>
            <sql-type>BIGINT</sql-type>
         </mapping>

         <mapping>
            <java-type>java.math.BigDecimal</java-type>
            <jdbc-type>VARCHAR</jdbc-type>
            <sql-type>VARCHAR(256)</sql-type>
         </mapping>

         <mapping>
            <java-type>java.lang.String</java-type>
            <jdbc-type>VARCHAR</jdbc-type>
            <sql-type>VARCHAR(256)</sql-type>
         </mapping>

         <mapping>
            <java-type>java.lang.Object</java-type>
            <jdbc-type>LONGVARBINARY</jdbc-type>
            <sql-type>IMAGE</sql-type>
         </mapping>

         <mapping>
            <java-type>java.lang.Byte</java-type>
            <jdbc-type>TINYINT</jdbc-type>
            <sql-type>TINYINT</sql-type>
         </mapping>

         <mapping>
            <!--
            | Note that you lose granularity here
            | Use a numeric type and store milliseconds if you really need it
            -->
            <java-type>java.sql.Timestamp</java-type>
            <jdbc-type>TIMESTAMP</jdbc-type>
            <sql-type>DATETIME</sql-type>
         </mapping>

         <mapping>
            <java-type>java.sql.Date</java-type>
            <jdbc-type>DATE</jdbc-type>
            <sql-type>DATETIME</sql-type>
         </mapping>

         <mapping>
            <java-type>java.sql.Time</java-type>
            <jdbc-type>TIME</jdbc-type>
            <sql-type>DATETIME</sql-type>
         </mapping>

         <mapping>
            <java-type>java.util.Date</java-type>
            <jdbc-type>TIMESTAMP</jdbc-type>
            <sql-type>DATETIME</sql-type>
         </mapping>

         <mapping>
            <java-type>java.lang.Boolean</java-type>
            <jdbc-type>BIT</jdbc-type>
            <sql-type>BIT</sql-type>
         </mapping>

         <mapping>
            <java-type>java.lang.Float</java-type>
            <jdbc-type>REAL</jdbc-type>
            <sql-type>REAL</sql-type>
         </mapping>

         <mapping>
            <java-type>java.lang.Double</java-type>
            <jdbc-type>DOUBLE</jdbc-type>
            <sql-type>FLOAT</sql-type>
         </mapping>
      </type-mapping>

      <type-mapping>
         <name>DB2/400</name>
         <row-locking-template/>
         <pk-constraint-template>CONSTRAINT ?1 PRIMARY KEY (?2)</pk-constraint-template>
         <fk-constraint-template>ALTER TABLE ?1 ADD CONSTRAINT ?2 FOREIGN KEY (?3) REFERENCES ?4 (?5)</fk-constraint-template>
         <alias-header-prefix>t</alias-header-prefix>
         <alias-header-suffix>_</alias-header-suffix>
         <alias-max-length>18</alias-max-length>
         <subquery-supported>true</subquery-supported>
         <true-mapping>1</true-mapping>
         <false-mapping>0</false-mapping>

         <function-mapping>
            <function-name>count</function-name>
            <function-sql>count(?1)</function-sql>
         </function-mapping>

         <mapping>
            <java-type>java.lang.Character</java-type>
            <jdbc-type>CHAR</jdbc-type>
            <sql-type>CHAR(1)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.String</java-type>
            <jdbc-type>VARCHAR</jdbc-type>
            <sql-type>VARCHAR(256)</sql-type>
         </mapping>
    <!-- Apparent DB2/400 doesn't handle Byte type either
         <mapping>
            <java-type>java.lang.Byte</java-type>
            <jdbc-type>CHAR</jdbc-type>
            <sql-type>CHAR(1) FOR BIT DATA</sql-type>
         </mapping>
    -->
         <mapping>
            <java-type>java.util.Date</java-type>
            <jdbc-type>TIMESTAMP</jdbc-type>
            <sql-type>TIMESTAMP</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Time</java-type>
            <jdbc-type>TIME</jdbc-type>
            <sql-type>TIME</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Float</java-type>
            <jdbc-type>FLOAT</jdbc-type>
            <sql-type>FLOAT</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Integer</java-type>
            <jdbc-type>INTEGER</jdbc-type>
            <sql-type>INTEGER</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Double</java-type>
            <jdbc-type>DOUBLE</jdbc-type>
            <sql-type>DOUBLE</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Long</java-type>
            <jdbc-type>BIGINT</jdbc-type>
            <sql-type>INTEGER</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Boolean</java-type>
            <jdbc-type>CHAR</jdbc-type>
            <sql-type>CHAR(5)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Short</java-type>
            <jdbc-type>SMALLINT</jdbc-type>
            <sql-type>SMALLINT</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Object</java-type>
            <jdbc-type>JAVA_OBJECT</jdbc-type>
            <sql-type>VARCHAR(4096) FOR BIT DATA</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Timestamp</java-type>
            <jdbc-type>TIMESTAMP</jdbc-type>
            <sql-type>TIMESTAMP</sql-type>
         </mapping>
      </type-mapping>

      <type-mapping>
         <name>SapDB</name>
         <!-- SapDB 7.3 might require '... UPDATE OF ?1' in the row-locking-template -->
         <!-- as is works with SapDB 7.4 -->
         <row-locking-template>SELECT ?1 FROM ?2 WHERE ?3 ORDER BY ?4 FOR UPDATE</row-locking-template>
         <pk-constraint-template>CONSTRAINT ?1 PRIMARY KEY (?2)</pk-constraint-template>
         <fk-constraint-template>ALTER TABLE ?1 ADD FOREIGN KEY ?2 (?3) REFERENCES ?4 (?5)</fk-constraint-template>
         <alias-header-prefix>t</alias-header-prefix>
         <alias-header-suffix>_</alias-header-suffix>
         <alias-max-length>32</alias-max-length>
         <subquery-supported>true</subquery-supported>
         <true-mapping>1</true-mapping>
         <false-mapping>0</false-mapping>

         <function-mapping>
            <function-name>count</function-name>
            <function-sql>count(?1)</function-sql>
         </function-mapping>

         <mapping>
            <java-type>java.lang.Integer</java-type>
            <jdbc-type>INTEGER</jdbc-type>
            <sql-type>INTEGER</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Character</java-type>
            <jdbc-type>CHAR</jdbc-type>
            <sql-type>CHAR</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.String</java-type>
            <jdbc-type>VARCHAR</jdbc-type>
            <sql-type>VARCHAR(256)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Object</java-type>
            <jdbc-type>JAVA_OBJECT</jdbc-type>
            <sql-type>LONG BYTE</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Byte</java-type>
            <jdbc-type>TINYINT</jdbc-type>
            <sql-type>CHAR BYTE</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Timestamp</java-type>
            <jdbc-type>TIMESTAMP</jdbc-type>
            <sql-type>TIMESTAMP</sql-type>
         </mapping>
         <mapping>
            <java-type>java.util.Date</java-type>
            <jdbc-type>TIMESTAMP</jdbc-type>
            <sql-type>TIMESTAMP</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Time</java-type>
            <jdbc-type>TIME</jdbc-type>
            <sql-type>TIME</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Boolean</java-type>
            <jdbc-type>BIT</jdbc-type>
            <sql-type>BOOLEAN</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Float</java-type>
            <jdbc-type>FLOAT</jdbc-type>
            <sql-type>FLOAT</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Short</java-type>
            <jdbc-type>SMALLINT</jdbc-type>
            <sql-type>SMALLINT</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Double</java-type>
            <jdbc-type>DOUBLE</jdbc-type>
            <sql-type>DOUBLE PRECISION</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Long</java-type>
            <jdbc-type>DECIMAL</jdbc-type>
            <sql-type>DECIMAL(20)</sql-type>
         </mapping>
      </type-mapping>

      <type-mapping>
         <name>MaxDB</name>
         <row-locking-template>SELECT ?1 FROM ?2 WHERE ?3 ORDER BY ?4 FOR UPDATE</row-locking-template>
         <pk-constraint-template>CONSTRAINT ?1 PRIMARY KEY (?2)</pk-constraint-template>
         <fk-constraint-template>ALTER TABLE ?1 ADD FOREIGN KEY ?2 (?3) REFERENCES ?4 (?5)</fk-constraint-template>
             <auto-increment-template>?1</auto-increment-template>
         <alias-header-prefix>t</alias-header-prefix>
         <alias-header-suffix>_</alias-header-suffix>
         <alias-max-length>32</alias-max-length>
         <subquery-supported>true</subquery-supported>
         <true-mapping>true</true-mapping>
         <false-mapping>false</false-mapping>

         <function-mapping>
            <function-name>count</function-name>
            <function-sql>count(?1)</function-sql>
         </function-mapping>

         <mapping>
            <java-type>java.lang.Integer</java-type>
            <jdbc-type>INTEGER</jdbc-type>
            <sql-type>INTEGER</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Character</java-type>
            <jdbc-type>CHAR</jdbc-type>
            <sql-type>CHAR</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.String</java-type>
            <jdbc-type>VARCHAR</jdbc-type>
            <sql-type>VARCHAR(256)</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Object</java-type>
            <jdbc-type>JAVA_OBJECT</jdbc-type>
            <sql-type>LONG BYTE</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Byte</java-type>
            <jdbc-type>TINYINT</jdbc-type>
            <sql-type>CHAR BYTE</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Timestamp</java-type>
            <jdbc-type>TIMESTAMP</jdbc-type>
            <sql-type>TIMESTAMP</sql-type>
         </mapping>
         <mapping>
            <java-type>java.util.Date</java-type>
            <jdbc-type>TIMESTAMP</jdbc-type>
            <sql-type>TIMESTAMP</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Time</java-type>
            <jdbc-type>TIME</jdbc-type>
            <sql-type>TIME</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Boolean</java-type>
            <jdbc-type>BOOLEAN</jdbc-type>
            <sql-type>BOOLEAN</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Float</java-type>
            <jdbc-type>FLOAT</jdbc-type>
            <sql-type>FLOAT</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Short</java-type>
            <jdbc-type>SMALLINT</jdbc-type>
            <sql-type>SMALLINT</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Double</java-type>
            <jdbc-type>DOUBLE</jdbc-type>
            <sql-type>DOUBLE PRECISION</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Long</java-type>
            <jdbc-type>DECIMAL</jdbc-type>
            <sql-type>DECIMAL(20)</sql-type>
         </mapping>
      </type-mapping>

      <type-mapping>
         <name>Cloudscape</name>
         <row-locking-template/>
         <pk-constraint-template>CONSTRAINT ?1 PRIMARY KEY (?2)</pk-constraint-template>
         <fk-constraint-template>ALTER TABLE ?1 ADD CONSTRAINT ?2 FOREIGN KEY (?3) REFERENCES ?4 (?5)</fk-constraint-template>
         <alias-header-prefix>t</alias-header-prefix>
         <alias-header-suffix>_</alias-header-suffix>
         <alias-max-length>32</alias-max-length>
         <subquery-supported>true</subquery-supported>
         <true-mapping>1</true-mapping>
         <false-mapping>0</false-mapping>

         <function-mapping>
            <function-name>count</function-name>
            <function-sql>count(?1)</function-sql>
         </function-mapping>

         <mapping>
            <java-type>java.math.BigDecimal</java-type>
            <jdbc-type>LONGVARCHAR</jdbc-type>
            <sql-type>LONG VARCHAR</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Boolean</java-type>
            <jdbc-type>BIT</jdbc-type>
            <sql-type>BOOLEAN</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Byte</java-type>
            <jdbc-type>TINYINT</jdbc-type>
            <sql-type>TINYINT</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Short</java-type>
            <jdbc-type>SMALLINT</jdbc-type>
            <sql-type>SMALLINT</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Integer</java-type>
            <jdbc-type>INTEGER</jdbc-type>
            <sql-type>INTEGER</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Long</java-type>
            <jdbc-type>BIGINT</jdbc-type>
            <sql-type>LONGINT</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Float</java-type>
            <jdbc-type>REAL</jdbc-type>
            <sql-type>REAL</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Double</java-type>
            <jdbc-type>DOUBLE</jdbc-type>
            <sql-type>DOUBLE PRECISION</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Character</java-type>
            <jdbc-type>CHAR</jdbc-type>
            <sql-type>CHAR</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.String</java-type>
            <jdbc-type>LONGVARCHAR</jdbc-type>
            <sql-type>LONG VARCHAR</sql-type>
         </mapping>
         <!-- NOTE: This alternative mapping has been suggested for cloudscape
         <mapping>
            <java-type>java.lang.String</java-type>
            <jdbc-type>VARCHAR</jdbc-type>
            <sql-type>VARCHAR(256)</sql-type>
         </mapping> -->
         <mapping>
            <java-type>java.sql.Date</java-type>
            <jdbc-type>DATE</jdbc-type>
            <sql-type>DATE</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Time</java-type>
            <jdbc-type>TIME</jdbc-type>
            <sql-type>TIME</sql-type>
         </mapping>
         <mapping>
            <java-type>java.sql.Timestamp</java-type>
            <jdbc-type>TIMESTAMP</jdbc-type>
            <sql-type>TIMESTAMP</sql-type>
         </mapping>
         <mapping>
            <java-type>java.lang.Object</java-type>
            <jdbc-type>JAVA_OBJECT</jdbc-type>
            <sql-type>LONG VARBINARY</sql-type>
         </mapping>
      </type-mapping>


      <type-mapping>
         <name>InformixDB</name>
         <row-locking-template>select ?1 from ?2 where ?3 order by ?4 for update</row-locking-template>
         <pk-constraint-template>PRIMARY KEY (?2) CONSTRAINT ?1</pk-constraint-template>
         <fk-constraint-template>ALTER TABLE ?1 ADD CONSTRAINT FOREIGN KEY (?3) REFERENCES ?4 (?5) CONSTRAINT ?2</fk-constraint-template>
         <auto-increment-template>?1 serial(1)</auto-increment-template>
         <alias-header-prefix>t</alias-header-prefix>
         <alias-header-suffix>_</alias-header-suffix>
         <alias-max-length>32</alias-max-length>
         <subquery-supported>true</subquery-supported>
         <true-mapping>1</true-mapping>
         <false-mapping>0</false-mapping>

         <function-mapping>
            <function-name>count</function-name>
            <function-sql>count(?1)</function-sql>
         </function-mapping>

         <mapping>
            <java-type>java.lang.Character</java-type>
            <jdbc-type>CHAR</jdbc-type>
            <sql-type>CHAR(1)</sql-type>
         </mapping>

         <mapping>
            <java-type>java.lang.String</java-type>
            <jdbc-type>VARCHAR</jdbc-type>
            <sql-type>VARCHAR(255,0)</sql-type>
         </mapping>

         <mapping>
            <java-type>java.math.BigDecimal</java-type>
            <jdbc-type>NUMERIC</jdbc-type>
            <sql-type>DECIMAL</sql-type>
         </mapping>

         <mapping>
            <java-type>java.lang.Boolean</java-type>
            <jdbc-type>BIT</jdbc-type>
            <sql-type>SMALLINT</sql-type>
         </mapping>

         <mapping>
            <java-type>java.lang.Integer</java-type>
            <jdbc-type>INTEGER</jdbc-type>
            <sql-type>INTEGER</sql-type>
         </mapping>

         <mapping>
            <java-type>java.lang.Long</java-type>
            <jdbc-type>BIGINT</jdbc-type>
            <sql-type>NUMERIC(18,0)</sql-type>
         </mapping>

         <mapping>
            <java-type>java.lang.Float</java-type>
            <jdbc-type>REAL</jdbc-type>
            <sql-type>FLOAT</sql-type>
         </mapping>

         <mapping>
            <java-type>java.lang.Double</java-type>
            <jdbc-type>DOUBLE</jdbc-type>
            <sql-type>DOUBLE PRECISION</sql-type>
         </mapping>

         <mapping>
            <java-type>java.lang.Byte</java-type>
            <jdbc-type>TINYINT</jdbc-type>
            <sql-type>SMALLINT</sql-type>
         </mapping>

         <mapping>
            <java-type>java.lang.Short</java-type>
            <jdbc-type>SMALLINT</jdbc-type>
            <sql-type>SMALLINT</sql-type>
         </mapping>

         <mapping>
            <java-type>java.util.Date</java-type>
            <jdbc-type>TIMESTAMP</jdbc-type>
            <sql-type>DATETIME YEAR TO FRACTION(3)</sql-type>
         </mapping>

         <mapping>
            <java-type>java.sql.Date</java-type>
            <jdbc-type>DATE</jdbc-type>
            <sql-type>DATE</sql-type>
         </mapping>

         <mapping>
            <java-type>java.sql.Time</java-type>
            <jdbc-type>TIME</jdbc-type>
            <sql-type>TIME</sql-type>
         </mapping>

         <mapping>
            <java-type>java.sql.Timestamp</java-type>
            <jdbc-type>TIMESTAMP</jdbc-type>
            <sql-type>DATETIME YEAR TO FRACTION(3)</sql-type>
         </mapping>

         <mapping>
            <java-type>java.lang.Object</java-type>
            <jdbc-type>BLOB</jdbc-type>
            <sql-type>BLOB</sql-type>
         </mapping>
      </type-mapping>

      <type-mapping>
          <name>Mimer SQL</name>
          <row-locking-template/>
          <pk-constraint-template>CONSTRAINT ?1 PRIMARY KEY (?2)</pk-constraint-template>
          <fk-constraint-template>ALTER TABLE ?1 ADD CONSTRAINT ?2 FOREIGN KEY (?3) REFERENCES ?4 (?5)</fk-constraint-template>
          <alias-header-prefix>t</alias-header-prefix>
          <alias-header-suffix>_</alias-header-suffix>
          <alias-max-length>32</alias-max-length>
          <subquery-supported>true</subquery-supported>
          <true-mapping>1</true-mapping>
          <false-mapping>0</false-mapping>

          <mapping>
             <java-type>java.lang.Boolean</java-type>
             <jdbc-type>BIT</jdbc-type>
             <sql-type>SMALLINT</sql-type>
          </mapping>

          <mapping>
             <java-type>java.lang.Byte</java-type>
             <jdbc-type>TINYINT</jdbc-type>
             <sql-type>SMALLINT</sql-type>
          </mapping>

          <mapping>
             <java-type>java.lang.Short</java-type>
             <jdbc-type>SMALLINT</jdbc-type>
             <sql-type>SMALLINT</sql-type>
          </mapping>

          <mapping>
             <java-type>java.lang.Integer</java-type>
             <jdbc-type>INTEGER</jdbc-type>
             <sql-type>INTEGER</sql-type>
          </mapping>

          <mapping>
             <java-type>java.lang.Long</java-type>
             <jdbc-type>BIGINT</jdbc-type>
             <sql-type>BIGINT</sql-type>
          </mapping>

          <mapping>
             <java-type>java.lang.Float</java-type>
             <jdbc-type>REAL</jdbc-type>
             <sql-type>REAL</sql-type>
          </mapping>

          <mapping>
             <java-type>java.lang.Double</java-type>
             <jdbc-type>DOUBLE</jdbc-type>
             <sql-type>DOUBLE PRECISION</sql-type>
          </mapping>

          <mapping>
             <java-type>java.lang.Character</java-type>
             <jdbc-type>CHAR</jdbc-type>
             <sql-type>CHAR</sql-type>
          </mapping>

          <mapping>
             <java-type>java.lang.String</java-type>
             <jdbc-type>VARCHAR</jdbc-type>
             <sql-type>VARCHAR(5000)</sql-type>
          </mapping>

          <mapping>
             <java-type>java.sql.Date</java-type>
             <jdbc-type>DATE</jdbc-type>
             <sql-type>DATE</sql-type>
          </mapping>

          <mapping>
             <java-type>java.sql.Time</java-type>
             <jdbc-type>TIME</jdbc-type>
             <sql-type>TIME</sql-type>
          </mapping>

          <mapping>
             <java-type>java.sql.Timestamp</java-type>
             <jdbc-type>TIMESTAMP</jdbc-type>
             <sql-type>TIMESTAMP</sql-type>
          </mapping>

          <mapping>
             <java-type>java.lang.Object</java-type>
             <jdbc-type>JAVA_OBJECT</jdbc-type>
             <sql-type>VARBINARY(5000)</sql-type>
          </mapping>
       </type-mapping>
   </type-mappings>

   <entity-commands>
      <!-- default command; doesn't support unknown-pk -->
      <entity-command name="default"
                      class="org.jboss.ejb.plugins.cmp.jdbc.JDBCCreateEntityCommand"/>

      <!-- variation on default that skips select before insert -->
      <entity-command name="no-select-before-insert"
                      class="org.jboss.ejb.plugins.cmp.jdbc.JDBCCreateEntityCommand">
         <attribute name="SQLExceptionProcessor">jboss.jdbc:service=SQLExceptionProcessor</attribute>
      </entity-command>

      <!-- fetches next key value with the specified sql statement -->
      <entity-command name="pk-sql"
                      class="org.jboss.ejb.plugins.cmp.jdbc.keygen.JDBCPkSqlCreateCommand">
         <!-- change to define SQL used to obtain key prior to insert -->
         <attribute name="pk-sql">SELECT CURRENT_TIMESTAMP</attribute>
      </entity-command>

      <!-- this command requires auto-increment element for unknown-pk -->
      <entity-command name="mysql-get-generated-keys"
                      class="org.jboss.ejb.plugins.cmp.jdbc.keygen.JDBCMySQLCreateCommand">
         <!-- uncomment in case of XADataSource <attribute name="class-name">com.mysql.jdbc.jdbc2.optional.PreparedStatementWrapper</attribute>  -->
      </entity-command>

      <!-- this command requires the specified sequence to have been created -->
      <entity-command name="oracle-sequence"
                      class="org.jboss.ejb.plugins.cmp.jdbc.keygen.JDBCOracleCreateCommand">
         <attribute name="sequence">TEST_SEQUENCE</attribute>
      </entity-command>

      <!-- this command makes the use of a specific sequence for each table -->
      <entity-command name="oracle-table-sequence"
                      class="org.jboss.ejb.plugins.cmp.jdbc.keygen.JDBCOracleSequenceCreateCommand">
         <attribute name="sequence_name">%%t_seq</attribute>
      </entity-command>

      <!-- retrieves generated key of the record inserted into hsql db -->
      <entity-command name="hsqldb-fetch-key"
                      class="org.jboss.ejb.plugins.cmp.jdbc.keygen.JDBCHsqldbCreateCommand">
         <!-- uncomment to change SQL statement used to obtain identity
         <attribute name="pk-sql">CALL IDENTITY()</attribute>
         -->
      </entity-command>

      <!-- retrieves generated key of the record inserted into sybase db -->
      <entity-command name="sybase-fetch-key"
                      class="org.jboss.ejb.plugins.cmp.jdbc.keygen.JDBCSybaseCreateCommand"/>

      <!-- retrieves generated key of the record inserted into SQLServer db -->
      <entity-command name="mssql-fetch-key"
                      class="org.jboss.ejb.plugins.cmp.jdbc.keygen.JDBCSQLServerCreateCommand">
         <!-- uncomment for versions prior to SQL Server 2000
         <attribute name="pk-sql">SELECT @@IDENTITY</attribute>
         -->
      </entity-command>

      <!-- retrieves serial value of the record inserted into informix db -->
      <entity-command name="informix-serial"
                      class="org.jboss.ejb.plugins.cmp.jdbc.keygen.JDBCInformixCreateCommand">
         <!-- uncomment to use with SERIAL8 column
         <attribute name="method">getSerial8</attribute>
         -->
      </entity-command>

      <!-- retrieves the currval of the the sequence associated with a PostgreSQL SERIAL column -->
      <entity-command name="postgresql-fetch-seq"
                      class="org.jboss.ejb.plugins.cmp.jdbc.keygen.JDBCPostgreSQLCreateCommand">
         <!-- uncomment to change the name of the sequence; default is ${table}_${pkColumn}_seq
         <attribute name="sequence"></attribute>
         -->
      </entity-command>

      <!-- uses key generator to fetch the next key value -->
      <entity-command name="key-generator"
                      class="org.jboss.ejb.plugins.cmp.jdbc.keygen.JDBCKeyGeneratorCreateCommand">
         <attribute name="key-generator-factory">UUIDKeyGeneratorFactory</attribute>
      </entity-command>

      <!-- uses JDBC 3.0 getGeneratedKeys() method -->
      <entity-command name="get-generated-keys"
                      class="org.jboss.ejb.plugins.cmp.jdbc.keygen.JDBC30GeneratedKeysCreateCommand"/>

      <!-- pk-sql for jdbc2 pm -->
      <entity-command name="jdbc2pm-pk-sql"
                      class="org.jboss.ejb.plugins.cmp.jdbc2.PkSqlCreateCommand">
         <!-- change to define SQL used to obtain key prior to insert -->
         <attribute name="pk-sql">SELECT CURRENT_TIMESTAMP</attribute>
      </entity-command>

      <!-- retrieves generated key of the record inserted into hsql db for jdbc2 pm -->
      <entity-command name="jdbc2pm-hsqldb-fetch-key"
                      class="org.jboss.ejb.plugins.cmp.jdbc2.keygen.HsqldbCreateCommand">
         <!-- uncomment to change SQL statement used to obtain identity
         <attribute name="pk-sql">CALL IDENTITY()</attribute>
         -->
      </entity-command>

      <!-- retrieves the currval of the the sequence associated with a PostgreSQL SERIAL column for jdbc2 pm -->
      <entity-command name="jdbc2pm-postgresql-fetch-seq"
                      class="org.jboss.ejb.plugins.cmp.jdbc2.keygen.PostgreSQLCreateCommand">
         <!-- uncomment to change the name of the sequence; default is ${table}_${pkColumn}_seq
         <attribute name="sequence"></attribute>
         -->
      </entity-command>
   </entity-commands>

   <!-- reserved words that should not be used as table names -->
   <!-- JBoss will escape them by prepending a 'X' -->
   <reserved-words>
      	<word>alias</word>   	
      	<word>alter</word>
      	<word>between</word>
      	<word>char</word>      	
      	<word>column</word>      	
      	<word>commit</word>
      	<word>create</word>
      	<word>date</word>
      	<word>default</word>
      	<word>delete</word>
      	<word>drop</word>
      	<word>file</word>
      	<word>from</word>
      	<word>grant</word>
      	<word>group</word>
      	<word>index</word>
      	<word>integer</word>
      	<word>join</word>
      	<word>number</word>
      	<word>on</word>
      	<word>order</word>
      	<word>primary</word>
      	<word>public</word>
      	<word>revoke</word>
      	<word>rollback</word>
      	<word>row</word>
      	<word>select</word>
      	<word>set</word>
      	<word>session</word>
      	<word>size</word>      	
      	<word>table</word>
      	<word>trigger</word>
      	<word>update</word>
      	<word>unique</word>
      	<word>user</word>
      	<word>varchar</word>
      	<word>view</word>
    </reserved-words>
</jbosscmp-jdbc>
