SQLType


1   /*
2    * The contents of this file are subject to the terms of the Common Development
3    * and Distribution License (the License). You may not use this file except in
4    * compliance with the License.
5    *
6    * You can obtain a copy of the License at http://www.netbeans.org/cddl.html
7    * or http://www.netbeans.org/cddl.txt.
8    *
9    * When distributing Covered Code, include this CDDL Header Notice in each file
10   * and include the License file at http://www.netbeans.org/cddl.txt.
11   * If applicable, add the following below the CDDL Header, with the fields
12   * enclosed by brackets [] replaced by your own identifying information:
13   * "Portions Copyrighted [year] [name of copyright owner]"
14   *
15   * The Original Software is NetBeans. The Initial Developer of the Original
16   * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun
17   * Microsystems, Inc. All Rights Reserved.
18   */
19  package org.netbeans.modules.j2ee.persistence.entitygenerator;
20  
21  import java.lang.ref.SoftReference  ;
22  import java.math.BigDecimal  ;
23  import java.math.BigInteger  ;
24  import java.sql.Types  ;
25  import java.util.*;
26  import org.netbeans.modules.dbschema.ColumnElement;
27  
28  /**
29   * provides class wrapper for java.sql.Types.
30   * @see java.sql.Types
31   * @author Christopher Webster
32   */
33  class SQLType {
34      private int sqlType;
35      private String   stringValue;
36      private Class  [] typeList;
37      private boolean supportsFinder;
38      private static final SQLType UNKNOWN = new SQLType(Types.OTHER, 
39                                                         "UNKNOWN", // NOI18N
40                                                         new Class  [0], false);
41          
42      private SQLType(int type, String   value, Class  [] tList, boolean supportsFinder) {
43          sqlType = type;
44          stringValue = value;
45          typeList = tList;
46          this.supportsFinder = supportsFinder;
47      }
48  
49     /** 
50      * Override Object.equals
51      */
52      public boolean equals(Object   other) {
53          if (other == null || !getClass().isInstance(other)){
54          return false;
55          }  
56      return ((SQLType)other).sqlType == sqlType;
57      }
58  
59      /**
60       * Override Object.hashCode
61       */
62      public int hashCode() {
63          return sqlType;
64      }
65    
66      /**
67       * Provide string representation of sql type. For example, 
68       * java.sql.Types.BIT returns BIT.
69       */
70      public String   toString() {
71          return stringValue;
72      }
73          
74      /**
75       * provide original sql type
76       * @return sql type from java.sql.Types
77       */
78      public int sqlType() {
79          return sqlType;
80      }    
81      
82      /**
83       * Return list of classes that could be used to represent this sql type in
84       * Java. The list is derived from JDBC 2.0 specification.
85       * @return list containing java.lang.Class elements to represent this type
86       */
87      private List getValidClasses() {
88          List retList = new ArrayList(typeList.length);
89          retList.addAll(Arrays.asList(typeList));
90          return retList;
91      }
92      
93      /**
94       * Return the string value associated with this sql type
95       * @return String value used in the method signature 
96       */
97      String   getMemberType(ColumnElement element) {
98          String   memberType = java.io.Serializable  .class.getName();
99          Class   memberTypeClass = null;
100 
101         if (element.isCharacterType()) {
102             memberTypeClass = getClassForCharType(element.getLength(), 
103                     element.isNullable());
104         } else if (element.isNumericType()) {
105             memberTypeClass = getClassForNumericType(element.getPrecision(), 
106                     element.getScale(), element.isNullable());
107         }
108 
109         if (memberTypeClass != null) {
110             return memberTypeClass.getName();
111         }
112 
113         if (typeList.length > 0) {
114             memberType = typeList[0].getName();
115         }
116         
117         /* Alters the name in the case of byte arrays */
118         if (memberType.equals("[B")) {
119             memberType = "byte []";
120         }
121         return memberType;
122     }
123 
124     // returns the relevant Class from the typeList if it is dependent on
125     // length, <code>null</code> if the rules in the no-arg getMemberType 
126     // method are sufficient
127     private Class   getClassForCharType (Integer   length, boolean isNullable) {
128         switch (sqlType) {
129             case Types.CHAR:
130                 if ((length != null) && (length.intValue() == 1)) {
131                      return typeList[isNullable ? 1 : 2];
132                 }
133             default:
134                 return null;
135         }
136     }
137 
138     // returns the relevant Class from the typeList if it is dependent on
139     // precision, scale, or nullability, <code>null</code> if the rules in 
140     // the no-arg getMemberType method are sufficient
141     private Class   getClassForNumericType(Integer   precision, 
142             Integer   scale, boolean isNullable) {
143         int precValue = ((precision == null) ? -1 : precision.intValue());
144         int scaleValue = ((scale == null) ? -1 : scale.intValue());
145 
146         switch (sqlType) {
147             case Types.DECIMAL:
148             case Types.NUMERIC:
149                 // some jdbc drivers put in null or zero for a numeric
150                 // specified without precision or scale
151                 // return BigInteger in that case
152                 if ((precValue <= 0) && (scaleValue <= 0)){
153                     return BigInteger  .class;
154                 }
155 
156                 if (scaleValue > 0) {
157                     return BigDecimal  .class;
158                 }
159                 if (precValue > 18) {
160                     return BigInteger  .class;
161                 }
162                 if (precValue > 9) {
163                     return (isNullable ? Long  .class : Long.TYPE);
164                 }
165                 if (precValue > 4) {
166                     return (isNullable ? Integer  .class : Integer.TYPE);
167                 }
168                 return (isNullable ? Short  .class : Short.TYPE);
169             case Types.FLOAT:
170             case Types.DOUBLE:
171             case Types.REAL:
172             case Types.BIGINT:
173             case Types.INTEGER:
174             case Types.SMALLINT:
175             case Types.TINYINT:
176             case Types.BIT:
177                 return typeList[isNullable ? 0 : 1];
178             default:
179                 return null;
180         }
181     }
182  
183     /**
184      * Return list of classes where class.isPrimitive() == false.
185      * @return list of java.lang.Class elements that can represent this type
186      */
187     public List getValidObjects() {
188         List classList = getValidClasses();
189         Iterator it = classList.iterator();
190         while (it.hasNext()) {
191             if (((Class  ) it.next()).isPrimitive()) {
192                 it.remove();
193             }
194         }
195         return classList;
196     }
197     
198     public boolean supportsFinder() {
199         return supportsFinder;
200     }
201     
202     /**
203      * Return create SQLType.
204      * @param sqlType value from java.sql.Types
205      * @return SQLType or null if type cannot be created
206      */
207     public static SQLType getSQLType(int sqlType) {
208         List types = getSQLTypes();
209         int ind = types.indexOf(new SQLType(sqlType, null, null, false));
210     return ind==-1?UNKNOWN:(SQLType)types.get(ind);
211     }
212     
213     private static List getSQLTypes() {
214         List types = (List) typeCache.get();
215         if (types == null) {
216             types = getAllSQLTypes();
217             typeCache = new SoftReference  (types);
218         }
219         return types;
220     }
221     
222     private static List getAllSQLTypes() {
223         return Arrays.asList(new SQLType[] {
224             new SQLType(Types.ARRAY, "ARRAY",   //NOI18N
225                 new Class  [0], false), 
226             new SQLType(Types.BIGINT, "BIGINT",     //NOI18N
227                 new Class  [] {java.math.BigInteger  .class, Long.TYPE}, true),
228             new SQLType(Types.DECIMAL, "DECIMAL",   //NOI18N
229                 new Class  [] {java.math.BigDecimal  .class, java.math.BigInteger  .class, 
230                     Short  .class, Short.TYPE, Integer  .class, Integer.TYPE, 
231                     Long  .class, Long.TYPE}, true),
232             new SQLType(Types.NUMERIC, "NUMERIC",   //NOI18N
233                 new Class  [] {java.math.BigDecimal  .class, java.math.BigInteger  .class, 
234                     Short  .class, Short.TYPE, Integer  .class, Integer.TYPE, 
235                     Long  .class, Long.TYPE}, true),
236             new SQLType(Types.BLOB, "BLOB",         //NOI18N
237                 new Class  [0], false),
238             new SQLType(Types.CHAR, "CHAR",         //NOI18N
239                 new Class  [] {java.lang.String  .class, Character  .class, Character.TYPE}, true),
240             new SQLType(Types.LONGVARCHAR, "LONGVARCHAR",   //NOI18N
241                 new Class  [] {java.lang.String  .class}, true),
242             new SQLType(Types.VARCHAR, "VARCHAR",           //NOI18N
243                 new Class  [] {java.lang.String  .class}, true),
244             new SQLType(Types.CLOB, "CLOB",                 //NOI18N
245                 new Class  [] {java.lang.String  .class}, false),
246             new SQLType(Types.DATE, "DATE",                 //NOI18N
247                 new Class  [] {java.sql.Date  .class}, false),
248             new SQLType(Types.FLOAT, "FLOAT",               //NOI18N
249                 new Class  [] {Double  .class, Double.TYPE}, true),
250             new SQLType(Types.DOUBLE, "DOUBLE",             //NOI18N
251                 new Class  [] {Double  .class, Double.TYPE}, true),
252             new SQLType(Types.REAL, "REAL",                 //NOI18N
253                 new Class  [] {Float  .class, Float.TYPE}, true),   
254             new SQLType(Types.INTEGER, "INTEGER",           //NOI18N
255                 new Class  [] {Integer  .class, Integer.TYPE}, true),
256             new SQLType(Types.JAVA_OBJECT, "JAVA_OBJECT",   //NOI18N
257                 new Class  [0], false),
258         new SQLType(Types.NULL, "NULL",                 //NOI18N
259                 new Class  [0], false),
260             new SQLType(Types.OTHER, "OTHER",               //NOI18N
261                 new Class  []{Object  .class}, true),    
262             new SQLType(Types.STRUCT, "STRUCT",             //NOI18N
263                 new Class  [0], false),
264             new SQLType(Types.DISTINCT, "DISTINCT",         //NOI18N
265                 new Class  [0], false),
266             new SQLType(Types.BINARY, "BINARY",             //NOI18N
267                 new Class  [] { byte[].class}, false),
268             new SQLType(Types.BIT, "BIT",                   //NOI18N
269                 new Class  [] {Boolean  .class, Boolean.TYPE}, true),
270             new SQLType(Types.VARBINARY, "VARBINARY",       //NOI18N
271                 new Class  [] {byte[].class}, false),
272             new SQLType(Types.LONGVARBINARY, "LONGVARBINARY",   //NOI18N
273                 new Class  [] {byte[].class}, false),
274             new SQLType(Types.REF, "REF",                   //NOI18N
275                 new Class  [0], false),
276             new SQLType(Types.SMALLINT, "SMALLINT",         //NOI18N
277                 new Class  [] {Short  .class, Short.TYPE}, true),
278             new SQLType(Types.TINYINT, "TINYINT",           //NOI18N
279                 new Class  [] {Short  .class, Short.TYPE}, true),
280             new SQLType(Types.TIME, "TIME",                 //NOI18N
281                 new Class  [] {java.sql.Time  .class}, false),
282             new SQLType(Types.TIMESTAMP, "TIMESTAMP",       //NOI18N
283                 new Class  [] {java.sql.Timestamp  .class}, false)
284         });
285     }
286     
287     private static SoftReference   typeCache = new SoftReference  (null);
288 }
289     
290
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags