|
1 package in.co.daffodil.db.jdbc;
2
3 import java.sql.*;
4 import com.daffodilwoods.database.resource.*;
5 import java.util.TreeMap  ;
6 import java.text.DateFormat ;
7 import com.daffodilwoods.daffodildb.server.datasystem.interfaces.Datatype;
8 import in.co.daffodil.db.general.*;
9
10 public class Utilities {
11
12 private static TreeMap databaseTypesMap = new TreeMap (String.CASE_INSENSITIVE_ORDER);
13 static {
14 databaseTypesMap.put("CHARACTER", new Integer (Datatype.CHARACTER));
15 databaseTypesMap.put("INTEGER", new Integer (Datatype.INTEGER));
16 databaseTypesMap.put("LONG", new Integer (Datatype.LONG));
17 databaseTypesMap.put("SHORT", new Integer (Datatype.SHORT));
18 databaseTypesMap.put("BOOLEAN", new Integer (Datatype.BOOLEAN));
19 databaseTypesMap.put("FLOAT", new Integer (Datatype.FLOAT));
20 databaseTypesMap.put("DOUBLE", new Integer (Datatype.DOUBLE));
21 databaseTypesMap.put("DATE", new Integer (Datatype.DATE));
22 databaseTypesMap.put("MODULE", new Integer (Datatype.MODULE));
23 databaseTypesMap.put("SUM", new Integer (Datatype.SUM));
24 databaseTypesMap.put("ARRAY", new Integer (Datatype.ARRAY));
25 databaseTypesMap.put("RECORD", new Integer (Datatype.RECORD));
26 databaseTypesMap.put("RECORDSET", new Integer (Datatype.RECORDSET));
27 databaseTypesMap.put("BIGDECIMAL", new Integer (Datatype.BIGDECIMAL));
28 databaseTypesMap.put("TIME", new Integer (Datatype.TIME));
29 databaseTypesMap.put("TIMESTAMP", new Integer (Datatype.TIMESTAMP));
30 databaseTypesMap.put("BYTE", new Integer (Datatype.BYTE));
31 databaseTypesMap.put("BLOB", new Integer (Datatype.BLOB));
32 databaseTypesMap.put("CLOB", new Integer (Datatype.CLOB));
33 databaseTypesMap.put("REF", new Integer (Datatype.REF));
34 databaseTypesMap.put("STRUCT", new Integer (Datatype.STRUCT));
35 databaseTypesMap.put("VARCHAR", new Integer (Datatype.VARCHAR));
36 databaseTypesMap.put("CHAR", new Integer (Datatype.CHAR));
37 databaseTypesMap.put("CHARACTER VARYING", new Integer (Datatype.CHARACTERVARYING));
38 databaseTypesMap.put("CHAR VARYING", new Integer (Datatype.CHARVARYING));
39 databaseTypesMap.put("CHARACTER LARGE OBJECT", new Integer (Datatype.CHARACTERLARGEOBJECT));
40 databaseTypesMap.put("CHAR LARGE OBJECT", new Integer (Datatype.CHARLARGEOBJECT));
41 databaseTypesMap.put("BINARY LARGE OBJECT", new Integer (Datatype.BINARYLARGEOBJECT));
42 databaseTypesMap.put("BIT", new Integer (Datatype.BIT));
43 databaseTypesMap.put("BIT VARYING", new Integer (Datatype.BITVARYING));
44 databaseTypesMap.put("NUMERIC", new Integer (Datatype.NUMERIC));
45 databaseTypesMap.put("DECIMAL", new Integer (Datatype.DECIMAL));
46 databaseTypesMap.put("DEC", new Integer (Datatype.DEC));
47 databaseTypesMap.put("INT", new Integer (Datatype.INT));
48 databaseTypesMap.put("REAL", new Integer (Datatype.REAL));
49 databaseTypesMap.put("DOUBLE PRECISION", new Integer (Datatype.DOUBLEPRECISION));
50 databaseTypesMap.put("SMALLINT", new Integer (Datatype.SMALLINT));
51 databaseTypesMap.put("BINARY", new Integer (Datatype.BINARY));
52 databaseTypesMap.put("BIGINT", new Integer (Datatype.BIGINT));
53 databaseTypesMap.put("LONG VARBINARY", new Integer (Datatype.LONGVARBINARY));
54 databaseTypesMap.put("LONG VARCHAR", new Integer (Datatype.LONGVARCHAR));
55 databaseTypesMap.put("TINYINT", new Integer (Datatype.TINYINT));
56 databaseTypesMap.put("VARBINARY", new Integer (Datatype.VARBINARY));
57 };
58
59 public Utilities() {
60 }
61
62 public static String getDataBaseTypeName(int databaseType) throws DException {
63 switch (databaseType) {
64 case Datatype.CHARACTER:
65 return "CHARACTER";
66 case Datatype.INTEGER:
67 return "INTEGER";
68 case Datatype.LONG:
69 return "LONG";
70 case Datatype.SHORT:
71 return "SHORT";
72 case Datatype.BOOLEAN:
73 return "BOOLEAN";
74 case Datatype.FLOAT:
75 return "FLOAT";
76 case Datatype.DOUBLE:
77 return "DOUBLE";
78 case Datatype.DATE:
79 return "DATE";
80 case Datatype.MODULE:
81 return "MODULE";
82 case Datatype.SUM:
83 return "SUM";
84 case Datatype.ARRAY:
85 return "ARRAY";
86 case Datatype.RECORD:
87 return "RECORD";
88 case Datatype.RECORDSET:
89 return "RECORDSET";
90 case Datatype.BIGDECIMAL:
91 return "BIGDECIMAL";
92 case Datatype.TIME:
93 return "TIME";
94 case Datatype.TIMESTAMP:
95 return "TIMESTAMP";
96 case Datatype.BYTE:
97 return "BYTE";
98 case Datatype.BLOB:
99 return "BLOB";
100 case Datatype.CLOB:
101 return "CLOB";
102 case Datatype.REF:
103 return "REF";
104 case Datatype.STRUCT:
105 return "STRUCT";
106
107 case Datatype.VARCHAR:
108 return "VARCHAR";
109 case Datatype.CHAR:
110 return "CHAR";
111 case Datatype.CHARACTERVARYING:
112 return "CHARACTER VARYING";
113 case Datatype.CHARVARYING:
114 return "CHAR VARYING";
115 case Datatype.CHARACTERLARGEOBJECT:
116 return "CHARACTER LARGE OBJECT";
117 case Datatype.CHARLARGEOBJECT:
118 return "CHAR LARGE OBJECT";
119 case Datatype.BINARYLARGEOBJECT:
120 return "BINARY LARGE OBJECT";
121 case Datatype.BIT:
122 return "BIT";
123 case Datatype.BITVARYING:
124 return "BIT VARYING";
125 case Datatype.NUMERIC:
126 return "NUMERIC";
127 case Datatype.DECIMAL:
128 return "DECIMAL";
129 case Datatype.DEC:
130 return "DEC";
131 case Datatype.INT:
132 return "INT";
133 case Datatype.REAL:
134 return "REAL";
135 case Datatype.DOUBLEPRECISION:
136 return "DOUBLE PRECISION";
137 case Datatype.SMALLINT:
138 return "SMALLINT";
139 case Datatype.LONGVARCHAR:
140 return "LONG VARCHAR";
141 case Datatype.LONGVARBINARY:
142 return "LONG VARBINARY";
143 case Datatype.BINARY:
144 return "BINARY";
145 case Datatype.BIGINT:
146 return "BIGINT";
147 case Datatype.VARBINARY:
148 return "VARBINARY";
149 case Datatype.TINYINT:
150 return "TINYINT";
151 }
152 DException dex = new DException("DSE1018", new Object [] {new Integer (databaseType)});
153 throw dex;
154
155 }
156
157 public static int getCorrespondingSqlTypeOfDatabaseType(int type) throws DException {
158 switch (type) {
159 case Datatype.CHAR:
160 case Datatype.CHARACTER:
161 return Types.CHAR;
162 case Datatype.INT:
163 case Datatype.INTEGER:
164 return Types.INTEGER;
165 case Datatype.BIGINT:
166 case Datatype.LONG:
167 return Types.BIGINT;
168 case Datatype.SMALLINT:
169 case Datatype.SHORT:
170 return Types.SMALLINT;
171 case Datatype.BOOLEAN:
172 return Types.BOOLEAN;
173 case Datatype.REAL:
174 return Types.REAL;
175 case Datatype.FLOAT:
176 return Types.FLOAT;
177 case Datatype.DOUBLEPRECISION:
178 case Datatype.DOUBLE:
179 return Types.DOUBLE;
180 case Datatype.DATE:
181 return Types.DATE;
182 case Datatype.MODULE:
183 return Types.DATE;
184 case Datatype.SUM:
185 return Types.DOUBLE;
186 case Datatype.ARRAY:
187 return Types.ARRAY;
188 case Datatype.RECORD:
189 return Types.BIGINT;
190 case Datatype.NUMERIC:
191 return Types.NUMERIC;
192 case Datatype.DECIMAL:
193 case Datatype.DEC:
194 case Datatype.BIGDECIMAL:
195 return Types.DECIMAL;
196 case Datatype.TIME:
197 return Types.TIME;
198 case Datatype.TIMESTAMP:
199 return Types.TIMESTAMP;
200 case Datatype.TINYINT:
201 case Datatype.BYTE:
202 return Types.TINYINT;
203 case Datatype.LONGVARBINARY:
204 return Types.LONGVARBINARY;
205 case Datatype.BINARYLARGEOBJECT:
206
207 case Datatype.BLOB:
208 return Types.BLOB;
209 case Datatype.CHARACTERLARGEOBJECT:
210 case Datatype.CHARLARGEOBJECT:
211 case Datatype.CLOB:
212 return Types.CLOB;
213 case Datatype.LONGVARCHAR:
214 return Types.LONGVARCHAR;
215 case Datatype.REF:
216 return Types.REF;
217 case Datatype.STRUCT:
218 return Types.STRUCT;
219
220 case Datatype.CHARACTERVARYING:
221 case Datatype.CHARVARYING:
222 case Datatype.VARCHAR:
223 return Types.VARCHAR;
224 case Datatype.BIT:
225 return Types.BIT;
226 case Datatype.BITVARYING:
227 return Types.VARBINARY;
228 case Datatype.BINARY:
229 return Types.BINARY;
230 case Datatype.VARBINARY:
231 return Types.VARBINARY;
232 }
233 return Types.OTHER;
234
235 }
236
237 public static String getCorrespondingJavaClassesOfSqlTypes(int type) {
238 switch (type) {
239 case Types.VARCHAR:
240 case Types.LONGVARCHAR:
241 case Types.CHAR:
242 return "java.lang.String";
243 case Types.INTEGER:
244 return "java.lang.Integer";
245 case Types.BIGINT:
246 return "java.lang.Long";
247 case Types.SMALLINT:
248 return "java.lang.Short";
249
250 case Types.BIT:
251 case 16:
252 return "java.lang.Boolean";
254 case Types.REAL:
255 return "java.lang.Float";
256 case Types.FLOAT:
257 case Types.DOUBLE:
258 return "java.lang.Double";
259
260 case Types.TINYINT:
261 return "java.lang.Byte";
262
263 case Types.NUMERIC:
264 case Types.DECIMAL:
265 return "java.math.BigDecimal";
266 case Types.DATE:
267 return "java.sql.Date";
268 case Types.TIME:
269 return "java.sql.Time";
270 case Types.TIMESTAMP:
271 return "java.sql.TimeStamp";
272
273 case Types.BINARY:
274 case Types.VARBINARY:
275 case Types.LONGVARBINARY:
276 return "java.lang.String"; case Types.ARRAY:
278 return "java.sql.Array";
279 case Types.CLOB:
280 return "java.sql.Clob";
281 case Types.BLOB:
282 return "java.sql.Blob";
283 case Types.REF:
284 return "java.sql.Ref";
285 case Types.STRUCT:
286 return "java.sql.Struct";
287 }
288 return "java.lang.Object";
289
290 }
291
292 public static int getDataBaseType(String databaseType) throws SQLException {
293 databaseType = databaseType.toUpperCase();
294 if (databaseTypesMap.containsKey(databaseType))
295 return databaseTypesMap.get(databaseType).hashCode();
296 throw new SQLException( );
297 }
298
299 public static Object convertObject(Object value, int requiredType) throws SQLException, DException {
300 if (value == null)
301 return null;
302 return DTConvertor.getInstance().getObject(value, requiredType);
303 }
304
305 public static Object convertObject(Object value, SQLType sqlType) throws SQLException, DException {
306 if (value == null) {
307 return null;
308 }
309 Object newvalue = convertObject(value, sqlType.type);
310 if (sqlType.getType() == Types.NUMERIC || sqlType.getType() == Types.DECIMAL) {
311 if (sqlType.scale != -1) {
312 newvalue = ( (java.math.BigDecimal ) newvalue).setScale(sqlType.getScale(), java.math.BigDecimal.ROUND_DOWN);
313 }
314 }
315 return newvalue;
316 }
317
318 static int implicit_maximum_numeric_precision = -1;
319 public static int getDispalySize(int sqlType, int precision, int charSize) throws DException {
320 switch (sqlType) {
321 case Types.BINARY:
322 case Types.VARBINARY:
323 case Types.VARCHAR:
324 case Types.CHAR:
325 return charSize;
326 case Types.INTEGER:
327 return precision == -1 ? 11 : precision + 1;
328 case Types.BIGINT:
329 return precision == -1 ? 20 : precision + 1;
330 case Types.SMALLINT:
331 return precision == -1 ? 6 : precision + 1;
332
333 case Types.BIT:
334 case 16: return 1;
336
337 case Types.REAL:
338 return precision == -1 ? 14 : precision + 7;
339 case Types.FLOAT:
340 case Types.DOUBLE:
341 return precision == -1 ? 24 : precision + 9;
342
343 case Types.TINYINT:
344 return precision == -1 ? 4 : precision + 1;
345 case Types.NUMERIC:
346 case Types.DECIMAL:
347 return precision == -1 ? implicit_maximum_numeric_precision + 2
348 : precision + 2;
349
350 case Types.DATE:
351 return 19;
352 case Types.TIME:
353 return 19;
354 case Types.TIMESTAMP:
355 return 23;
356
357 case Types.ARRAY:
358 return -1;
359 case Types.LONGVARCHAR:
360 case Types.CLOB:
361 return 2147483647;
362 case Types.LONGVARBINARY:
363 case Types.BLOB:
364 return -2;
365 case Types.REF:
366 return -1;
367 case Types.STRUCT:
368 return -1;
369 }
370 return -1;
371
372 }
373
374 public static boolean isConvertable(int fromSqlType, int toSqlType) throws SQLException {
375 if (toSqlType == fromSqlType)
376 return true;
377 switch (toSqlType) {
378 case Types.TINYINT:
379 case Types.SMALLINT:
380 case Types.INTEGER:
381 case Types.BIGINT:
382 case Types.FLOAT:
383 case Types.DOUBLE:
384 case Types.REAL:
385 case Types.DECIMAL:
386 case Types.NUMERIC:
387 case Types.BINARY:
388 case Types.VARBINARY:
389 case Types.CHAR:
390 case Types.VARCHAR:
391 case Types.LONGVARCHAR:
392 case Types.TIMESTAMP:
393 case Types.DATE:
394 return fromSqlType == Types.DATE || fromSqlType == Types.TIMESTAMP ||
395 fromSqlType == Types.CHAR || fromSqlType == Types.VARCHAR ||
396 fromSqlType == Types.LONGVARCHAR;
397 case Types.TIME:
398 return fromSqlType == Types.TIME || fromSqlType == Types.TIMESTAMP ||
399 fromSqlType == Types.CHAR || fromSqlType == Types.VARCHAR ||
400 fromSqlType == Types.LONGVARCHAR;
401
402 case Types.BLOB:
403 case Types.CLOB:
404 return true;
405 }
406 return false;
407
408 }
409
410 public static byte[] convertCharsToBytes(char[] chars) throws sun.io.MalformedInputException {
411 return sun.io.CharToByteConverter.getDefault().convertAll(chars);
412 }
413
414 public static char[] convertBytesToChars(byte[] bytes) throws sun.io.MalformedInputException {
415 return sun.io.ByteToCharASCII.getDefault().convertAll(bytes);
416 }
417
418 public static byte[] convertBytesToUnicodeBytes(byte[] bytes) throws sun.io.MalformedInputException, SQLException {
419 char[] chars = sun.io.ByteToCharASCII.getDefault().convertAll(bytes);
420 return sun.io.CharToByteUnicode.getDefault().convertAll(chars);
421
422 }
423
424 public static byte[] convertBytesToAsciiBytes(byte[] bytes) throws sun.io.MalformedInputException, SQLException {
425 char[] chars = sun.io.ByteToCharASCII.getDefault().convertAll(bytes);
426 return sun.io.CharToByteASCII.getDefault().convertAll(chars);
427
428 }
429
430 public static byte[] convertUnicodeBytesToBytes(byte[] unicodeBytes) throws sun.io.MalformedInputException, SQLException {
431 char[] chars = sun.io.ByteToCharUnicode.getDefault().convertAll(unicodeBytes);
432 return sun.io.CharToByteConverter.getDefault().convertAll(chars);
433 }
434
435 public static byte[] convertAsciiBytesToBytes(byte[] asciiBytes) throws sun.io.MalformedInputException, SQLException {
436 char[] chars = sun.io.ByteToCharASCII.getDefault().convertAll(asciiBytes);
437 return sun.io.CharToByteConverter.getDefault().convertAll(chars);
438
439 }
440
441 public static int getPrecision(int type) throws DException {
442 switch (type) {
443 case Types.SMALLINT:
444 return Datatype.SHORT_PRECISION;
445 case Types.VARCHAR:
446 return 1024; }
448 return 0;
449
450 }
451 public static Boolean getBooleanValue(boolean value){
452 return value ? Boolean.TRUE : Boolean.FALSE ;
453 }
454 public static Object calculatehashCode(String query, int resultSetType,
455 int resultSetConcurrency,
456 int resultSetHoldability) {
457 int hashCode = 1;
458 hashCode = 31 * hashCode + (query == null ? 0 : query.hashCode());
459 hashCode = 31 * hashCode + resultSetConcurrency;
460 hashCode = 31 * hashCode + resultSetType;
461 hashCode = 31 * hashCode + resultSetHoldability;
462 return new Integer (hashCode);
463 }
464
465 }
466 |
Popular Tags |
Java API By Example, From Geeks To Geeks.