db-ojb-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From arm...@apache.org
Subject svn commit: r422225 [1/2] - in /db/ojb/trunk/src: java/org/apache/ojb/broker/ java/org/apache/ojb/broker/accesslayer/ java/org/apache/ojb/broker/accesslayer/conversions/ java/org/apache/ojb/broker/metadata/ java/org/apache/ojb/broker/metadata/fieldacce...
Date Sat, 15 Jul 2006 14:09:48 GMT
Author: arminw
Date: Sat Jul 15 07:09:47 2006
New Revision: 422225

URL: http://svn.apache.org/viewvc?rev=422225&view=rev
Log:
merge trunk with 1.0.x

Added:
    db/ojb/trunk/src/java/org/apache/ojb/broker/TransientObjectException.java
    db/ojb/trunk/src/java/org/apache/ojb/broker/accesslayer/NullCheck.java
    db/ojb/trunk/src/java/org/apache/ojb/broker/accesslayer/NullCheckDefaultImpl.java
    db/ojb/trunk/src/java/org/apache/ojb/broker/accesslayer/NullCheckRelaxedImpl.java
    db/ojb/trunk/src/java/org/apache/ojb/broker/accesslayer/conversions/AbstractList2VarcharConversion.java
    db/ojb/trunk/src/java/org/apache/ojb/broker/metadata/ConversionHelper.java
    db/ojb/trunk/src/java/org/apache/ojb/broker/metadata/FieldTypes.java
    db/ojb/trunk/src/java/org/apache/ojb/broker/metadata/JdbcTypes.java
    db/ojb/trunk/src/java/org/apache/ojb/broker/metadata/fieldaccess/PersistentFieldCGLibImpl.java
    db/ojb/trunk/src/java/org/apache/ojb/broker/util/GUIDFactory.java
    db/ojb/trunk/src/java/org/apache/ojb/broker/util/ReaderInputStream.java
    db/ojb/trunk/src/java/org/apache/ojb/broker/util/UnwrapHelper.java
    db/ojb/trunk/src/java/org/apache/ojb/broker/util/sequence/SequenceManagerTransientImpl.java
    db/ojb/trunk/src/java/org/apache/ojb/odmg/Image.java
    db/ojb/trunk/src/test/org/apache/ojb/Test_Repository_Renamed_DTD.xml
    db/ojb/trunk/src/test/org/apache/ojb/broker/JdbcJavaObjectTest.java
    db/ojb/trunk/src/test/org/apache/ojb/broker/UnwrapHelperTest.java
    db/ojb/trunk/src/test/org/apache/ojb/performance/PerfRunner.java

Added: db/ojb/trunk/src/java/org/apache/ojb/broker/TransientObjectException.java
URL: http://svn.apache.org/viewvc/db/ojb/trunk/src/java/org/apache/ojb/broker/TransientObjectException.java?rev=422225&view=auto
==============================================================================
--- db/ojb/trunk/src/java/org/apache/ojb/broker/TransientObjectException.java (added)
+++ db/ojb/trunk/src/java/org/apache/ojb/broker/TransientObjectException.java Sat Jul 15 07:09:47 2006
@@ -0,0 +1,45 @@
+package org.apache.ojb.broker;
+
+/* Copyright 2002-2004 The Apache Software Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import java.lang.Object;
+
+/**
+ * This exception signals a problem with a transient object.
+ *
+ * @version $Id: $
+ */
+public class TransientObjectException extends OJBException
+{
+    public TransientObjectException()
+    {
+    }
+
+    public TransientObjectException(String msg)
+    {
+        super(msg);
+    }
+
+    public TransientObjectException(Throwable cause)
+    {
+        super(cause);
+    }
+
+    public TransientObjectException(String msg, Throwable cause)
+    {
+        super(msg, cause);
+    }
+}

Added: db/ojb/trunk/src/java/org/apache/ojb/broker/accesslayer/NullCheck.java
URL: http://svn.apache.org/viewvc/db/ojb/trunk/src/java/org/apache/ojb/broker/accesslayer/NullCheck.java?rev=422225&view=auto
==============================================================================
--- db/ojb/trunk/src/java/org/apache/ojb/broker/accesslayer/NullCheck.java (added)
+++ db/ojb/trunk/src/java/org/apache/ojb/broker/accesslayer/NullCheck.java Sat Jul 15 07:09:47 2006
@@ -0,0 +1,46 @@
+package org.apache.ojb.broker.accesslayer;
+
+/* Copyright 2002-2006 The Apache Software Foundation
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+import java.io.Serializable;
+
+import org.apache.ojb.broker.metadata.FieldDescriptor;
+
+/**
+ * Declares the protocol for checking if a persistent field's value
+ * represents a 'null' value.
+ * <p>
+ * Used (among other things) for:
+ *  <ul>
+ *   <li>determining if auto-numbering should grab a new sequence id
+ *   <li>checking if a DELETE operation is allowed (all PK-fields must not be null)
+ *   <li>checking if identity handling has enough data (all PK-fields must not be null)
+ *  </ul>
+ * 
+ * @version $Id: NullCheck.java 411859 2006-06-05 17:04:13Z mkalen $
+ * @since OJB 1.0.5
+ */
+public interface NullCheck extends Serializable {
+
+    /**
+     * Returns wether the given object value represents 'null' for the specified field.
+     * @param fld descriptor representation of the persistent field
+     * @param aValue the value to check if it represents 'null' 
+     * @return true if and only if aValue represents null
+     */
+	boolean representsNull(FieldDescriptor fld, Object aValue);
+
+}

Added: db/ojb/trunk/src/java/org/apache/ojb/broker/accesslayer/NullCheckDefaultImpl.java
URL: http://svn.apache.org/viewvc/db/ojb/trunk/src/java/org/apache/ojb/broker/accesslayer/NullCheckDefaultImpl.java?rev=422225&view=auto
==============================================================================
--- db/ojb/trunk/src/java/org/apache/ojb/broker/accesslayer/NullCheckDefaultImpl.java (added)
+++ db/ojb/trunk/src/java/org/apache/ojb/broker/accesslayer/NullCheckDefaultImpl.java Sat Jul 15 07:09:47 2006
@@ -0,0 +1,75 @@
+package org.apache.ojb.broker.accesslayer;
+
+import org.apache.ojb.broker.metadata.FieldDescriptor;
+
+/* Copyright 2002-2006 The Apache Software Foundation
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+/**
+ * Default implementation of NullCheck.
+ * 
+ * @version $Id: NullCheckDefaultImpl.java 411859 2006-06-05 17:04:13Z mkalen $
+ * @since OJB 1.0.5
+ * @see org.apache.ojb.broker.accesslayer.NullCheckRelaxedImpl
+ */
+public class NullCheckDefaultImpl implements NullCheck
+{
+
+	private static final long serialVersionUID = -3434296237352411888L;
+
+	/**
+     * Returns wether the given object value represents 'null' for the specified field.
+     * <p>
+     * Null is defined as:
+     *  <ul>
+     *   <li>given value is 'null' itself
+     *   <li>given value is instance of Number with value 0 and the field-descriptor
+     *			represents a primitive field
+     *   <li>given value is instance of String with length 0 and the field-descriptor
+     * 			is a primary key
+     *  </ul>
+     * @param fld descriptor representation of the persistent field
+     * @param aValue the value to check if it represents 'null' 
+     * @return true if and only if aValue represents null
+     */
+	public boolean representsNull(FieldDescriptor fld, Object aValue)
+	{
+        if (aValue == null) return true;
+
+        boolean result = false;
+        if (((aValue instanceof Number) && (((Number) aValue).longValue() == 0)))
+        {
+            Class type = fld.getPersistentField().getType();
+            /*
+            AnonymousPersistentFields will *always* have a null type according to the
+            javadoc comments in AnonymousPersistentField.getType() and never represents
+            a primitve java field with value 0, thus we return always 'false' in this case.
+            (If the value object is null, the first check above return true)
+            */
+            if(type != null)
+            {
+                result = type.isPrimitive();
+            }
+        }
+        // TODO: Do we need this check?? String could be nullified, why should we assume
+        // it's 'null' on empty string?
+        else if ((aValue instanceof String) && (((String) aValue).length() == 0))
+        {
+            result = fld.isPrimaryKey();
+        }
+        return result;
+	}
+
+}

Added: db/ojb/trunk/src/java/org/apache/ojb/broker/accesslayer/NullCheckRelaxedImpl.java
URL: http://svn.apache.org/viewvc/db/ojb/trunk/src/java/org/apache/ojb/broker/accesslayer/NullCheckRelaxedImpl.java?rev=422225&view=auto
==============================================================================
--- db/ojb/trunk/src/java/org/apache/ojb/broker/accesslayer/NullCheckRelaxedImpl.java (added)
+++ db/ojb/trunk/src/java/org/apache/ojb/broker/accesslayer/NullCheckRelaxedImpl.java Sat Jul 15 07:09:47 2006
@@ -0,0 +1,47 @@
+package org.apache.ojb.broker.accesslayer;
+
+import org.apache.ojb.broker.metadata.FieldDescriptor;
+
+/* Copyright 2002-2006 The Apache Software Foundation
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+/**
+ * Implementation of NullCheck with a more relaxed definition of 'null' than
+ * {@link NullCheckDefaultImpl]}.
+ * 
+ * @version $Id: NullCheckRelaxedImpl.java 411859 2006-06-05 17:04:13Z mkalen $
+ * @since OJB 1.0.5
+ */
+public class NullCheckRelaxedImpl implements NullCheck
+{
+
+	private static final long serialVersionUID = -2006686663775435151L;
+
+	/**
+     * Returns wether the given object value represents 'null' for the specified field.
+     * <p>
+     * Null is defined as:
+     *  <ul>
+     *   <li>given value is 'null' itself
+     *  </ul>
+     * @param fld descriptor representation of the persistent field
+     * @param aValue the value to check if it represents 'null' 
+     * @return true if and only if aValue represents null
+     */
+	public boolean representsNull(FieldDescriptor fld, Object aValue) {
+		return aValue == null;
+	}
+
+}

Added: db/ojb/trunk/src/java/org/apache/ojb/broker/accesslayer/conversions/AbstractList2VarcharConversion.java
URL: http://svn.apache.org/viewvc/db/ojb/trunk/src/java/org/apache/ojb/broker/accesslayer/conversions/AbstractList2VarcharConversion.java?rev=422225&view=auto
==============================================================================
--- db/ojb/trunk/src/java/org/apache/ojb/broker/accesslayer/conversions/AbstractList2VarcharConversion.java (added)
+++ db/ojb/trunk/src/java/org/apache/ojb/broker/accesslayer/conversions/AbstractList2VarcharConversion.java Sat Jul 15 07:09:47 2006
@@ -0,0 +1,191 @@
+package org.apache.ojb.broker.accesslayer.conversions;
+
+/* Copyright 2002-2006 The Apache Software Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import java.lang.Object;
+import java.util.List;
+import java.util.ArrayList;
+
+import org.apache.commons.lang.StringUtils;
+
+/**
+ * Base class to implement simple object List (e.g. list of strings or list of time values)
+ * to Varchar column conversions.
+ * <br/>
+ * Strings may not contain <em>"#"</em> (at the beginning and end of a string) as this is
+ * used as separator.
+ * Additionally this implementation use keywords for "blank string" and 'null' list entires,
+ * thus string based list entries may not contain keywords <em>"+.EmPtY.+"</em> and <em>"+.NuLl.+"</em>.
+ *
+ * @version $Id: $
+ */
+abstract class AbstractList2VarcharConversion implements FieldConversion
+{
+
+    protected static final String NULLVALUE = "#NULL#";
+    // don't fix the typo! otherwise we are no longer backward compatible
+    protected static final String EMPTYCOLLEC = "#EMTPY#";
+    protected static final String EMPTY_STR_ENTRY = "+.EmPtY.+";
+    protected static final String NULL_ENTRY = "+.NuLl.+";
+
+    public AbstractList2VarcharConversion()
+    {
+    }
+
+    /**
+     * Return a new instance of used {@link java.util.List} implementation.
+     */
+    protected List newList()
+    {
+        return new ArrayList();
+    }
+
+    /**
+     * Converts the list entry to a {@link String} representation. By default
+     * this method simply call 'toString' on specified entry. If entry is 'null'
+     * method returns 'null'.
+     */
+    protected String convertListEntryToString(Object entry)
+    {
+        String result = entry != null ? entry.toString() : null;
+        // if the separator keyword '#' is used within a string
+        // replace it by '##' to allow handle of '#' in strings
+        if(result != null)
+        {
+            result = StringUtils.replace(result, "#", "##");
+        }
+        return result;
+    }
+
+    /**
+     * Add a list entry (extracted from the datastore varchar column) to result list.
+     * By default this method simply add the string to the result list.
+     */
+    protected void addEntryToList(List resultList, String strEntry)
+    {
+        resultList.add(checkResult(strEntry));
+    }
+
+    /**
+     * Check method for String based list entries.
+     */
+    protected String checkResult(String result)
+    {
+        //System.out.println("check: " + result);
+        if(result.equals(NULL_ENTRY))
+        {
+            return null;
+}
+        else if(result.equals(EMPTY_STR_ENTRY))
+        {
+            return "";
+        }
+        else
+        {
+            return result;
+        }
+    }
+
+    /* (non-Javadoc)
+     * @see org.apache.ojb.broker.accesslayer.conversions.FieldConversion#javaToSql(java.lang.Object)
+     */
+    public Object javaToSql(Object source) throws ConversionException
+    {
+
+        if (source == null)
+        {
+            return NULLVALUE;
+        }
+
+        try
+        {
+            List sourceList = (List) source;
+            if (sourceList.isEmpty())
+            {
+                return EMPTYCOLLEC;
+            }
+
+            StringBuffer result = new StringBuffer();
+            for (int i = 0; i < sourceList.size(); i++)
+            {
+                String newSt = convertListEntryToString(sourceList.get(i));
+                if (i > 0)
+                {
+                    result.append("#");
+                }
+                if(newSt == null) result.append(NULL_ENTRY);
+                else if(newSt.equals("")) result.append(EMPTY_STR_ENTRY);
+                else result.append(newSt);
+            }
+            return result.toString();
+        }
+        catch (ClassCastException e)
+        {
+            throw new ConversionException("Object is not a List of objects, class: "
+                    + source.getClass().getName());
+        }
+    }
+
+    /* (non-Javadoc)
+     * @see org.apache.ojb.broker.accesslayer.conversions.FieldConversion#sqlToJava(java.lang.Object)
+     */
+    public Object sqlToJava(Object source) throws ConversionException
+    {
+        if (source == null)
+        {
+            return null;
+        }
+        if (source.toString().equals(NULLVALUE))
+        {
+            return null;
+        }
+        if (source.toString().equals(EMPTYCOLLEC))
+        {
+            return newList();
+        }
+
+        List resultList = newList();
+        int pos = 0;
+        int length;
+        StringBuffer input = new StringBuffer();
+        StringBuffer newString = new StringBuffer();
+        input.append(source.toString());
+        length = input.length();
+        while (pos < length)
+        {
+            if (input.charAt(pos) != '#')
+            {
+                newString.append(input.charAt(pos));
+            }
+            else
+            {
+                if (input.charAt(pos + 1) != '#')
+                {
+                    addEntryToList(resultList, newString.toString());
+                    newString = new StringBuffer();
+                }
+                else
+                {
+                    newString.append('#');
+                    ++pos;
+                }
+            }
+            ++pos;
+        }
+        addEntryToList(resultList, newString.toString());
+        return resultList;
+    }
+}

Added: db/ojb/trunk/src/java/org/apache/ojb/broker/metadata/ConversionHelper.java
URL: http://svn.apache.org/viewvc/db/ojb/trunk/src/java/org/apache/ojb/broker/metadata/ConversionHelper.java?rev=422225&view=auto
==============================================================================
--- db/ojb/trunk/src/java/org/apache/ojb/broker/metadata/ConversionHelper.java (added)
+++ db/ojb/trunk/src/java/org/apache/ojb/broker/metadata/ConversionHelper.java Sat Jul 15 07:09:47 2006
@@ -0,0 +1,260 @@
+package org.apache.ojb.broker.metadata;
+
+/* Copyright 2002-2006 The Apache Software Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import java.sql.Types;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Calendar;
+
+import org.apache.ojb.broker.accesslayer.conversions.FieldConversion;
+import org.apache.ojb.broker.accesslayer.conversions.JavaDate2SqlDateFieldConversion;
+import org.apache.ojb.broker.accesslayer.conversions.JavaDate2SqlTimestampFieldConversion;
+import org.apache.ojb.broker.accesslayer.conversions.Calendar2TimestampFieldConversion;
+import org.apache.ojb.broker.accesslayer.conversions.Calendar2DateFieldConversion;
+import org.apache.ojb.broker.accesslayer.conversions.Boolean2IntFieldConversion;
+import org.apache.ojb.broker.metadata.fieldaccess.PersistentField;
+
+/**
+ * This class manage predefined
+ * {@link org.apache.ojb.broker.accesslayer.conversions.FieldConversion}
+ * for mapped fields (sql-type/java-type) of persistence capable object classes.
+ * <p/>
+ * Use method {@link #addConversionRule(org.apache.ojb.broker.metadata.ConversionHelper.Rule)}
+ * to add more rules (this have to be done before OJB read in mapping information).
+ * <br/>
+ * Method {@link #getAllRules()} returns a list of all
+ * active {@link org.apache.ojb.broker.metadata.ConversionHelper.Rule}.
+ *
+ * @version $Id: $
+ */
+public class ConversionHelper
+{
+    private Map rules = Collections.synchronizedMap(new HashMap());
+
+    public ConversionHelper()
+    {
+        init();
+    }
+
+    private void init()
+    {
+        addConversionRule(new Date2SqlDateRule());
+        addConversionRule(new Date2TimestampRule());
+        addConversionRule(new Calendar2DateRule());
+        addConversionRule(new Calendar2TimestampRule());
+        addConversionRule(new Boolean2IntegerRule());
+    }
+
+    public FieldConversion getConversion(JdbcType jdbc, PersistentField field)
+    {
+        FieldConversion result = null;
+        List sqlTypeRules = (List) rules.get(new Integer(jdbc.getType()));
+        if(sqlTypeRules != null && sqlTypeRules.size() > 0)
+        {
+            for(int i = 0; i < sqlTypeRules.size(); i++)
+            {
+                Rule rule = (Rule) sqlTypeRules.get(i);
+                if(rule.match(jdbc, field))
+                {
+                    result = rule.newConversion();
+                    break;
+                }
+            }
+        }
+        return result;
+    }
+
+    public synchronized void addConversionRule(Rule rule)
+    {
+        Integer key = new Integer(rule.getSqlType());
+        List ruleList = (List) rules.get(key);
+        if(ruleList == null)
+        {
+            ruleList = new ArrayList();
+            rules.put(key, ruleList);
+        }
+        ruleList.add(rule);
+    }
+
+    public synchronized boolean removeConversionRule(Rule rule)
+    {
+        boolean result = false;
+        List ruleList = (List) rules.get(new Integer(rule.getSqlType()));
+        if(ruleList != null)
+        {
+            result = ruleList.remove(rule);
+        }
+        return result;
+    }
+
+    public List getAllRules()
+    {
+        List result = new ArrayList();
+        Collection rulesList = rules.values();
+        for(Iterator iterator = rulesList.iterator(); iterator.hasNext();)
+        {
+            List list = (List) iterator.next();
+            result.addAll(list);
+        }
+        return result;
+    }
+
+    /**
+     * Defines a rule for a specific java-field/sql type combination, e.g.
+     * if java-field is of type {@link java.util.Date} and sql-type is DATE, then the
+     * rule (see {@link org.apache.ojb.broker.metadata.ConversionHelper.Rule#newConversion()})
+     * should return a {@link org.apache.ojb.broker.accesslayer.conversions.FieldConversion}
+     * handle {@link java.util.Date} to {@link java.sql.Date}
+     * conversion.
+     */
+    public static interface Rule
+    {
+        /** Returns the sql-type {see @link java.sql.Types} matched by this rule. */
+        int getSqlType();
+
+        /**
+         * Returns <em>true</em> if the specified {@link JdbcType} and {@link FieldType}
+         * match the rule.
+         *
+         * @param jdbc The {@link JdbcType} of the database column.
+         * @param field The {@link FieldType} of the mapped persistent object field.
+         * @return If match <em>true</em> is returned.
+         */
+        boolean match(JdbcType jdbc, PersistentField field);
+
+        /**
+         * Returns a new instance of the
+         * {@link org.apache.ojb.broker.accesslayer.conversions.FieldConversion}
+         * matched by this rule.
+         */
+        FieldConversion newConversion();
+    }
+
+    static class Date2SqlDateRule implements Rule
+    {
+        public int getSqlType()
+        {
+            return Types.DATE;
+        }
+
+        public boolean match(JdbcType jdbc, PersistentField field)
+        {
+            boolean result = false;
+            if(jdbc.getType() == getSqlType())
+            {
+                Class fieldClass = field.getType();
+                if(Date.class.isAssignableFrom(fieldClass))
+                {
+                    result = true;
+                }
+            }
+            return result;
+        }
+
+        public FieldConversion newConversion()
+        {
+            return new JavaDate2SqlDateFieldConversion();
+        }
+    }
+
+    static class Date2TimestampRule extends Date2SqlDateRule
+    {
+        public int getSqlType()
+        {
+            return Types.TIMESTAMP;
+        }
+
+        public FieldConversion newConversion()
+        {
+            return new JavaDate2SqlTimestampFieldConversion();
+        }
+    }
+
+    static class Calendar2DateRule implements Rule
+    {
+        public int getSqlType()
+        {
+            return Types.DATE;
+        }
+
+        public boolean match(JdbcType jdbc, PersistentField field)
+        {
+            boolean result = false;
+            if(jdbc.getType() == getSqlType())
+            {
+                Class fieldClass = field.getType();
+                if(Calendar.class.isAssignableFrom(fieldClass))
+                {
+                    result = true;
+                }
+            }
+            return result;
+        }
+
+        public FieldConversion newConversion()
+        {
+            return new Calendar2DateFieldConversion();
+        }
+    }
+
+    static class Calendar2TimestampRule extends Calendar2DateRule
+    {
+        public int getSqlType()
+        {
+            return Types.TIMESTAMP;
+        }
+
+        public FieldConversion newConversion()
+        {
+            return new Calendar2TimestampFieldConversion();
+        }
+    }
+
+    static class Boolean2IntegerRule implements Rule
+    {
+        public int getSqlType()
+        {
+            return Types.INTEGER;
+        }
+
+        public boolean match(JdbcType jdbc, PersistentField field)
+        {
+            boolean result = false;
+            if(jdbc.getType() == getSqlType())
+            {
+                Class fieldClass = field.getType();
+                if(FieldTypes.BooleanFieldType.class.isAssignableFrom(jdbc.getFieldType().getClass())
+                        || Boolean.class.isAssignableFrom(fieldClass))
+                {
+                    result = true;
+                }
+            }
+            return result;
+        }
+
+        public FieldConversion newConversion()
+        {
+            return new Boolean2IntFieldConversion();
+        }
+    }
+}

Added: db/ojb/trunk/src/java/org/apache/ojb/broker/metadata/FieldTypes.java
URL: http://svn.apache.org/viewvc/db/ojb/trunk/src/java/org/apache/ojb/broker/metadata/FieldTypes.java?rev=422225&view=auto
==============================================================================
--- db/ojb/trunk/src/java/org/apache/ojb/broker/metadata/FieldTypes.java (added)
+++ db/ojb/trunk/src/java/org/apache/ojb/broker/metadata/FieldTypes.java Sat Jul 15 07:09:47 2006
@@ -0,0 +1,442 @@
+package org.apache.ojb.broker.metadata;
+
+/* Copyright 2002-2006 The Apache Software Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import java.io.Serializable;
+import java.lang.reflect.Method;
+import java.sql.Date;
+import java.sql.Time;
+import java.sql.Timestamp;
+import java.util.Arrays;
+import java.net.URL;
+import java.net.MalformedURLException;
+
+import org.apache.commons.lang.ArrayUtils;
+import org.apache.commons.lang.ObjectUtils;
+import org.apache.commons.lang.SerializationUtils;
+import org.apache.commons.lang.builder.ToStringBuilder;
+import org.apache.ojb.broker.util.logging.LoggerFactory;
+import org.apache.ojb.broker.OJBRuntimeException;
+import org.apache.ojb.broker.lob.LobHandle;
+
+/**
+ * Encapsulates {@link org.apache.ojb.broker.metadata.FieldType} implementations as inner classes.
+ *
+ * @version $Id: FieldTypes.java 365232 2005-12-21 23:36:07 +0100 (Mi, 21 Dez 2005) tomdz $
+ */
+public class FieldTypes
+{
+    private FieldTypes()
+    {
+    }
+
+    /** Base class for all fields. */
+    abstract static class BaseFieldType implements FieldType
+    {
+        /**
+         * Helper method to copy an object if possible.
+         *
+         * @param toCopy The object to copy.
+         * @return The copy of the object or <em>null</em> clone is not supported.
+         */
+        private Object copyIfCloneable(Object toCopy)
+        {
+            Object result = null;
+            if(toCopy instanceof Cloneable)
+            {
+                try
+                {
+                    Method m = toCopy.getClass().getMethod("clone", ArrayUtils.EMPTY_CLASS_ARRAY);
+                    /*
+                    arminw:
+                    By definition the overrided object.clone() method has to be public
+                    so we don't need to make it accessible
+                    */
+                    //m.setAccessible(true);
+                    result = m.invoke(toCopy, null);
+                }
+                catch(Exception e)
+                {
+                    LoggerFactory.getDefaultLogger().error("[" + this.getClass().getName() + "]"
+                            + "Can't invoke method 'clone' on Cloneable object: " + toCopy, e);
+                }
+            }
+            return result;
+        }
+
+        /**
+         * Helper method to copy an object if possible.
+         *
+         * @param toCopy The object to copy.
+         * @return The copy of the object or <em>null</em> if serialization is not supported.
+         */
+        private Object copyIfSerializeable(Object toCopy)
+        {
+            Object result = null;
+            if(toCopy instanceof Serializable)
+            {
+                result = SerializationUtils.clone((Serializable) toCopy);
+            }
+            return result;
+        }
+
+        /**
+         * This method copy the specified object if the object
+         * is {@link Cloneable} or {@link java.io.Serializable}, else
+         * <code>NULL</code> is returned.
+         *
+         * @param toCopy The object to copy.
+         * @return The copy result.
+         */
+        Object copyIfPossible(Object toCopy)
+        {
+            Object copy = copyIfCloneable(toCopy);
+            if(copy == null)
+            {
+                copy = copyIfSerializeable(toCopy);
+            }
+            return copy;
+        }
+
+        public String toString()
+        {
+            return new ToStringBuilder(this)
+                    .append("isMutable", isMutable()).toString();
+        }
+
+        public boolean isLobField()
+        {
+            return false;
+        }
+    }
+
+    /** Base class for all <em>immutable</em> types, like Number fields, Strings, ... */
+    abstract static class ImmutableFieldType extends BaseFieldType
+    {
+        public boolean isMutable()
+        {
+            return false;
+        }
+
+        public Object copy(Object source)
+        {
+            return source;
+        }
+
+        public boolean equals(Object firstValue, Object secondValue)
+        {
+            return ObjectUtils.equals(firstValue, secondValue);
+        }
+    }
+
+    /** Base class for all <em>mutable</em> fields. */
+    abstract static class MutableFieldType extends BaseFieldType
+    {
+        public boolean isMutable()
+        {
+            return true;
+        }
+
+        public boolean equals(Object firstValue, Object secondValue)
+        {
+            return ObjectUtils.equals(firstValue, secondValue);
+        }
+    }
+
+    /**
+     * Base class for LOB fields implemented as mutable field.
+     */
+    static class LobFieldType extends MutableFieldType
+    {
+        public boolean isLobField()
+        {
+            return true;
+        }
+
+        /**
+         * It's not possible to copy locator objects, thus this method always
+         * returns a decoupled LOB wrapper object.
+         *
+         * @param fieldValue The value to copy.
+         * @return A decoupled locator instance.
+         */
+        public Object copy(Object fieldValue)
+        {
+            if(fieldValue != null)
+            {
+                LobHandle lob = (LobHandle) fieldValue;
+                return lob.decoupledCopy();
+            }
+            else
+            {
+                return null;
+            }
+        }
+
+        /**
+         * Compare locator objects is different from "normal fields", because the locator object
+         * itself can't be compared. Thus we expect that the locator is of
+         * type {@link org.apache.ojb.broker.lob.LobHandle}.
+         *
+         * @param firstValue First value to compare.
+         * @param secondValue Second value to compare.
+         * @return The comparision state of both fields.
+         */
+        public boolean equals(Object firstValue, Object secondValue)
+        {
+            LobHandle first = (LobHandle) firstValue;
+            LobHandle second = (LobHandle) secondValue;
+            boolean result = true;
+            if(first != null)
+            {
+                // one was nullified
+                if(second == null)
+                {
+                    result = false;
+                }
+                // both are not null, check internal state
+                else
+                {
+                    result = !first.isDirty() || !second.isDirty();
+                }
+            }
+            else
+            {
+                // second isn't null
+                if(second != null)
+                {
+                    result = false;
+                }
+                // else both are null
+            }
+            return result;
+        }
+    }
+
+    /**
+     * Clob (like other LOB's) fields normally are logical pointer to DB
+     * thus it's mutable, because the LOB content could change.
+     *
+     * @see BlobFieldType
+     */
+    public static class ClobFieldType extends LobFieldType
+    {
+    }
+
+    /**
+     * Blob (like other LOB's) fields normally are logical pointer to DB
+     * thus it's mutable, because the LOB content could change.
+     * Snip of JDBC specification:
+     * "An application does not deal directly with the LOCATOR(blob) and
+     * LOCATOR(clob) types that are defined in SQL. By default, a JDBC
+     * driver should implement the Blob and Clob interfaces using the
+     * appropriate locator type. Also by default, Blob and Clob objects
+     * remain valid only during the transaction in which they are created."
+     */
+    public static class BlobFieldType extends LobFieldType
+    {
+    }
+
+    /**
+     * Array fields are logical pointer to DB, so for OJB it's immutable.
+     * Snip of JDBC specification:
+     * "The Array object returned to an application by the ResultSet.getArray and
+     * CallableStatement.getArray methods is a logical pointer to the SQL ARRAY
+     * value in the database; it does not contain the contents of the SQL ARRAY value."
+     */
+    public static class ArrayFieldType extends ImmutableFieldType
+    {
+    }
+
+    /**
+     * Ref fields are logical pointer to DB, so for OJB it's immutable.
+     * Snip of JDBC specification:
+     * "An SQL REF value is a pointer; therefore, a Ref object, which is the mapping of a
+     * REF value, is likewise a pointer and does not contain the data of the structured type
+     * instance to which it refers."
+     */
+    public static class RefFieldType extends ImmutableFieldType
+    {
+    }
+
+    /**
+     * When using SQL UDT's it's possible that the jdbc-driver returns
+     * full materialized java objects defined by the user.
+     */
+    public static class StructFieldType extends MutableFieldType
+    {
+        // TODO: does this make sense?? or Struct instances always Locator objects?
+        public Object copy(Object fieldValue)
+        {
+            if(fieldValue == null) return null;
+
+            Object copy = copyIfPossible(fieldValue);
+            return copy == null ? fieldValue : copy;
+        }
+    }
+
+    /**
+     * If a user-defined object is used, we can check if object is
+     * {@link Cloneable} or {@link java.io.Serializable} to copy the object.
+     * If not possible return the specified object instance.
+     */
+    public static class JavaObjectFieldType extends MutableFieldType
+    {
+        public Object copy(Object fieldValue)
+        {
+            if(fieldValue == null) return null;
+
+            Object copy = copyIfPossible(fieldValue);
+            return copy == null ? fieldValue : copy;
+        }
+    }
+
+    public static class ByteArrayFieldType extends MutableFieldType
+    {
+        public Object copy(Object fieldValue)
+        {
+            byte[] result = null;
+            if(fieldValue != null)
+            {
+                byte[] source = (byte[]) fieldValue;
+                int length = source.length;
+                result = new byte[length];
+                System.arraycopy(fieldValue, 0, result, 0, length);
+            }
+            return result;
+        }
+
+        public boolean equals(Object firstValue, Object secondValue)
+        {
+            return Arrays.equals((byte[]) firstValue, (byte[]) secondValue);
+        }
+    }
+
+    public static class DateFieldType extends MutableFieldType
+    {
+        public Object copy(Object fieldValue)
+        {
+            Date source = (Date) fieldValue;
+            return source != null ? new Date(source.getTime()) : null;
+        }
+    }
+
+    public static class TimeFieldType extends MutableFieldType
+    {
+        public Object copy(Object fieldValue)
+        {
+            Time source = (Time) fieldValue;
+            return source != null ? new Time(source.getTime()) : null;
+        }
+    }
+
+    public static class TimestampFieldType extends MutableFieldType
+    {
+        public Object copy(Object fieldValue)
+        {
+            Timestamp result = null;
+            if(fieldValue != null)
+            {
+                Timestamp source = (Timestamp) fieldValue;
+                result = (Timestamp) source.clone();
+            }
+            return result;
+        }
+    }
+
+    public static class URLFieldType extends MutableFieldType
+    {
+        public Object copy(Object fieldValue)
+        {
+            URL url = (URL) fieldValue;
+            try
+            {
+                return new URL(url.getProtocol(), url.getHost(), url.getPort(), url.getFile());
+            }
+            catch(MalformedURLException e)
+            {
+                throw new CopyException("Can't copy URL: " + fieldValue);
+            }
+        }
+    }
+
+    public static class StringFieldType extends ImmutableFieldType
+    {
+    }
+
+    public static class BigDecimalFieldType extends ImmutableFieldType
+    {
+    }
+
+    public static class BooleanFieldType extends ImmutableFieldType
+    {
+    }
+
+    public static class ByteFieldType extends ImmutableFieldType
+    {
+    }
+
+    public static class ShortFieldType extends ImmutableFieldType
+    {
+
+    }
+
+    public static class IntegerFieldType extends ImmutableFieldType
+    {
+
+    }
+
+    public static class LongFieldType extends ImmutableFieldType
+    {
+
+    }
+
+    public static class FloatFieldType extends ImmutableFieldType
+    {
+
+    }
+
+    public static class DoubleFieldType extends ImmutableFieldType
+    {
+
+    }
+
+    /**
+     * A <em>CopyException</em> is thrown when an unexpected field copy error occur.
+     */
+    public static class CopyException extends OJBRuntimeException
+    {
+        public CopyException()
+        {
+            super();
+        }
+
+        public CopyException(String msg)
+        {
+            super(msg);
+        }
+
+        public CopyException(Throwable cause)
+        {
+            super(cause);
+        }
+
+        public CopyException(String msg, Throwable cause)
+        {
+            super(msg, cause);
+        }
+    }
+}

Added: db/ojb/trunk/src/java/org/apache/ojb/broker/metadata/JdbcTypes.java
URL: http://svn.apache.org/viewvc/db/ojb/trunk/src/java/org/apache/ojb/broker/metadata/JdbcTypes.java?rev=422225&view=auto
==============================================================================
--- db/ojb/trunk/src/java/org/apache/ojb/broker/metadata/JdbcTypes.java (added)
+++ db/ojb/trunk/src/java/org/apache/ojb/broker/metadata/JdbcTypes.java Sat Jul 15 07:09:47 2006
@@ -0,0 +1,1352 @@
+package org.apache.ojb.broker.metadata;
+
+/* Copyright 2002-2006 The Apache Software Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.math.BigDecimal;
+import java.sql.Blob;
+import java.sql.CallableStatement;
+import java.sql.Clob;
+import java.sql.Date;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Time;
+import java.sql.Timestamp;
+import java.sql.Types;
+
+import org.apache.commons.lang.BooleanUtils;
+import org.apache.commons.lang.builder.ToStringBuilder;
+import org.apache.ojb.broker.util.SqlHelper;
+import org.apache.ojb.broker.util.sequence.SequenceManagerException;
+
+/**
+ * Encapsulates {@link org.apache.ojb.broker.metadata.JdbcType} implementations as inner classes.
+ *
+ * @version $Id: JdbcTypes.java 382468 2006-03-02 20:00:37 +0100 (Do, 02 Mrz 2006) arminw $
+ * @see JdbcType
+ */
+public class JdbcTypes
+{
+    private JdbcTypes()
+    {
+        // default constructor
+    }
+
+    //======================================================================================
+    // inner classes implementing JdbcType interface
+    //======================================================================================
+
+    public abstract static class BaseType implements JdbcType
+    {
+        private FieldType fieldType;
+
+        protected BaseType()
+        {
+            fieldType = lookupFieldType();
+        }
+
+        /**
+         * This method is responsible to associate the {@link FieldType}
+         * of this {@link JdbcType}.
+         */
+        FieldType lookupFieldType()
+        {
+            return JdbcTypesHelper.newFieldType(this);
+        }
+
+        /**
+         * Abstract method to read in query results.
+         *
+         * @param rs The current active result set.
+         * @param columnName The column name of row to read.
+         * @return The value of the row (could be <em>null</em>).
+         * @throws SQLException
+         */
+        abstract Object readValueFromResultSet(final ResultSet rs, final String columnName) throws SQLException;
+
+        /**
+         * Abstract method to read in query results.
+         *
+         * @param rs The current active result set.
+         * @param columnIndex The column index of row to read.
+         * @return The value of the row (could be <em>null</em>).
+         * @throws SQLException
+         */
+        abstract Object readValueFromResultSet(final ResultSet rs, final int columnIndex) throws SQLException;
+
+        /**
+         * Abstract method to read in query results.
+         *
+         * @param stmt The current active callable statement.
+         * @param columnIndex The column index of row to read.
+         * @return The value of the row (could be <em>null</em>).
+         * @throws SQLException
+         */
+        abstract Object readValueFromStatement(final CallableStatement stmt, final int columnIndex) throws SQLException;
+
+        /*
+        only supported by jdk >= 1.4x, maybe useful in further versions
+        */
+        // abstract Object readValueFromStatement(CallableStatement stmt, String columnName) throws SQLException;
+
+        public boolean equals(Object obj)
+        {
+            if(this == obj) return true;
+            boolean result = false;
+            if(obj instanceof JdbcType)
+            {
+                result = this.getType() == ((JdbcType) obj).getType();
+            }
+            return result;
+        }
+
+        public int hashCode()
+        {
+            return getType();
+        }
+
+        public FieldType getFieldType()
+        {
+            return fieldType;
+        }
+
+        public Object getObjectFromColumn(final CallableStatement stmt, final int columnId) throws SQLException
+        {
+            return getObjectFromColumn(null, stmt, null, columnId);
+        }
+
+        public Object getObjectFromColumn(final ResultSet rs, final String columnName) throws SQLException
+        {
+            return getObjectFromColumn(rs, null, columnName, MIN_INT);
+        }
+
+        public Object getObjectFromColumn(final ResultSet rs, final int columnId) throws SQLException
+        {
+            return getObjectFromColumn(rs, null, null, columnId);
+        }
+
+        public Object getObjectFromColumn(final ResultSet rs, final CallableStatement stmt,
+                                          final String columnName, final int columnIndex) throws SQLException
+        {
+            if(stmt != null)
+            {
+                if(columnIndex == MIN_INT)
+                {
+                    throw new UnsupportedOperationException("Not implemented yet");
+                }
+                else
+                {
+                    return readValueFromStatement(stmt, columnIndex);
+                }
+            }
+            else
+            {
+                return columnIndex == MIN_INT ?
+                        readValueFromResultSet(rs, SqlHelper.stripOjbQuotes(columnName))
+                        : readValueFromResultSet(rs, columnIndex);
+            }
+        }
+
+        public String toString()
+        {
+            return new ToStringBuilder(this)
+                    .append("jdbcType", getType())
+                    .append("jdbcTypeString", JdbcTypesHelper.getSqlTypeAsString(getType()))
+                    .append("associatedFieldType", getFieldType())
+                    .toString();
+        }
+
+//      // not used in code, but maybe useful in further versions
+//        public Object getObjectFromColumn(CallableStatement stmt, String columnName) throws SQLException
+//        {
+//            return getObjectFromColumn(null, stmt, columnName, MIN_INT);
+//        }
+//
+//        public Object getObjectFromColumn(ResultSet rs, int columnId) throws SQLException
+//        {
+//            return getObjectFromColumn(rs, null, null, columnId);
+//        }
+
+    }
+
+
+    public static final class T_Char extends JdbcTypes.BaseType
+    {
+		private static final long serialVersionUID = 1L;
+
+		public Object sequenceKeyConversion(Long identifier)
+        {
+            return identifier.toString();
+        }
+
+//        Object readValueFromStatement(CallableStatement stmt, String columnName) throws SQLException
+//        {
+//            return stmt.getString(columnName);
+//        }
+
+        Object readValueFromStatement(final CallableStatement stmt, final int columnIndex) throws SQLException
+        {
+            return stmt.getString(columnIndex);
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final String columnName) throws SQLException
+        {
+            return rs.getString(columnName);
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final int columnIndex) throws SQLException
+        {
+            return rs.getString(columnIndex);
+        }
+
+        public int getType()
+        {
+            return Types.CHAR;
+        }
+    }
+
+    public static final class T_Varchar extends JdbcTypes.BaseType
+    {
+		private static final long serialVersionUID = 1L;
+
+		public Object sequenceKeyConversion(Long identifier)
+        {
+            return identifier.toString();
+        }
+
+//        Object readValueFromStatement(CallableStatement stmt, String columnName) throws SQLException
+//        {
+//            return stmt.getString(columnName);
+//        }
+
+        Object readValueFromStatement(final CallableStatement stmt, final int columnIndex) throws SQLException
+        {
+            return stmt.getString(columnIndex);
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final String columnName) throws SQLException
+        {
+            return rs.getString(columnName);
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final int columnIndex) throws SQLException
+        {
+            return rs.getString(columnIndex);
+        }
+
+        public int getType()
+        {
+            return Types.VARCHAR;
+        }
+    }
+
+    public static final class T_LongVarChar extends JdbcTypes.BaseType
+    {
+		private static final long serialVersionUID = 1L;
+
+		public Object sequenceKeyConversion(Long identifier)
+        {
+            return identifier.toString();
+        }
+
+//        Object readValueFromStatement(CallableStatement stmt, String columnName) throws SQLException
+//        {
+//            return stmt.getString(columnName);
+//        }
+
+        Object readValueFromStatement(final CallableStatement stmt, final int columnIndex) throws SQLException
+        {
+            return stmt.getString(columnIndex);
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final String columnName) throws SQLException
+        {
+            return rs.getString(columnName);
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final int columnIndex) throws SQLException
+        {
+            return rs.getString(columnIndex);
+        }
+
+        public int getType()
+        {
+            return Types.LONGVARCHAR;
+        }
+    }
+
+    public static final class T_Numeric extends JdbcTypes.BaseType
+    {
+		private static final long serialVersionUID = 1L;
+
+        public Object sequenceKeyConversion(Long identifier)
+        {
+            return BigDecimal.valueOf(identifier.longValue());
+        }
+
+//        Object readValueFromStatement(CallableStatement stmt, String columnName) throws SQLException
+//        {
+//            return stmt.getBigDecimal(columnName);
+//        }
+
+        Object readValueFromStatement(final CallableStatement stmt, final int columnIndex) throws SQLException
+        {
+            return stmt.getBigDecimal(columnIndex);
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final String columnName) throws SQLException
+        {
+            return rs.getBigDecimal(columnName);
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final int columnIndex) throws SQLException
+        {
+            return rs.getBigDecimal(columnIndex);
+        }
+
+        public int getType()
+        {
+            return Types.NUMERIC;
+        }
+    }
+
+    public static final class T_Decimal extends JdbcTypes.BaseType
+    {
+		private static final long serialVersionUID = 1L;
+
+		public Object sequenceKeyConversion(Long identifier)
+        {
+        	return BigDecimal.valueOf(identifier.longValue());
+        }
+
+//        Object readValueFromStatement(CallableStatement stmt, String columnName) throws SQLException
+//        {
+//            return stmt.getBigDecimal(columnName);
+//        }
+
+        Object readValueFromStatement(final CallableStatement stmt, final int columnIndex) throws SQLException
+        {
+            return stmt.getBigDecimal(columnIndex);
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final String columnName) throws SQLException
+        {
+            return rs.getBigDecimal(columnName);
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final int columnIndex) throws SQLException
+        {
+            return rs.getBigDecimal(columnIndex);
+        }
+
+        public int getType()
+        {
+            return Types.DECIMAL;
+        }
+    }
+
+    public static final class T_Bit extends JdbcTypes.BaseType
+    {
+		private static final long serialVersionUID = 1L;
+
+		public Object sequenceKeyConversion(Long identifier) throws SequenceManagerException
+        {
+            throw new SequenceManagerException("Not supported sequence key type 'BIT'");
+        }
+
+//        Object readValueFromStatement(CallableStatement stmt, String columnName) throws SQLException
+//        {
+//            boolean temp = stmt.getBoolean(columnName);
+//            return (stmt.wasNull() ? null : new Boolean(temp));
+//        }
+
+        Object readValueFromStatement(final CallableStatement stmt, final int columnIndex) throws SQLException
+        {
+            boolean temp = stmt.getBoolean(columnIndex);
+            return (stmt.wasNull() ? null : BooleanUtils.toBooleanObject(temp));
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final String columnName) throws SQLException
+        {
+            boolean temp = rs.getBoolean(columnName);
+            return (rs.wasNull() ? null : BooleanUtils.toBooleanObject(temp));
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final int columnIndex) throws SQLException
+        {
+            boolean temp = rs.getBoolean(columnIndex);
+            return (rs.wasNull() ? null : BooleanUtils.toBooleanObject(temp));
+        }
+
+        public int getType()
+        {
+            return Types.BIT;
+        }
+    }
+
+//#ifdef JDBC30
+
+    public static final class T_Boolean extends JdbcTypes.BaseType
+    {
+		private static final long serialVersionUID = 1L;
+
+		public Object sequenceKeyConversion(final Long identifier) throws SequenceManagerException
+        {
+            throw new SequenceManagerException("Not supported sequence key type 'BOOLEAN'");
+        }
+
+//        Object readValueFromStatement(CallableStatement stmt, String columnName) throws SQLException
+//        {
+//            boolean temp = stmt.getBoolean(columnName);
+//            return (stmt.wasNull() ? null : BooleanUtils.toBooleanObject(temp));
+//        }
+
+        Object readValueFromStatement(final CallableStatement stmt, final int columnIndex) throws SQLException
+        {
+            boolean temp = stmt.getBoolean(columnIndex);
+            return (stmt.wasNull() ? null : BooleanUtils.toBooleanObject(temp));
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final String columnName) throws SQLException
+        {
+            boolean temp = rs.getBoolean(columnName);
+            return (rs.wasNull() ? null : BooleanUtils.toBooleanObject(temp));
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final int columnIndex) throws SQLException
+        {
+            boolean temp = rs.getBoolean(columnIndex);
+            return (rs.wasNull() ? null : BooleanUtils.toBooleanObject(temp));
+        }
+
+        public int getType()
+        {
+            return Types.BOOLEAN;
+        }
+    }
+//#endif
+
+    public static final class T_TinyInt extends JdbcTypes.BaseType
+    {
+		private static final long serialVersionUID = 1L;
+
+		public Object sequenceKeyConversion(final Long identifier)
+        {
+            return new Byte(identifier.byteValue());
+        }
+
+//        Object readValueFromStatement(CallableStatement stmt, String columnName) throws SQLException
+//        {
+//            byte temp = stmt.getByte(columnName);
+//            return (stmt.wasNull() ? null : new Byte(temp));
+//        }
+
+        Object readValueFromStatement(final CallableStatement stmt, final int columnIndex) throws SQLException
+        {
+            byte temp = stmt.getByte(columnIndex);
+            return (stmt.wasNull() ? null : new Byte(temp));
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final String columnName) throws SQLException
+        {
+            byte temp = rs.getByte(columnName);
+            return (rs.wasNull() ? null : new Byte(temp));
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final int columnIndex) throws SQLException
+        {
+            byte temp = rs.getByte(columnIndex);
+            return (rs.wasNull() ? null : new Byte(temp));
+        }
+
+        public int getType()
+        {
+            return Types.TINYINT;
+        }
+    }
+
+    public static final class T_SmallInt extends JdbcTypes.BaseType
+    {
+		private static final long serialVersionUID = 1L;
+
+        public Object sequenceKeyConversion(Long identifier)
+        {
+            return new Short(identifier.shortValue());
+        }
+
+//        Object readValueFromStatement(CallableStatement stmt, String columnName) throws SQLException
+//        {
+//            short temp = stmt.getShort(columnName);
+//            return (stmt.wasNull() ? null : new Short(temp));
+//        }
+
+        Object readValueFromStatement(final CallableStatement stmt, final int columnIndex) throws SQLException
+        {
+            short temp = stmt.getShort(columnIndex);
+            return (stmt.wasNull() ? null : new Short(temp));
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final String columnName) throws SQLException
+        {
+            short temp = rs.getShort(columnName);
+            return (rs.wasNull() ? null : new Short(temp));
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final int columnIndex) throws SQLException
+        {
+            short temp = rs.getShort(columnIndex);
+            return (rs.wasNull() ? null : new Short(temp));
+        }
+
+        public int getType()
+        {
+            return Types.SMALLINT;
+        }
+    }
+
+    public static final class T_Integer extends JdbcTypes.BaseType
+    {
+		private static final long serialVersionUID = 1L;
+
+        public Object sequenceKeyConversion(Long identifier)
+        {
+            return new Integer(identifier.intValue());
+        }
+
+//        Object readValueFromStatement(CallableStatement stmt, String columnName) throws SQLException
+//        {
+//            int temp = stmt.getInt(columnName);
+//            return (stmt.wasNull() ? null : new Integer(temp));
+//        }
+
+        Object readValueFromStatement(final CallableStatement stmt, final int columnIndex) throws SQLException
+        {
+            int temp = stmt.getInt(columnIndex);
+            return (stmt.wasNull() ? null : new Integer(temp));
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final String columnName) throws SQLException
+        {
+            int temp = rs.getInt(columnName);
+            return (rs.wasNull() ? null : new Integer(temp));
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final int columnIndex) throws SQLException
+        {
+            int temp = rs.getInt(columnIndex);
+            return (rs.wasNull() ? null : new Integer(temp));
+        }
+
+        public int getType()
+        {
+            return Types.INTEGER;
+        }
+    }
+
+    public static final class T_BigInt extends JdbcTypes.BaseType
+    {
+		private static final long serialVersionUID = 1L;
+
+        public Object sequenceKeyConversion(Long identifier)
+        {
+            return identifier;
+        }
+
+//        Object readValueFromStatement(CallableStatement stmt, String columnName) throws SQLException
+//        {
+//            long temp = stmt.getLong(columnName);
+//            return (stmt.wasNull() ? null : new Long(temp));
+//        }
+
+        Object readValueFromStatement(final CallableStatement stmt, final int columnIndex) throws SQLException
+        {
+            long temp = stmt.getLong(columnIndex);
+            return (stmt.wasNull() ? null : new Long(temp));
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final String columnName) throws SQLException
+        {
+            long temp = rs.getLong(columnName);
+            return (rs.wasNull() ? null : new Long(temp));
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final int columnIndex) throws SQLException
+        {
+            long temp = rs.getLong(columnIndex);
+            return (rs.wasNull() ? null : new Long(temp));
+        }
+
+        public int getType()
+        {
+            return Types.BIGINT;
+        }
+    }
+
+    public static final class T_Real extends JdbcTypes.BaseType
+    {
+		private static final long serialVersionUID = 1L;
+
+        public Object sequenceKeyConversion(Long identifier)
+        {
+            return new Float(identifier.floatValue());
+        }
+
+//        Object readValueFromStatement(CallableStatement stmt, String columnName) throws SQLException
+//        {
+//            float temp = stmt.getFloat(columnName);
+//            return (stmt.wasNull() ? null : new Float(temp));
+//        }
+
+        Object readValueFromStatement(final CallableStatement stmt, final int columnIndex) throws SQLException
+        {
+            float temp = stmt.getFloat(columnIndex);
+            return (stmt.wasNull() ? null : new Float(temp));
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final String columnName) throws SQLException
+        {
+            float temp = rs.getFloat(columnName);
+            return (rs.wasNull() ? null : new Float(temp));
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final int columnIndex) throws SQLException
+        {
+            float temp = rs.getFloat(columnIndex);
+            return (rs.wasNull() ? null : new Float(temp));
+        }
+
+        public int getType()
+        {
+            return Types.REAL;
+        }
+    }
+
+    public static final class T_Float extends JdbcTypes.BaseType
+    {
+		private static final long serialVersionUID = 1L;
+
+        public Object sequenceKeyConversion(Long identifier)
+        {
+            return new Double(identifier.doubleValue());
+        }
+
+//        Object readValueFromStatement(CallableStatement stmt, String columnName) throws SQLException
+//        {
+//            double temp = stmt.getDouble(columnName);
+//            return (stmt.wasNull() ? null : new Double(temp));
+//        }
+
+        Object readValueFromStatement(final CallableStatement stmt, final int columnIndex) throws SQLException
+        {
+            double temp = stmt.getDouble(columnIndex);
+            return (stmt.wasNull() ? null : new Double(temp));
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final String columnName) throws SQLException
+        {
+            double temp = rs.getDouble(columnName);
+            return (rs.wasNull() ? null : new Double(temp));
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final int columnIndex) throws SQLException
+        {
+            double temp = rs.getDouble(columnIndex);
+            return (rs.wasNull() ? null : new Double(temp));
+        }
+
+        public int getType()
+        {
+            return Types.FLOAT;
+        }
+    }
+
+    public static final class T_Double extends JdbcTypes.BaseType
+    {
+		private static final long serialVersionUID = 1L;
+
+        public Object sequenceKeyConversion(Long identifier)
+        {
+            return new Double(identifier.doubleValue());
+        }
+
+//        Object readValueFromStatement(CallableStatement stmt, String columnName) throws SQLException
+//        {
+//            double temp = stmt.getDouble(columnName);
+//            return (stmt.wasNull() ? null : new Double(temp));
+//        }
+
+        Object readValueFromStatement(final CallableStatement stmt, final int columnIndex) throws SQLException
+        {
+            double temp = stmt.getDouble(columnIndex);
+            return (stmt.wasNull() ? null : new Double(temp));
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final String columnName) throws SQLException
+        {
+            double temp = rs.getDouble(columnName);
+            return (rs.wasNull() ? null : new Double(temp));
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final int columnIndex) throws SQLException
+        {
+            double temp = rs.getDouble(columnIndex);
+            return (rs.wasNull() ? null : new Double(temp));
+        }
+
+        public int getType()
+        {
+            return Types.DOUBLE;
+        }
+    }
+
+    public static final class T_Binary extends JdbcTypes.BaseType
+    {
+		private static final long serialVersionUID = 1L;
+
+        public Object sequenceKeyConversion(Long identifier)
+        {
+            return identifier.toString().getBytes();
+        }
+
+//        Object readValueFromStatement(CallableStatement stmt, String columnName) throws SQLException
+//        {
+//            return stmt.getBytes(columnName);
+//        }
+
+        Object readValueFromStatement(final CallableStatement stmt, final int columnIndex) throws SQLException
+        {
+            return stmt.getBytes(columnIndex);
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final String columnName) throws SQLException
+        {
+            return rs.getBytes(columnName);
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final int columnIndex) throws SQLException
+        {
+            return rs.getBytes(columnIndex);
+        }
+
+        public int getType()
+        {
+            return Types.BINARY;
+        }
+    }
+
+    public static final class T_VarBinary extends JdbcTypes.BaseType
+    {
+		private static final long serialVersionUID = 1L;
+
+        public Object sequenceKeyConversion(Long identifier)
+        {
+            return identifier.toString().getBytes();
+        }
+
+//        Object readValueFromStatement(CallableStatement stmt, String columnName) throws SQLException
+//        {
+//            return stmt.getBytes(columnName);
+//        }
+
+        Object readValueFromStatement(final CallableStatement stmt, final int columnIndex) throws SQLException
+        {
+            return stmt.getBytes(columnIndex);
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final String columnName) throws SQLException
+        {
+            return rs.getBytes(columnName);
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final int columnIndex) throws SQLException
+        {
+            return rs.getBytes(columnIndex);
+        }
+
+        public int getType()
+        {
+            return Types.VARBINARY;
+        }
+    }
+
+    public static final class T_LongVarBinary extends JdbcTypes.BaseType
+    {
+		private static final long serialVersionUID = 1L;
+        private static final int BUFSZ = 2048;
+
+        /**
+         * Retrieve LONGVARBINARY InputStream data and pack into a byte array.
+         *
+         * @param is the input stream to be retrieved
+         * @return a string containing the clob data
+         * @throws java.sql.SQLException if conversion fails or the clob cannot be read
+         */
+        protected static byte[] retrieveStreamDataFromRs(InputStream is) throws SQLException
+        {
+            if(is == null)
+            {
+                return null;
+            }
+            byte[] bytes = null;
+            ByteArrayOutputStream bos = null;
+            try
+            {
+                bos = new ByteArrayOutputStream();
+                int numRead;
+                byte[] buf = new byte[JdbcTypes.T_LongVarBinary.BUFSZ];
+                while((numRead = is.read(buf, 0, buf.length)) > 0)
+                {
+                    bos.write(buf, 0, numRead);
+                }
+                bytes = bos.toByteArray();
+            }
+            catch(IOException e)
+            {
+                throw new SQLException("I/O exception retrieving LONGVARBINARY: " + e.getLocalizedMessage());
+            }
+            finally
+            {
+                if(bos != null)
+                {
+                    try
+                    {
+                        bos.close();
+                    }
+                    catch(Exception ignored)
+                    {
+                        //ignore
+                    }
+                }
+            }
+            return bytes;
+        }
+
+        public Object sequenceKeyConversion(Long identifier)
+        {
+            return identifier.toString().getBytes();
+        }
+
+//        Object readValueFromStatement(CallableStatement stmt, String columnName) throws SQLException
+//        {
+//            return stmt.getBytes(columnName);
+//        }
+
+        Object readValueFromStatement(final CallableStatement stmt, final int columnIndex) throws SQLException
+        {
+            return stmt.getBytes(columnIndex);
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final String columnName) throws SQLException
+        {
+            return JdbcTypes.T_LongVarBinary.retrieveStreamDataFromRs(rs.getBinaryStream(columnName));
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final int columnIndex) throws SQLException
+        {
+            return JdbcTypes.T_LongVarBinary.retrieveStreamDataFromRs(rs.getBinaryStream(columnIndex));
+        }
+
+        public int getType()
+        {
+            return Types.LONGVARBINARY;
+        }
+    }
+
+    public static final class T_Date extends JdbcTypes.BaseType
+    {
+		private static final long serialVersionUID = 1L;
+
+        public Object sequenceKeyConversion(Long identifier)
+        {
+            return new Date(identifier.longValue());
+        }
+
+//        Object readValueFromStatement(CallableStatement stmt, String columnName) throws SQLException
+//        {
+//            return stmt.getDate(columnName);
+//        }
+
+        Object readValueFromStatement(final CallableStatement stmt, final int columnIndex) throws SQLException
+        {
+            return stmt.getDate(columnIndex);
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final String columnName) throws SQLException
+        {
+            return rs.getDate(columnName);
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final int columnIndex) throws SQLException
+        {
+            return rs.getDate(columnIndex);
+        }
+
+        public int getType()
+        {
+            return Types.DATE;
+        }
+    }
+
+    public static final class T_Time extends JdbcTypes.BaseType
+    {
+		private static final long serialVersionUID = 1L;
+
+        public Object sequenceKeyConversion(Long identifier)
+        {
+            return new Time(identifier.longValue());
+        }
+
+//        Object readValueFromStatement(CallableStatement stmt, String columnName) throws SQLException
+//        {
+//            return stmt.getTime(columnName);
+//        }
+
+        Object readValueFromStatement(final CallableStatement stmt, final int columnIndex) throws SQLException
+        {
+            return stmt.getTime(columnIndex);
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final String columnName) throws SQLException
+        {
+            return rs.getTime(columnName);
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final int columnIndex) throws SQLException
+        {
+            return rs.getTime(columnIndex);
+        }
+
+        public int getType()
+        {
+            return Types.TIME;
+        }
+    }
+
+    public static final class T_Timestamp extends JdbcTypes.BaseType
+    {
+		private static final long serialVersionUID = 1L;
+
+        public Object sequenceKeyConversion(Long identifier)
+        {
+            return new Timestamp(identifier.longValue());
+        }
+
+//        Object readValueFromStatement(CallableStatement stmt, String columnName) throws SQLException
+//        {
+//            return stmt.getTimestamp(columnName);
+//        }
+
+        Object readValueFromStatement(final CallableStatement stmt, final int columnIndex) throws SQLException
+        {
+            return stmt.getTimestamp(columnIndex);
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final String columnName) throws SQLException
+        {
+            return rs.getTimestamp(columnName);
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final int columnIndex) throws SQLException
+        {
+            return rs.getTimestamp(columnIndex);
+        }
+
+        public int getType()
+        {
+            return Types.TIMESTAMP;
+        }
+    }
+
+    public static final class T_Clob extends JdbcTypes.BaseType
+    {
+		private static final long serialVersionUID = 1L;
+
+        public Object sequenceKeyConversion(Long identifier) throws SequenceManagerException
+        {
+            throw new SequenceManagerException("Not supported sequence key type 'CLOB'");
+        }
+
+//        Object readValueFromStatement(CallableStatement stmt, String columnName) throws SQLException
+//        {
+//            Clob aClob = stmt.getClob(columnName);
+//            return (stmt.wasNull() ? null : aClob.getSubString(1L, (int) aClob.length()));
+//        }
+
+        Object readValueFromStatement(final CallableStatement stmt, final int columnIndex) throws SQLException
+        {
+            Clob aClob = stmt.getClob(columnIndex);
+            return stmt.wasNull() ? null : aClob;
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final String columnName) throws SQLException
+        {
+            Clob aClob = rs.getClob(columnName);
+            return rs.wasNull() ? null : aClob;
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final int columnIndex) throws SQLException
+        {
+            Clob aClob = rs.getClob(columnIndex);
+            return rs.wasNull() ? null : aClob;
+        }
+
+        public int getType()
+        {
+            return Types.CLOB;
+        }
+    }
+
+    public static final class T_ClobToString extends JdbcTypes.BaseType
+    {
+		private static final long serialVersionUID = 1L;
+        private static final int BUFSZ = 32768;
+
+        /**
+         * Convert CLOB to String. Safe for very large objects.
+         *
+         * @param aClob clob with character data
+         * @return a string containing the clob data
+         * @throws java.sql.SQLException if conversion fails or the clob cannot be read
+         */
+        protected static String safeClobToString(Clob aClob) throws SQLException
+        {
+            long length = aClob.length();
+            if(length == 0)
+            {
+                return "";
+            }
+            StringBuffer sb = new StringBuffer();
+            char[] buf = new char[JdbcTypes.T_ClobToString.BUFSZ];
+            java.io.Reader stream = aClob.getCharacterStream();
+            try
+            {
+                int numRead;
+                while((numRead = stream.read(buf)) != -1)
+                {
+                    sb.append(buf, 0, numRead);
+                }
+                stream.close();
+            }
+            catch(IOException e)
+            {
+                throw new SQLException(e.getLocalizedMessage());
+            }
+            return sb.toString();
+        }
+
+        public Object sequenceKeyConversion(Long identifier) throws SequenceManagerException
+        {
+            throw new SequenceManagerException("Not supported sequence key type 'CLOB'");
+        }
+
+        FieldType lookupFieldType()
+        {
+            return new FieldTypes.StringFieldType();
+        }
+
+//        Object readValueFromStatement(CallableStatement stmt, String columnName) throws SQLException
+//        {
+//            Clob aClob = stmt.getClob(columnName);
+//            return (stmt.wasNull() ? null : aClob.getSubString(1L, (int) aClob.length()));
+//        }
+
+        Object readValueFromStatement(final CallableStatement stmt, final int columnIndex) throws SQLException
+        {
+            Clob aClob = stmt.getClob(columnIndex);
+            return (stmt.wasNull() ? null : JdbcTypes.T_ClobToString.safeClobToString(aClob));
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final String columnName) throws SQLException
+        {
+            Clob aClob = rs.getClob(columnName);
+            return (rs.wasNull() ? null : JdbcTypes.T_ClobToString.safeClobToString(aClob));
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final int columnIndex) throws SQLException
+        {
+            Clob aClob = rs.getClob(columnIndex);
+            return (rs.wasNull() ? null : JdbcTypes.T_ClobToString.safeClobToString(aClob));
+        }
+
+        public int getType()
+        {
+            return Types.CLOB;
+        }
+    }
+
+    public static final class T_Blob extends JdbcTypes.BaseType
+    {
+    	private static final long serialVersionUID = 1L;
+
+        public Object sequenceKeyConversion(Long identifier) throws SequenceManagerException
+        {
+            throw new SequenceManagerException("Not supported sequence key type 'BLOB'");
+        }
+
+//        Object readValueFromStatement(CallableStatement stmt, String columnName) throws SQLException
+//        {
+//            Blob aBlob = stmt.getBlob(columnName);
+//            return (stmt.wasNull() ? null : aBlob.getBytes(1L, (int) aBlob.length()));
+//        }
+
+        Object readValueFromStatement(final CallableStatement stmt, final int columnIndex) throws SQLException
+        {
+            Blob aBlob = stmt.getBlob(columnIndex);
+            return stmt.wasNull() ? null : aBlob;
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final String columnName) throws SQLException
+        {
+            Blob aBlob = rs.getBlob(columnName);
+            return rs.wasNull() ? null : aBlob;
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final int columnIndex) throws SQLException
+        {
+            Blob aBlob = rs.getBlob(columnIndex);
+            return rs.wasNull() ? null : aBlob;
+        }
+
+        public int getType()
+        {
+            return Types.BLOB;
+        }
+    }
+
+    public static final class T_BlobToByteArray extends JdbcTypes.BaseType
+    {
+    	private static final long serialVersionUID = 1L;
+
+        public Object sequenceKeyConversion(Long identifier) throws SequenceManagerException
+        {
+            throw new SequenceManagerException("Not supported sequence key type 'BLOB'");
+        }
+
+        FieldType lookupFieldType()
+        {
+            return new FieldTypes.ByteArrayFieldType();
+        }
+
+//        Object readValueFromStatement(CallableStatement stmt, String columnName) throws SQLException
+//        {
+//            Blob aBlob = stmt.getBlob(columnName);
+//            return (stmt.wasNull() ? null : aBlob.getBytes(1L, (int) aBlob.length()));
+//        }
+
+        Object readValueFromStatement(final CallableStatement stmt, final int columnIndex) throws SQLException
+        {
+            Blob aBlob = stmt.getBlob(columnIndex);
+            return (stmt.wasNull() ? null : aBlob.getBytes(1L, (int) aBlob.length()));
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final String columnName) throws SQLException
+        {
+            Blob aBlob = rs.getBlob(columnName);
+            return (rs.wasNull() ? null : aBlob.getBytes(1L, (int) aBlob.length()));
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final int columnIndex) throws SQLException
+        {
+            Blob aBlob = rs.getBlob(columnIndex);
+            return (rs.wasNull() ? null : aBlob.getBytes(1L, (int) aBlob.length()));
+        }
+
+        public int getType()
+        {
+            return Types.BLOB;
+        }
+    }
+
+    public static final class T_Array extends JdbcTypes.BaseType
+    {
+    	private static final long serialVersionUID = 1L;
+
+        public Object sequenceKeyConversion(Long identifier) throws SequenceManagerException
+        {
+            throw new SequenceManagerException("Not supported sequence key type 'ARRAY'");
+        }
+
+//        Object readValueFromStatement(CallableStatement stmt, String columnName) throws SQLException
+//        {
+//            return stmt.getArray(columnName);
+//        }
+
+        Object readValueFromStatement(final CallableStatement stmt, final int columnIndex) throws SQLException
+        {
+            return stmt.getArray(columnIndex);
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final String columnName) throws SQLException
+        {
+            return rs.getArray(columnName);
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final int columnIndex) throws SQLException
+        {
+            return rs.getArray(columnIndex);
+        }
+
+        public int getType()
+        {
+            return Types.ARRAY;
+        }
+    }
+
+    public static final class T_Struct extends JdbcTypes.BaseType
+    {
+    	private static final long serialVersionUID = 1L;
+
+        public Object sequenceKeyConversion(Long identifier) throws SequenceManagerException
+        {
+            throw new SequenceManagerException("Not supported sequence key type 'STRUCT'");
+        }
+
+//        Object readValueFromStatement(CallableStatement stmt, String columnName) throws SQLException
+//        {
+//            return stmt.getObject(columnName);
+//        }
+
+        Object readValueFromStatement(final CallableStatement stmt, final int columnIndex) throws SQLException
+        {
+            return stmt.getObject(columnIndex);
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final String columnName) throws SQLException
+        {
+            return rs.getObject(columnName);
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final int columnIndex) throws SQLException
+        {
+            return rs.getObject(columnIndex);
+        }
+
+        public int getType()
+        {
+            return Types.STRUCT;
+        }
+    }
+
+    public static final class T_Ref extends JdbcTypes.BaseType
+    {
+    	private static final long serialVersionUID = 1L;
+
+        public Object sequenceKeyConversion(Long identifier) throws SequenceManagerException
+        {
+            throw new SequenceManagerException("Not supported sequence key type 'REF'");
+        }
+
+//        Object readValueFromStatement(CallableStatement stmt, String columnName) throws SQLException
+//        {
+//            return stmt.getRef(columnName);
+//        }
+
+        Object readValueFromStatement(final CallableStatement stmt, final int columnIndex) throws SQLException
+        {
+            return stmt.getRef(columnIndex);
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final String columnName) throws SQLException
+        {
+            return rs.getRef(columnName);
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final int columnIndex) throws SQLException
+        {
+            return rs.getRef(columnIndex);
+        }
+
+        public int getType()
+        {
+            return Types.REF;
+        }
+    }
+
+    public static final class T_JavaObject extends JdbcTypes.BaseType
+    {
+    	private static final long serialVersionUID = 1L;
+
+        public Object sequenceKeyConversion(Long identifier) throws SequenceManagerException
+        {
+            throw new SequenceManagerException("Not supported sequence key type 'JAVA_OBJECT'");
+        }
+
+//        Object readValueFromStatement(CallableStatement stmt, String columnName) throws SQLException
+//        {
+//            return stmt.getRef(columnName);
+//        }
+
+        Object readValueFromStatement(final CallableStatement stmt, final int columnIndex) throws SQLException
+        {
+            return stmt.getObject(columnIndex);
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final String columnName) throws SQLException
+        {
+            return rs.getObject(columnName);
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final int columnIndex) throws SQLException
+        {
+            return rs.getObject(columnIndex);
+        }
+
+        public int getType()
+        {
+            return Types.JAVA_OBJECT;
+        }
+    }
+
+//#ifdef JDBC30
+
+    public static final class T_Datalink extends JdbcTypes.BaseType
+    {
+    	private static final long serialVersionUID = 1L;
+
+        public Object sequenceKeyConversion(Long identifier) throws SequenceManagerException
+        {
+            throw new SequenceManagerException("Not supported sequence key type 'DATALINK'");
+        }
+
+//        Object readValueFromStatement(CallableStatement stmt, String columnName) throws SQLException
+//        {
+//            return stmt.getURL(columnName);
+//        }
+
+        Object readValueFromStatement(final CallableStatement stmt, final int columnIndex) throws SQLException
+        {
+            return stmt.getURL(columnIndex);
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final String columnName) throws SQLException
+        {
+            return rs.getURL(columnName);
+        }
+
+        Object readValueFromResultSet(final ResultSet rs, final int columnIndex) throws SQLException
+        {
+            return rs.getURL(columnIndex);
+        }
+
+        public int getType()
+        {
+            return Types.DATALINK;
+        }
+    }
+//#endif
+}



---------------------------------------------------------------------
To unsubscribe, e-mail: ojb-dev-unsubscribe@db.apache.org
For additional commands, e-mail: ojb-dev-help@db.apache.org


Mime
View raw message