KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > jboss > portal > setup > impl > dl > dbloader > hibernate > TypeResolver


1 /*****************************************
2  * *
3  * JBoss Portal: The OpenSource Portal *
4  * *
5  * Distributable under LGPL license. *
6  * See terms of license at gnu.org. *
7  * *
8  *****************************************/

9 package org.jboss.portal.setup.impl.dl.dbloader.hibernate;
10
11
12 import java.io.ByteArrayInputStream JavaDoc;
13 import java.util.HashMap JavaDoc;
14 import java.sql.Types JavaDoc;
15 import java.sql.PreparedStatement JavaDoc;
16 import java.sql.Statement JavaDoc;
17
18 import org.jboss.portal.setup.PortalSetupException;
19 import org.hibernate.type.LiteralType;
20 import org.hibernate.type.Type;
21 import org.hibernate.type.TypeFactory;
22 import org.hibernate.type.NullableType;
23
24 /**
25  * @author <a HREF="mailto:palber@novell.com">Polina Alber</a>
26  * Date: Apr 28, 2005; Time: 9:24:52 PM
27  * @since JBoss portal 2.0
28  * Class org.jboss.portal.setup.impl.dl.dbloader.hibernate.TypeResolver -
29  * is a helper class designed to overcome some of the issues of building generic database loader using hibernate.
30  */

31 public class TypeResolver
32 {
33 /*generic mapping bettweeb name returned bu Dialect#getTypeName(int) */
34    private static final HashMap JavaDoc g_SQLStandardTypes = new HashMap JavaDoc();
35
36
37    static
38    {
39
40       g_SQLStandardTypes.put("bit", new Integer JavaDoc(Types.BIT));
41       g_SQLStandardTypes.put("bigint", new Integer JavaDoc(Types.BIGINT));
42       g_SQLStandardTypes.put("smallint", new Integer JavaDoc(Types.SMALLINT));
43       g_SQLStandardTypes.put("tinyint", new Integer JavaDoc(Types.TINYINT));
44       g_SQLStandardTypes.put("integer", new Integer JavaDoc(Types.BIT));
45       g_SQLStandardTypes.put("char(1)", new Integer JavaDoc(Types.CHAR));
46       g_SQLStandardTypes.put("varchar($l)", new Integer JavaDoc(Types.VARCHAR));
47       g_SQLStandardTypes.put("FLOAT", new Integer JavaDoc(Types.FLOAT));
48       g_SQLStandardTypes.put("double", new Integer JavaDoc(Types.DOUBLE));
49       g_SQLStandardTypes.put("timestamp", new Integer JavaDoc(Types.TIMESTAMP));
50       g_SQLStandardTypes.put("varbinary($l)", new Integer JavaDoc(Types.VARBINARY));
51       g_SQLStandardTypes.put("varbinary($l)", new Integer JavaDoc(Types.VARBINARY));
52       g_SQLStandardTypes.put("numeric(19, $l)", new Integer JavaDoc(Types.NUMERIC));
53       g_SQLStandardTypes.put("blob", new Integer JavaDoc(Types.BLOB));
54       g_SQLStandardTypes.put("clob", new Integer JavaDoc(Types.CLOB));
55
56    }
57
58    /**
59     * No instances, please
60     */

61    private TypeResolver()
62    {
63
64    }
65
66    /**
67     * @param type a name of a database type
68     * @param value an Object instance of a value to resolve
69     * @param lType - a Literal type resolved by the java class of an object via TypeFactory
70     * @return a quoted string represesntation of resolved value value
71     * @throws PortalSetupException
72     */

73    public static String JavaDoc resolveValueByType(String JavaDoc type, Object JavaDoc value, LiteralType lType) throws PortalSetupException
74    {
75       Object JavaDoc newValue = value;
76       String JavaDoc strValue = null;
77       if (null != type && null != lType)
78       {
79
80          String JavaDoc lowCase = type.toLowerCase();
81          Type basicType = TypeFactory.basic(lowCase);
82          try
83          {
84             if (basicType != null && lType != null)
85             {
86                if (!basicType.getClass().getName().equals(lType.getClass().getName()))
87                {
88                   newValue = resolveValueBySqlType(value, ((NullableType)basicType).sqlType());
89                   //return ((LiteralType) basicType).objectToSQLString(newValue);
90
strValue = '\'' + ((NullableType)basicType).toString(value) + '\'';
91                }
92             }
93             else
94             {
95                int index = ((NullableType)lType).sqlType();
96                int sqlTypeIndex = ((Integer JavaDoc)g_SQLStandardTypes.get(lowCase)).intValue();
97                if (index > 0 && sqlTypeIndex != index)
98                {
99                   //type are not compatible, do some magic
100
//XXXX if
101
newValue = resolveValueBySqlType(value, sqlTypeIndex);
102                   strValue = newValue.toString();
103
104                }
105                else
106                {
107
108                   strValue = lType.objectToSQLString(value);
109
110                }
111             }
112          }
113          catch (Exception JavaDoc e)
114          {
115             throw new PortalSetupException("failed to convert object value to string for type: " + type, e);
116          }
117       }
118       else
119       {
120          if (null != lType)
121          {
122             try
123             {
124                strValue = lType.objectToSQLString(value);
125             }
126             catch (Exception JavaDoc e)
127             {
128                throw new PortalSetupException("failed to convert object value to string for type: " + type, e);
129             }
130          }
131          else
132          {
133             strValue = value.toString();
134          }
135       }
136       return newValue.toString();
137    }
138
139
140    /**
141     * @param value an object instance of a value
142     * @param sqlType an index of a sql type
143     * @return returns converted object
144     */

145    static Object JavaDoc resolveValueBySqlType(Object JavaDoc value, int sqlType)
146    {
147       switch (sqlType)
148       {
149       case java.sql.Types.LONGVARBINARY:
150          if (((byte[])value).length != 0)
151          { // create an input stream
152
ByteArrayInputStream JavaDoc blobStream =
153                new ByteArrayInputStream JavaDoc((byte[])value);
154             return blobStream;
155          }
156          break;
157       case java.sql.Types.DATE:
158          // handles java.util.Date, sigh
159
if (!(value instanceof java.sql.Date JavaDoc) &&
160             (value instanceof java.util.Date JavaDoc))
161          {
162             java.util.Date JavaDoc myDate = (java.util.Date JavaDoc)value;
163             value = new java.sql.Date JavaDoc(myDate.getTime());
164          }
165
166          return value;
167       case java.sql.Types.TIME:
168          // handles java.util.Date, sigh
169
if (!(value instanceof java.sql.Time JavaDoc) &&
170             (value instanceof java.util.Date JavaDoc))
171          {
172             java.util.Date JavaDoc myDate = (java.util.Date JavaDoc)value;
173             value = new java.sql.Time JavaDoc(myDate.getTime());
174          }
175          return value;
176       case java.sql.Types.TIMESTAMP:
177          // handles java.util.Date, sigh
178
if (!(value instanceof java.sql.Timestamp JavaDoc) &&
179             (value instanceof java.util.Date JavaDoc))
180          {
181             java.util.Date JavaDoc myDate = (java.util.Date JavaDoc)value;
182             value = new java.sql.Timestamp JavaDoc(myDate.getTime());
183          }
184          return value;
185       default: // most cases
186
return value;
187
188       }
189       return value;
190    }
191 }
192
Popular Tags