6 Replies Latest reply on May 27, 2004 4:12 AM by alastairbrown

    Error compiling EJB-QL statement NoSuchMethodError

    alastairbrown Newbie

      JBoss 3.2.3

      Help! Using HSQLDB datasource (seesm to be working as previous operation updates the database sucessfully). HAve seen similar post that suggests it might work with 3.0.2. Any ideas most welcome!


      14:47:43,819 ERROR [EntityContainer] Starting failed
      org.jboss.deployment.DeploymentException: Error compiling EJB-QL statement 'SELECT OBJECT(d) FROM Blah d where d.blahcol= ?1'; - nested throwable: (java.lang.NoSuchMethodError)
      at org.jboss.ejb.plugins.cmp.jdbc.JDBCEJBQLQuery.(JDBCEJBQLQuery.java:50)
      at org.jboss.ejb.plugins.cmp.jdbc.JDBCCommandFactory.createEJBQLQuery(JDBCCommandFactory.java:59)
      at org.jboss.ejb.plugins.cmp.jdbc.JDBCQueryManager.start(JDBCQueryManager.java:212)
      at org.jboss.ejb.plugins.cmp.jdbc.JDBCStoreManager.startStoreManager(JDBCStoreManager.java:490)
      at org.jboss.ejb.plugins.cmp.jdbc.JDBCStoreManager.start(JDBCStoreManager.java:388)
      at org.jboss.ejb.plugins.CMPPersistenceManager.start(CMPPersistenceManager.java:152)
      at org.jboss.ejb.EntityContainer.startService(EntityContainer.java:342)
      at org.jboss.system.ServiceMBeanSupport.start(ServiceMBeanSupport.java:192)
      at java.lang.reflect.Method.invoke(Native Method)
      at org.jboss.mx.capability.ReflectedMBeanDispatcher.invoke(ReflectedMBeanDispatcher.java:284)
      at org.jboss.mx.server.MBeanServerImpl.invoke(MBeanServerImpl.java:546)
      at org.jboss.system.ServiceController$ServiceProxy.invoke(ServiceController.java:976)
      at $Proxy14.start(Unknown Source)
      at org.jboss.system.ServiceController.start(ServiceController.java:394)
      at java.lang.reflect.Method.invoke(Native Method)
      at org.jboss.mx.capability.ReflectedMBeanDispatcher.invoke(ReflectedMBeanDispatcher.java:284)
      at org.jboss.mx.server.MBeanServerImpl.invoke(MBeanServerImpl.java:546)
      at org.jboss.mx.util.MBeanProxyExt.invoke(MBeanProxyExt.java:177)
      at $Proxy40.start(Unknown Source)

        • 1. Re: Error compiling EJB-QL statement NoSuchMethodError
          ironbird Newbie

          Post your descriptors (ejb-jar.xml and jbosscmp-jdbc.xml)

          • 2. Re: Error compiling EJB-QL statement NoSuchMethodError
            alastairbrown Newbie

            ejb-jar.xml excerpt


            <query-method>
            <method-name>findByBatchId</method-name>
            <method-params>
            <method-param>java.lang.String</method-param>
            </method-params>
            </query-method>
            <ejb-ql><![CDATA[SELECT OBJECT(d) FROM Blah where d.blahcol= ?1]]></ejb-ql>

            • 3. Re: Error compiling EJB-QL statement NoSuchMethodError
              alastairbrown Newbie

              oops finger slip

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

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

              <!-- $Id: standardjbosscmp-jdbc.xml,v 1.39.2.34 2003/11/25 01:48:16 ejort Exp $ -->

              <jbosscmp-jdbc>


              java:/DefaultDS
              <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>
              on-load
              <page-size>1000</page-size>
              <eager-load-group>*</eager-load-group>
              </read-ahead>
              <list-cache-max>1000</list-cache-max>

              <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"/>



              <type-mappings>
              <type-mapping>
              FirstSQL/J
              <row-locking-template/>
              <pk-constraint-template>PRIMARY KEY (?1)</pk-constraint-template>
              <fk-constraint-template>FOREIGN KEY (?1) REFERENCES ?2 (?3)</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>


              <java-type>java.lang.Boolean</java-type>
              <jdbc-type>TINYINT</jdbc-type>
              <sql-type>TINYINT</sql-type>


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


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


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


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


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


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


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


              <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>


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


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


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


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


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


              <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>

              </type-mapping>

              <type-mapping>
              Ingres
              <row-locking-template>SELECT ?1 FROM ?2 WHERE ?3 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 -->

              <java-type>java.lang.Boolean</java-type>
              <jdbc-type>INTEGER</jdbc-type>
              <sql-type>INTEGER</sql-type>


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


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


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


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


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


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


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


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


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


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


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


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


              <java-type>java.math.BigDecimal</java-type>
              <jdbc-type>DOUBLE</jdbc-type>
              <sql-type>FLOAT8</sql-type>

              <!--
              Mapping proposed by Computer Associates, but does not work with JBoss properly
              28.03.2003 hou

              <java-type>java.math.BigDecimal</java-type>
              <jdbc-type>NUMERIC</jdbc-type>
              <sql-type>DECIMAL(24,6)</sql-type>

              -->

              <java-type>java.lang.Object</java-type>
              <jdbc-type>JAVA_OBJECT</jdbc-type>
              <sql-type>LONG VARCHAR</sql-type>

              </type-mapping>
              <type-mapping>
              McKoi
              <row-locking-template>SELECT ?1 FROM ?2 WHERE ?3 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>


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


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


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


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


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


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


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


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


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


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


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


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


              <java-type>java.lang.Object</java-type>
              <jdbc-type>JAVA_OBJECT</jdbc-type>
              <sql-type>JAVA_OBJECT</sql-type>

              </type-mapping>

              <type-mapping>
              Firebird
              <!-- For use with the Firebirdsql jca-jdbc driver.
              A version after Beta 1 is strongly recommended,
              this may involve building from cvs -->
              <row-locking-template>SELECT ?1 FROM ?2 WHERE ?3 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>1</true-mapping>
              <false-mapping>0</false-mapping>

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


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


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


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


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


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


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


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


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


              <!-- 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>


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


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


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


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

              </type-mapping>

              <type-mapping>
              InterBase
              <row-locking-template>SELECT ?1 FROM ?2 WHERE ?3 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>1</true-mapping>
              <false-mapping>0</false-mapping>

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


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


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


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


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


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


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


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


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


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


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


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


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


              <java-type>java.lang.Object</java-type>
              <jdbc-type>JAVA_OBJECT</jdbc-type>
              <sql-type>VARCHAR(2000)</sql-type>

              </type-mapping>

              <type-mapping>
              DB2
              <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>


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

              <!-- DB2 does not appear to support columns of type "byte"
              Regrettably, this means they'll be serialized.

              <java-type>java.lang.Byte</java-type>
              <jdbc-type>CHAR</jdbc-type>
              <sql-type>CHAR(1) FOR BIT DATA</sql-type>

              -->

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


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


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


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


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


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


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


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


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


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


              <java-type>java.lang.Object</java-type>
              <jdbc-type>JAVA_OBJECT</jdbc-type>
              <sql-type>BLOB(2000)</sql-type>

              </type-mapping>

              <type-mapping>
              Oracle9i
              <!--
              | 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 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>


              <java-type>java.lang.Boolean</java-type>
              <jdbc-type>BIT</jdbc-type>
              <sql-type>NUMBER(1)</sql-type>


              <java-type>java.lang.Byte</java-type>
              <jdbc-type>SMALLINT</jdbc-type>
              <sql-type>NUMBER(3)</sql-type>


              <java-type>java.lang.Short</java-type>
              <jdbc-type>NUMERIC</jdbc-type>
              <sql-type>NUMBER(5)</sql-type>


              <java-type>java.lang.Integer</java-type>
              <jdbc-type>INTEGER</jdbc-type>
              <sql-type>NUMBER(10)</sql-type>


              <java-type>java.lang.Long</java-type>
              <jdbc-type>BIGINT</jdbc-type>
              <sql-type>NUMBER(19)</sql-type>


              <java-type>java.lang.Float</java-type>
              <jdbc-type>REAL</jdbc-type>
              <sql-type>NUMBER(38,7)</sql-type>


              <java-type>java.math.BigDecimal</java-type>
              <jdbc-type>DECIMAL</jdbc-type>
              <sql-type>NUMBER(38,15)</sql-type>


              <java-type>java.lang.Double</java-type>
              <jdbc-type>DOUBLE</jdbc-type>
              <sql-type>NUMBER(38,15)</sql-type>


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


              <java-type>java.lang.String</java-type>
              <jdbc-type>VARCHAR</jdbc-type>
              <sql-type>VARCHAR2(255)</sql-type>


              <java-type>java.util.Date</java-type>
              <jdbc-type>TIMESTAMP</jdbc-type>
              <sql-type>TIMESTAMP(3)</sql-type>


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


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


              <java-type>java.sql.Timestamp</java-type>
              <jdbc-type>TIMESTAMP</jdbc-type>
              <sql-type>TIMESTAMP(9)</sql-type>


              <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
              -->

              </type-mapping>

              <type-mapping>
              Oracle8
              <row-locking-template>SELECT ?1 FROM ?2 WHERE ?3 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>


              <java-type>java.lang.Boolean</java-type>
              <jdbc-type>BIT</jdbc-type>
              <sql-type>NUMBER(1)</sql-type>


              <java-type>java.lang.Byte</java-type>
              <jdbc-type>NUMERIC</jdbc-type>
              <sql-type>NUMBER(3)</sql-type>


              <java-type>java.lang.Short</java-type>
              <jdbc-type>NUMERIC</jdbc-type>
              <sql-type>NUMBER(5)</sql-type>


              <java-type>java.lang.Integer</java-type>
              <jdbc-type>INTEGER</jdbc-type>
              <sql-type>NUMBER(10)</sql-type>


              <java-type>java.lang.Long</java-type>
              <jdbc-type>BIGINT</jdbc-type>
              <sql-type>NUMBER(19)</sql-type>


              <java-type>java.lang.Float</java-type>
              <jdbc-type>REAL</jdbc-type>
              <sql-type>NUMBER(38,7)</sql-type>


              <java-type>java.math.BigDecimal</java-type>
              <jdbc-type>DECIMAL</jdbc-type>
              <sql-type>NUMBER(38,15)</sql-type>


              <java-type>java.lang.Double</java-type>
              <jdbc-type>DOUBLE</jdbc-type>
              <sql-type>NUMBER(38,15)</sql-type>


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


              <java-type>java.lang.String</java-type>
              <jdbc-type>VARCHAR</jdbc-type>
              <sql-type>VARCHAR2(255)</sql-type>


              <!--
              | 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>


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


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


              <!--
              | 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>


              <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
              -->

              </type-mapping>

              <type-mapping>
              Oracle7
              <row-locking-template>SELECT ?1 FROM ?2 WHERE ?3 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>


              <java-type>java.lang.Boolean</java-type>
              <jdbc-type>BIT</jdbc-type>
              <sql-type>NUMBER(1)</sql-type>


              <java-type>java.lang.Byte</java-type>
              <jdbc-type>NUMERIC</jdbc-type>
              <sql-type>NUMBER(3)</sql-type>


              <java-type>java.lang.Short</java-type>
              <jdbc-type>NUMERIC</jdbc-type>
              <sql-type>NUMBER(5)</sql-type>


              <java-type>java.lang.Integer</java-type>
              <jdbc-type>INTEGER</jdbc-type>
              <sql-type>NUMBER(10)</sql-type>


              <java-type>java.lang.Long</java-type>
              <jdbc-type>BIGINT</jdbc-type>
              <sql-type>NUMBER(19)</sql-type>


              <java-type>java.lang.Float</java-type>
              <jdbc-type>REAL</jdbc-type>
              <sql-type>NUMBER(38,7)</sql-type>


              <java-type>java.lang.Double</java-type>
              <jdbc-type>DOUBLE</jdbc-type>
              <sql-type>NUMBER(38,15)</sql-type>


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


              <java-type>java.lang.String</java-type>
              <jdbc-type>VARCHAR</jdbc-type>
              <sql-type>VARCHAR2(255)</sql-type>


              <!--
              | 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>


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


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


              <!--
              | 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>


              <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
              -->

              </type-mapping>

              <type-mapping>
              Sybase
              <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>
              <function-mapping>
              <function-name>length</function-name>
              <function-sql>char_length(?1)</function-sql>
              </function-mapping>


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

              <!-- Current Sybase JDBC drivers (jConnect 5.2) don't support
              byte or short. Unfortunately they'll be serialized.

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


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

              -->

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


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


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


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


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


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


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


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


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


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

              </type-mapping>

              <type-mapping>
              PostgreSQL
              <row-locking-template>SELECT ?1 FROM ?2 WHERE ?3 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>


              <java-type>java.lang.Boolean</java-type>
              <jdbc-type>CHAR</jdbc-type>
              <sql-type>BOOLEAN</sql-type>


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


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


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


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


              <java-type>java.lang.Float</java-type>
              <jdbc-type>FLOAT</jdbc-type>
              <sql-type>FLOAT(7)</sql-type>


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


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


              <java-type>java.lang.String</java-type>
              <jdbc-type>VARCHAR</jdbc-type>
              <sql-type>TEXT</sql-type>


              <java-type>java.util.Date</java-type>
              <jdbc-type>TIMESTAMP</jdbc-type>
              <sql-type>TIMESTAMP with time zone</sql-type>


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


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


              <java-type>java.sql.Timestamp</java-type>
              <jdbc-type>TIMESTAMP</jdbc-type>
              <sql-type>TIMESTAMP with time zone</sql-type>


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


              <java-type>java.lang.Object</java-type>
              <jdbc-type>VARBINARY</jdbc-type>
              <sql-type>BYTEA</sql-type>

              </type-mapping>

              <type-mapping>
              PostgreSQL 7.2
              <row-locking-template>SELECT ?1 FROM ?2 WHERE ?3 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>


              <java-type>java.lang.Boolean</java-type>
              <jdbc-type>CHAR</jdbc-type>
              <sql-type>BOOLEAN</sql-type>


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


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


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


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


              <java-type>java.lang.Float</java-type>
              <jdbc-type>FLOAT</jdbc-type>
              <sql-type>FLOAT(7)</sql-type>


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


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


              <java-type>java.lang.String</java-type>
              <jdbc-type>VARCHAR</jdbc-type>
              <sql-type>TEXT</sql-type>


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


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


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


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


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


              <java-type>java.lang.Object</java-type>
              <jdbc-type>VARBINARY</jdbc-type>
              <sql-type>BYTEA</sql-type>

              </type-mapping>

              <type-mapping>
              Hypersonic SQL
              <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=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>


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


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


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


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


              <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>


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


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


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


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


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


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


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


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


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


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

              </type-mapping>

              <type-mapping>
              PointBase
              <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>


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


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


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


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


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


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


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


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


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


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

              </type-mapping>

              <type-mapping>
              SOLID
              <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>


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


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


              <java-type>java.lang.Short</java-type>
              <jdbc-type>INTEGER</jdbc-type>
              <sql-type>INTEGER</sql-type>


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


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


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


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


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


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


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


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


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

              </type-mapping>

              <type-mapping>
              mySQL
              <row-locking-template>SELECT ?1 FROM ?2 WHERE ?3 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)

              • 4. Re: Error compiling EJB-QL statement NoSuchMethodError
                ironbird Newbie

                Post the whole entity declaration (fields) from ejb-jar and I don't understand the remainder:
                I don't give a shit about standardjbosscmp-jdbc.xml, its a system file !
                I ask you jbosscmp-jdbc.xml.

                • 5. Re: Error compiling EJB-QL statement NoSuchMethodError
                  Alexey Loubyansky Master

                  You are probably running JBoss compiled with j2sdk1.4.x under jdk1.3.1

                  • 6. Re: Error compiling EJB-QL statement NoSuchMethodError
                    alastairbrown Newbie

                    Yep, Thanks thats the problem!