2008-11-11 06:54:09 +07:00
<?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 63355 2007 - 06 - 05 17:25:20Z rrajesh $ -->
<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>
<!--
| This type-mapping applies to DB2 V7.2 and V8.0
-->
<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>
<!--
| This type-mapping applies both to Oracle 9i and Oracle 10g
| Make sure that you have the latest Oracle 10g version of ojdbc14.jar
-->
<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>
<!--
| This type-mapping applies to PostgreSQL V8.0 and V8.1
-->
<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>
<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"/>
<!-- 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>
