|
1 package com.daffodilwoods.daffodildb.utils;
2
3 import java.math.*;
4 import java.sql.*;
5 import com.daffodilwoods.daffodildb.server.datasystem.interfaces.*;
6 import com.daffodilwoods.daffodildb.server.datasystem.persistentsystem.*;
7 import com.daffodilwoods.daffodildb.server.sql99.common.*;
8 import com.daffodilwoods.daffodildb.utils.byteconverter.*;
9 import com.daffodilwoods.daffodildb.utils.comparator.*;
10 import com.daffodilwoods.daffodildb.utils.field.*;
11 import com.daffodilwoods.database.general.*;
12 import com.daffodilwoods.database.resource.*;
13 import com.daffodilwoods.daffodildb.utils.comparator.SuperComparator;
14 import com.daffodilwoods.daffodildb.utils.field.*;
15 import com.daffodilwoods.daffodildb.utils.FieldBaseConverter;
16 import com.daffodilwoods.daffodildb.server.datasystem.persistentsystem.DBlobUpdatable;
17 import java.text.Collator  ;
18 import com.daffodilwoods.database.utility.*;
19 import java.util.Calendar ;
20 import java.util.GregorianCalendar ;
21 import java.util.Arrays ;
22
23 public class FieldUtility {
24
25 public static BufferRange NULLBUFFERRANGE = new BufferRange(true);
26 public static FieldBase NULLFIELDBASE = new FieldLiteral(NULLBUFFERRANGE, -1);
27 public static final FieldBase Int1 = new FieldLiteral(new Integer (1), Datatype.INTEGER);
28 public static final FieldBase Int0 = new FieldLiteral(new Integer (0), Datatype.INTEGER);
29 public static final FieldBase Int_1 = new FieldLiteral(new Integer ( -1), Datatype.INTEGER);
30
31 public static FieldBase convertToAppropriateType(FieldBase field, int datatype, int size, Collator collator) throws DException {
32 return convertToAppropriateType(field, datatype, size, -1, collator);
33 }
34
35 public static FieldBase convertToAppropriateType(FieldBase field, int datatype, int size, int scale, Collator collator) throws DException {
36 int fieldType = field.getDatatype();
37 if (fieldType == Datatypes.DEFAULT_DATATYPE)
38 return field;
39
40 if (field.isNull()) {
41 FieldBase convertedField = getField(datatype, null, collator);
42 convertedField.setBufferRange(NULLBUFFERRANGE);
43 return convertedField;
44 }
45 if (fieldType == -1) {
46 try {
47 field.setDatatype( -1);
48 } catch (Exception ex) {
49 throw new RuntimeException (ex.getMessage());
50 }
51 fieldType = field.getDatatype();
52 }
53 FieldBase convertedField;
54 switch (datatype) {
55 case Datatype.BIGDECIMAL:
56 case Datatype.DEC:
57 case Datatype.DECIMAL:
58 case Datatype.NUMERIC:
59 switch (fieldType) {
60 case Datatype.BOOLEAN:
61 if (scale == 0)
62 return new FieldBigDecimal(
63 new BufferRange(Boolean.TRUE.equals(field.getObject()) ? "1".getBytes() : "0".getBytes()),
64 datatype);
65 convertedField = new FieldBigDecimal(
66 new BufferRange(Boolean.TRUE.equals(field.getObject()) ? "1.0".getBytes() : "0.0".getBytes()),
67 datatype);
68 return convertedField;
69 case Datatype.BIGDECIMAL:
70 case Datatype.DEC:
71 case Datatype.DECIMAL:
72 case Datatype.NUMERIC:
73 scale = scale < 0 ? 0 : scale;
74 checkPrecisionScale(field.getObject().toString(), size, scale);
75 BigDecimal bd = ( (BigDecimal) field.getObject());
76 bd = bd.setScale(scale, BigDecimal.ROUND_HALF_EVEN);
77 convertedField = new FieldBigDecimal(field.getBufferRange() == null ? new BufferRange(CCzufDpowfsufs.getBytes(bd)) : field.getBufferRange(), datatype);
78 return convertedField;
79 case Datatype.LONG:
80 case Datatype.BIGINT:
81 case Datatype.SHORT:
82 case Datatype.SMALLINT:
83 case Datatype.DOUBLE:
84 case Datatype.DOUBLEPRECISION:
85 case Datatype.FLOAT:
86 case Datatype.REAL:
87 case Datatype.TINYINT:
88 case Datatype.BYTE:
89 case Datatype.INT:
90 case Datatype.INTEGER:
91 scale = scale < 0 ? 0 : scale;
92 checkPrecisionScale(field.getObject().toString(), size, scale);
93 bd = new BigDecimal( (field.getObject().toString()));
94 bd = bd.setScale(scale, BigDecimal.ROUND_HALF_EVEN);
95 convertedField = new FieldBigDecimal(new BufferRange(CCzufDpowfsufs.getBytes(bd)), datatype);
96 return convertedField;
97 case Datatype.CHAR:
98 case Datatype.CHARACTER:
99 case Datatype.CHARACTERVARYING:
100 case Datatype.CHARVARYING:
101 case Datatype.VARCHAR:
102 default:
103 try {
104 scale = scale < 0 ? 0 : scale;
105 checkPrecisionScale(field.getObject().toString(), size, scale);
106 bd = new BigDecimal( (field.getObject().toString()));
107 bd = bd.setScale(scale, BigDecimal.ROUND_HALF_EVEN);
108 convertedField = new FieldBigDecimal(
109 new BufferRange(CCzufDpowfsufs.getBytes(bd)),
110 datatype);
111 return convertedField;
112 } catch (RuntimeException ex) {
113 throw new DException("DSE773", new Object [] {field.getObject(), StaticClass.getDataTypeName(datatype)});
114 }
115
116 }
117 case Datatype.BIGINT:
118 case Datatype.LONG:
119 switch (fieldType) {
120 case Datatype.BIGINT:
121 case Datatype.LONG:
122 convertedField = new FieldLong(field.getBufferRange() == null ? new BufferRange(CCzufDpowfsufs.getBytes( (Long ) field.getObject())) : field.getBufferRange(), datatype);
123 return convertedField;
124 case Datatype.BIGDECIMAL:
125 case Datatype.DEC:
126 case Datatype.DECIMAL:
127 case Datatype.NUMERIC:
128 TypeValidityHandler.checkLongWithBigDecimal(field);
129 convertedField = new FieldLong(
130 new BufferRange(CCzufDpowfsufs.getBytes( ( (BigDecimal) field.getObject()).longValue())),
131 datatype);
132 return convertedField;
133 case Datatype.BOOLEAN:
134 convertedField = new FieldLong(
135 new BufferRange(CCzufDpowfsufs.getBytes(Boolean.TRUE.equals(field.getObject()) ? 1 : 0)),
136 datatype);
137 return convertedField;
138 case Datatype.DOUBLE:
139 case Datatype.DOUBLEPRECISION:
140 case Datatype.FLOAT:
141 TypeValidityHandler.checkLongWithDouble(field);
142 convertedField = new FieldLong(
143 new BufferRange(CCzufDpowfsufs.getBytes( ( (Number ) field.getObject()).longValue())),
144 datatype);
145 return convertedField;
146 case Datatype.REAL:
147 TypeValidityHandler.checkLongWithFloat(field);
148 convertedField = new FieldLong(
149 new BufferRange(CCzufDpowfsufs.getBytes( ( (Number ) field.getObject()).longValue())),
150 datatype);
151 return convertedField;
152 case Datatype.INT:
153 case Datatype.INTEGER:
154 case Datatype.SHORT:
155 case Datatype.SMALLINT:
156 case Datatype.TINYINT:
157 case Datatype.BYTE:
158 convertedField = new FieldLong(
159 new BufferRange(CCzufDpowfsufs.getBytes( ( (Number ) field.getObject()).longValue())),
160 datatype);
161 return convertedField;
162 default:
163 try {
164 convertedField = new FieldLong(
165 new BufferRange(CCzufDpowfsufs.getBytes(new Long (field.getObject().toString()))),
166 datatype);
167 return convertedField;
168 } catch (RuntimeException re) {
169 throw new DException("DSE773", new Object [] {field.getObject(), StaticClass.getDataTypeName(datatype)});
170 }
171
172 }
173 case Datatype.BOOLEAN:
174 switch (fieldType) {
175 case Datatype.BOOLEAN:
176 convertedField = new FieldBoolean(field.getBufferRange() == null ? new BufferRange(CCzufDpowfsufs.getBytes( (Boolean ) field.getObject())) : field.getBufferRange(), datatype);
177 return convertedField;
178 default:
179 try {
180 String ss =field.getObject().toString();
181
187 if(ss.equals("1")){
188 convertedField = new FieldBoolean(new BufferRange(CCzufDpowfsufs.getBytes(new Boolean (true))),datatype);
189 return convertedField;
190
191 } else {
192 convertedField = new FieldBoolean(new BufferRange(CCzufDpowfsufs.getBytes(new Boolean (ss))),datatype);
193 return convertedField;
194 }
195 } catch (RuntimeException re) {
196 throw new DException("DSE773", new Object [] {field.getObject(), StaticClass.getDataTypeName(datatype)});
197 }
198
199 }
200 case Datatype.TINYINT:
201 case Datatype.BYTE:
202 switch (fieldType) {
203 case Datatype.BYTE:
204 case Datatype.TINYINT:
205 convertedField = new FieldByte(field.getBufferRange() == null ? new BufferRange(CCzufDpowfsufs.getBytes( (Byte ) field.getObject())) : field.getBufferRange(), datatype);
206 return convertedField;
207 case Datatype.BOOLEAN:
208 convertedField = new FieldByte(
209 new BufferRange(Boolean.TRUE.equals(field.getObject()) ? new byte[] {1}
210 : new byte[] {0}),
211 datatype);
212 return convertedField;
213 case Datatype.INT:
214 case Datatype.INTEGER:
215 case Datatype.LONG:
216 case Datatype.BIGINT:
217 case Datatype.SHORT:
218 case Datatype.SMALLINT:
219 TypeValidityHandler.checkByteWithNonDecimal(field);
220 convertedField = new FieldByte(
221 new BufferRange(new byte[] { ( (Number ) field.getObject()).byteValue()}), datatype);
222 return convertedField;
223 case Datatype.DOUBLE:
224 case Datatype.DOUBLEPRECISION:
225 case Datatype.FLOAT:
226 TypeValidityHandler.checkByteWithDouble(field);
227 convertedField = new FieldByte(
228 new BufferRange(new byte[] { ( (Number ) field.getObject()).byteValue()}), datatype);
229 return convertedField;
230 case Datatype.REAL:
231 TypeValidityHandler.checkByteWithFloat(field);
232 convertedField = new FieldByte(
233 new BufferRange(new byte[] { ( (Number ) field.getObject()).byteValue()}), datatype);
234 return convertedField;
235 default:
236 try {
237 convertedField = new FieldByte(
238 new BufferRange(CCzufDpowfsufs.getBytes(new Byte (field.getObject().toString()))),
239 datatype);
240 return convertedField;
241 } catch (RuntimeException re) {
242 throw new DException("DSE773", new Object [] {field.getObject(), StaticClass.getDataTypeName(datatype)});
243 }
244
245 }
246 case Datatype.BINARY:
247 case Datatype.VARBINARY:
248 switch (fieldType) {
249 case Datatype.BINARY:
250 case Datatype.VARBINARY:
251 try {
252 if (field.getBufferRange().getLength() > size) {
253 throw new SizeMisMatchException("DSE773", new Object [] {field.getObject(), StaticClass.getDataTypeName(datatype)});
254 }
255 } catch (NullPointerException ex) {
256 throw ex;
257 }
258 byte[] bytes1 = (byte[]) field.getObject();
259 if (datatype == Datatype.BINARY) {
260 byte[] tmp1 = new byte[size];
261 Arrays.fill(tmp1, (byte) 0);
262 System.arraycopy(bytes1, 0, tmp1, (size - bytes1.length), bytes1.length);
263 bytes1 = tmp1;
264 }
265 convertedField = new FieldBinary(new BufferRange(bytes1), datatype);
266 return convertedField;
267 case Datatype.BLOB:
268 case Datatype.BINARYLARGEOBJECT:
269 case Datatype.LONGVARBINARY:
270 case Datatype.VARCHAR:
271 case Datatype.CHAR:
272 case Datatype.CHARACTER:
273 case Datatype.CHARACTERVARYING:
274 case Datatype.CHARVARYING:
275 try {
276 if (field.getBufferRange().getLength() > size) {
277 throw new SizeMisMatchException("DSE773", new Object [] {field.getObject(), StaticClass.getDataTypeName(datatype)});
278 }
279 } catch (NullPointerException ex) {
280 throw ex;
281 }
282 byte[] bytes = field.getBytes();
283 if (datatype == Datatype.BINARY) {
284 byte[] tmp = new byte[size];
285 Arrays.fill(tmp, (byte) 0);
286 System.arraycopy(bytes, 0, tmp, (size - bytes.length), bytes.length);
287 bytes = tmp;
288 }
289 convertedField = new FieldBinary(new BufferRange(bytes), datatype);
290 return convertedField;
291 case Datatype.SHORT:
292 case Datatype.SMALLINT:
293 case Datatype.TINYINT:
294 case Datatype.BYTE:
295 case Datatype.INT:
296 case Datatype.INTEGER:
297 convertedField = convertNonDecimalToBinary(field, size, fieldType);
298 return convertedField;
299 default:
300 throw new DException("DSE773", new Object [] {field.getObject(), StaticClass.getDataTypeName(datatype)});
301 }
302 case Datatype.CHARACTERLARGEOBJECT:
303 case Datatype.CHARLARGEOBJECT:
304 case Datatype.CLOB:
305 case Datatype.LONGVARCHAR:
306 switch (fieldType) {
307 case Datatype.CLOB:
308 try {
309 return new DClobUpdatable( ( (Clob) field.getObject()).getAsciiStream());
310 } catch (SQLException ex) {
311 throw new DException("DSE0", new Object [] {ex.getMessage()});
312 }
313 case Datatype.CHAR:
314 case Datatype.CHARACTER:
315 case Datatype.CHARACTERVARYING:
316 case Datatype.CHARVARYING:
317 case Datatype.VARCHAR:
318 return new DClobUpdatable( (String ) field.getObject());
319 case Datatype.BINARY:
320 case Datatype.VARBINARY:
321 return new DClobUpdatable( (byte[]) field.getObject());
322 default:
323 throw new DException("DSE773", new Object [] {field.getObject(), StaticClass.getDataTypeName(datatype)});
324 }
325 case Datatype.BLOB:
326 case Datatype.BINARYLARGEOBJECT:
327 case Datatype.LONGVARBINARY:
328 switch (fieldType) {
329 case Datatype.BLOB:
330 try {
331 return new DBlobUpdatable( ( (Blob) field.getObject()).getBinaryStream());
332 } catch (SQLException ex) {
333 throw new DException("DSE0", new Object [] {ex.getMessage()});
334 }
335 case Datatype.CHAR:
336 case Datatype.CHARACTER:
337 case Datatype.CHARACTERVARYING:
338 case Datatype.CHARVARYING:
339 case Datatype.VARCHAR:
340 return new DBlobUpdatable( (String ) field.getObject());
341 case Datatype.BINARY:
342 case Datatype.VARBINARY:
343 return new DBlobUpdatable( (byte[]) field.getObject());
344 default:
345 throw new DException("DSE773", new Object [] {field.getObject(), StaticClass.getDataTypeName(datatype)});
346 }
347
348 case Datatype.CHAR:
349 case Datatype.CHARACTER:
350 case Datatype.CHARACTERVARYING:
351 case Datatype.CHARVARYING:
352 case Datatype.VARCHAR:
353 switch (fieldType) {
354 case Datatype.BINARY:
355 case Datatype.VARBINARY:
356 case Datatype.BLOB:
357 case Datatype.BINARYLARGEOBJECT:
358 case Datatype.LONGVARBINARY:
359 throw new DException("DSE773", new Object [] {field.getObject(), StaticClass.getDataTypeName(datatype)});
360 case Datatype.CHARACTERLARGEOBJECT:
361 case Datatype.CHARLARGEOBJECT:
362 case Datatype.CLOB:
363 case Datatype.LONGVARCHAR:
364 if (field.getLength() > size){
365 ; throw new SizeMisMatchException("DSE773", new Object [] {field.getObject(), StaticClass.getDataTypeName(datatype)});
367 }
368 String ss1 = null;
369 try {
370 ss1 = ( (Clob) field.getObject()).getSubString(1, field.getLength());
371 } catch (SQLException ex) {
372 throw new DException("DSE0", new Object [] {ex.getMessage()});
373 }
374 convertedField = new FieldString(
375 new BufferRange(CCzufDpowfsufs.getBytes(ss1, datatype == Datatype.CHAR || datatype == Datatype.CHARACTER ? size : -1, collator != null)),
376 datatype, collator);
377 return convertedField;
378 default:
379 String ss = field.getObject().toString();
380 if (ss.length() > size) {
381 ; throw new SizeMisMatchException("DSE773", new Object [] {field.getObject(), StaticClass.getDataTypeName(datatype)});
383 }
384 convertedField = new FieldString(
385 new BufferRange(CCzufDpowfsufs.getBytes(ss, datatype == Datatype.CHAR || datatype == Datatype.CHARACTER ? size : -1, collator != null)),
386 datatype, collator);
387 return convertedField;
388 }
389
390 case Datatype.BIT:
391 case Datatype.BITVARYING:
392 switch (fieldType) {
393 case Datatype.BOOLEAN:
394 String s = field.getObject().toString().trim();
395 s = (s.equalsIgnoreCase("0") || s.equalsIgnoreCase("false")) ? "0" : "1";
396 if (s.length() > size)
397 throw new SizeMisMatchException("DSE773", new Object [] {field.getObject(), StaticClass.getDataTypeName(datatype)});
398 convertedField = new FieldString(new BufferRange(CCzufDpowfsufs.getBytes(s, datatype == Datatype.BIT ? size : -1, false)),
399 datatype, collator);
400 return convertedField;
401 default:
402 try {
403 String ss = field.getObject().toString().trim();
404 ss = (ss.equalsIgnoreCase("0") || ss.equalsIgnoreCase("false")) ? "0" : (ss.equalsIgnoreCase("1") || ss.equalsIgnoreCase("true")) ? "1" : ss;
405 if (ss.length() > size) {
406 ; throw new SizeMisMatchException("DSE773", new Object [] {field.getObject(), StaticClass.getDataTypeName(datatype)});
408 }
409 for (int i = 0; i < ss.length(); i++) {
410 if (! (ss.charAt(i) == '0' || ss.charAt(i) == '1')) {
411 throw new DException("DSE773", null);
412 }
413 }
414 convertedField = new FieldString(new BufferRange(CCzufDpowfsufs.getBytes(ss, datatype == Datatype.BIT ? size : -1, false)),
415 datatype, collator);
416 return convertedField;
417 } catch (RuntimeException re) {
418 throw new DException("DSE773", new Object [] {field.getObject(), StaticClass.getDataTypeName(datatype)});
419 }
420
421 }
422
423 case Datatype.DOUBLE:
424 case Datatype.DOUBLEPRECISION:
425 case Datatype.FLOAT:
426 switch (fieldType) {
427 case Datatype.DOUBLE:
428 case Datatype.DOUBLEPRECISION:
429 case Datatype.FLOAT:
430 convertedField = new FieldDouble(field.getBufferRange() == null ? new BufferRange(CCzufDpowfsufs.getBytes( (Double ) field.getObject())) : field.getBufferRange(), datatype);
431 return convertedField;
432 case Datatype.BIGDECIMAL:
433 TypeValidityHandler.checkDoubleWithBigDecimal(field);
434 convertedField = new FieldDouble(
435 new BufferRange(CCzufDpowfsufs.getBytes( ( (BigDecimal) field.getObject()).doubleValue())),
436 datatype);
437 return convertedField;
438 case Datatype.BOOLEAN:
439 convertedField = new FieldDouble(
440 new BufferRange(CCzufDpowfsufs.getBytes(Boolean.TRUE.equals(field.getObject()) ? 1d : 0d)),
441 datatype);
442 return convertedField;
443 case Datatype.INT:
444 case Datatype.INTEGER:
445 case Datatype.SHORT:
446 case Datatype.SMALLINT:
447 case Datatype.BIGINT:
448 case Datatype.LONG:
449 case Datatype.TINYINT:
450 case Datatype.BYTE:
451 convertedField = new FieldDouble(
452 new BufferRange(CCzufDpowfsufs.getBytes( ( (Number ) field.getObject()).doubleValue())),
453 Datatype.DOUBLE);
454 return convertedField;
455 case Datatype.REAL:
456 TypeValidityHandler.checkDoubleWithFloat(field);
457 convertedField = new FieldDouble(
458 new BufferRange(CCzufDpowfsufs.getBytes( ( (Number ) field.getObject()).doubleValue())),
459 Datatype.DOUBLE);
460 return convertedField;
461 default:
462 try {
463 convertedField = new FieldDouble(
464 new BufferRange(CCzufDpowfsufs.getBytes(new Double (field.getObject().toString()))),
465 datatype);
466 return convertedField;
467 } catch (RuntimeException re) {
468 throw new DException("DSE773", new Object [] {field.getObject(), StaticClass.getDataTypeName(datatype)});
469 }
470
471 }
472
473 case Datatype.INT:
474 case Datatype.INTEGER:
475 switch (fieldType) {
476 case Datatype.INT:
477 case Datatype.INTEGER:
478 convertedField = new FieldInteger(field.getBufferRange() == null ? new BufferRange(CCzufDpowfsufs.getBytes( (Integer ) field.getObject())) : field.getBufferRange(), datatype);
479 return convertedField;
480 case Datatype.BIGDECIMAL:
481 case Datatype.DEC:
482 case Datatype.DECIMAL:
483 case Datatype.NUMERIC:
484 TypeValidityHandler.checkIntegerWithBigDecimal(field);
485 convertedField = new FieldInteger(
486 new BufferRange(CCzufDpowfsufs.getBytes( ( (BigDecimal) field.getObject()).intValue())),
487 datatype);
488 return convertedField;
489 case Datatype.BOOLEAN:
490 convertedField = new FieldInteger(
491 new BufferRange(CCzufDpowfsufs.getBytes(Boolean.TRUE.equals(field.getObject()) ? 1 : 0)),
492 datatype);
493 return convertedField;
494 case Datatype.BIGINT:
495 case Datatype.LONG:
496 TypeValidityHandler.checkIntegerWithNonDecimal(field);
497 convertedField = new FieldInteger(
498 new BufferRange(CCzufDpowfsufs.getBytes( ( (Number ) field.getObject()).intValue())),
499 datatype);
500 return convertedField;
501 case Datatype.DOUBLE:
502 case Datatype.DOUBLEPRECISION:
503 case Datatype.FLOAT:
504 TypeValidityHandler.checkIntegerWithDouble(field);
505 convertedField = new FieldInteger(
506 new BufferRange(CCzufDpowfsufs.getBytes( ( (Number ) field.getObject()).intValue())),
507 datatype);
508 return convertedField;
509 case Datatype.REAL:
510 TypeValidityHandler.checkIntegerWithFloat(field);
511 convertedField = new FieldInteger(
512 new BufferRange(CCzufDpowfsufs.getBytes( ( (Number ) field.getObject()).intValue())),
513 datatype);
514 return convertedField;
515 case Datatype.SHORT:
516 case Datatype.SMALLINT:
517 case Datatype.TINYINT:
518 case Datatype.BYTE:
519 convertedField = new FieldInteger(
520 new BufferRange(CCzufDpowfsufs.getBytes( ( (Number ) field.getObject()).intValue())),
521 datatype);
522 return convertedField;
523 default:
524 try {
525 convertedField = new FieldInteger(
526 new BufferRange(CCzufDpowfsufs.getBytes(new Integer (field.getObject().toString()))),
527 datatype);
528 return convertedField;
529 } catch (RuntimeException re) {
530 throw new DException("DSE773", new Object [] {field.getObject(), StaticClass.getDataTypeName(datatype)});
531 }
532
533 }
534
535 case Datatype.REAL:
536 switch (fieldType) {
537 case Datatype.REAL:
538 convertedField = new FieldReal(field.getBufferRange() == null ? new BufferRange(CCzufDpowfsufs.getBytes( (Float ) field.getObject())) : field.getBufferRange(), datatype);
539 return convertedField;
540 case Datatype.BIGDECIMAL:
541 case Datatype.DEC:
542 case Datatype.DECIMAL:
543 case Datatype.NUMERIC:
544 TypeValidityHandler.checkFloatWithBigDecimal(field);
545 convertedField = new FieldReal(
546 new BufferRange(CCzufDpowfsufs.getBytes( ( (BigDecimal) field.getObject()).floatValue())),
547 datatype);
548 return convertedField;
549 case Datatype.BOOLEAN:
550 convertedField = new FieldReal(
551 new BufferRange(CCzufDpowfsufs.getBytes(Boolean.TRUE.equals(field.getObject()) ? 1.0f : 0.0f)),
552 datatype);
553 return convertedField;
554 case Datatype.SHORT:
555 case Datatype.SMALLINT:
556 case Datatype.BIGINT:
557 case Datatype.LONG:
558 case Datatype.INT:
559 case Datatype.INTEGER:
560 case Datatype.DOUBLE:
561 case Datatype.DOUBLEPRECISION:
562 case Datatype.TINYINT:
563 case Datatype.BYTE:
564 convertedField = new FieldReal(
565 new BufferRange(CCzufDpowfsufs.getBytes( ( (Number ) field.getObject()).floatValue())),
566 datatype);
567 return convertedField;
568 case Datatype.FLOAT:
569 TypeValidityHandler.checkFloatWithDouble(field);
570 convertedField = new FieldReal(
571 new BufferRange(CCzufDpowfsufs.getBytes( ( (Number ) field.getObject()).floatValue())),
572 datatype);
573 return convertedField;
574 default:
575 try {
576 convertedField = new FieldReal(
577 new BufferRange(CCzufDpowfsufs.getBytes(new Float (field.getObject().toString()))),
578 datatype);
579 return convertedField;
580 } catch (RuntimeException e) {
581 throw new DException("DSE773", new Object [] {field.getObject(), StaticClass.getDataTypeName(datatype)});
582 }
583
584 }
585
586 case Datatype.SHORT:
587 case Datatype.SMALLINT:
588
589 switch (fieldType) {
590 case Datatype.BYTE:
591 case Datatype.TINYINT:
592 convertedField = new FieldShort(new BufferRange(CCzufDpowfsufs.getBytes( ( (Number ) field.getObject()).shortValue())), datatype);
593 return convertedField;
594 case Datatype.SHORT:
595 case Datatype.SMALLINT:
596 convertedField = new FieldShort(field.getBufferRange() == null ? new BufferRange(CCzufDpowfsufs.getBytes( (Short ) field.getObject())) : field.getBufferRange(), datatype);
597 return convertedField;
598 case Datatype.BIGDECIMAL:
599 TypeValidityHandler.checkShortWithBigDecimal(field);
600 convertedField = new FieldShort(
601 new BufferRange(CCzufDpowfsufs.getBytes( ( (BigDecimal) field.getObject()).shortValue())),
602 datatype);
603 return convertedField;
604 case Datatype.BOOLEAN:
605 convertedField = new FieldShort(
606 new BufferRange(CCzufDpowfsufs.getBytes(Boolean.TRUE.equals(field.getObject()) ? new Short ("1") : new Short ("0"))),
607 datatype);
608 return convertedField;
609 case Datatype.BIGINT:
610 case Datatype.LONG:
611 case Datatype.INT:
612 case Datatype.INTEGER:
613 TypeValidityHandler.checkShortWithNonDecimal(field);
614 convertedField = new FieldShort(
615 new BufferRange(CCzufDpowfsufs.getBytes( ( (Number ) field.getObject()).shortValue())),
616 datatype);
617 return convertedField;
618 case Datatype.DOUBLE:
619 case Datatype.DOUBLEPRECISION:
620 case Datatype.FLOAT:
621 TypeValidityHandler.checkShortWithDouble(field);
622 convertedField = new FieldShort(
623 new BufferRange(CCzufDpowfsufs.getBytes( ( (Number ) field.getObject()).shortValue())),
624 datatype);
625 return convertedField;
626 case Datatype.REAL:
627 TypeValidityHandler.checkShortWithFloat(field);
628 convertedField = new FieldShort(
629 new BufferRange(CCzufDpowfsufs.getBytes( ( (Number ) field.getObject()).shortValue())),
630 datatype);
631 return convertedField;
632 default:
633 try {
634 convertedField = new FieldShort(
635 new BufferRange(CCzufDpowfsufs.getBytes(new Short (field.getObject().toString()))),
636 datatype);
637 return convertedField;
638 } catch (RuntimeException e) {
639 throw new DException("DSE773", new Object [] {field.getObject(), StaticClass.getDataTypeName(datatype)});
640 }
641
642 }
643
644 case Datatype.DATE:
645 switch (fieldType) {
646 case Datatype.DATE:
647 convertedField = new FieldDate(field.getBufferRange() == null ? new BufferRange(CCzufDpowfsufs.getBytes( (Date) field.getObject())) : field.getBufferRange(), datatype);
648 return convertedField;
649 case Datatype.TIMESTAMP:
650 convertedField = new FieldDate(
651 new BufferRange(CCzufDpowfsufs.getBytes(TypeValidityHandler.getDBDate( (Timestamp) field.getObject()))),
652 datatype);
653 return convertedField;
654 case Datatype.TIME:
655 throw new DException("DSE5547", new Object [] {"Time", "Date"});
656 case Datatype.CHAR:
657 case Datatype.CHARACTER:
658 case Datatype.CHARACTERVARYING:
659 case Datatype.CHARVARYING:
660 case Datatype.VARCHAR:
661 convertedField = new FieldDate(
662 new BufferRange(CCzufDpowfsufs.getBytes(TypeValidityHandler.getDBDateFromDateTimestamp( (String ) field.getObject()))),
663 datatype);
664 return convertedField;
665 default:
666 throw new DException("DSE773", new Object [] {field.getObject(), StaticClass.getDataTypeName(datatype)});
667 }
668
669 case Datatype.TIME:
670 switch (fieldType) {
671 case Datatype.TIME:
672 convertedField = new FieldTime(field.getBufferRange() == null ? new BufferRange(CCzufDpowfsufs.getBytes( (Time) field.getObject())) : field.getBufferRange(), datatype);
673 return convertedField;
674 case Datatype.TIMESTAMP:
675 convertedField = new FieldTime(
676 new BufferRange(CCzufDpowfsufs.getBytes(TypeValidityHandler.getTime( (Timestamp) field.getObject()))),
677 datatype);
678 return convertedField;
679 case Datatype.DATE:
680 throw new DException("DSE5547", new Object [] {"Date", "Time"});
681 case Datatype.CHAR:
682 case Datatype.CHARACTER:
683 case Datatype.CHARACTERVARYING:
684 case Datatype.CHARVARYING:
685 case Datatype.VARCHAR:
686 convertedField = new FieldTime(
687 new BufferRange(CCzufDpowfsufs.getBytes(TypeValidityHandler.getTimeFromTimeTimeStamp( (String ) field.getObject()))),
688 datatype);
689 return convertedField;
690 default:
691 throw new DException("DSE773", new Object [] {field.getObject(), StaticClass.getDataTypeName(datatype)});
692 }
693
694 case Datatype.TIMESTAMP:
695 switch (fieldType) {
696 case Datatype.TIMESTAMP:
697 convertedField = new FieldTimeStamp(field.getBufferRange() == null ? new BufferRange(CCzufDpowfsufs.getBytes( (Timestamp) field.getObject())) : field.getBufferRange(), datatype);
698 return convertedField;
699 case Datatype.TIME:
700 throw new DException("DSE5547", new Object [] {"Time", "Timestamp"});
701 case Datatype.DATE:
702 convertedField = new FieldTimeStamp(
703 new BufferRange(CCzufDpowfsufs.getBytes(new Timestamp( ( (Date) field.getObject()).getTime()))),
704 datatype);
705 return convertedField;
706 case Datatype.CHAR:
707 case Datatype.CHARACTER:
708 case Datatype.CHARACTERVARYING:
709 case Datatype.CHARVARYING:
710 case Datatype.VARCHAR:
711 convertedField = new FieldTimeStamp(
712 new BufferRange(CCzufDpowfsufs.getBytes(TypeValidityHandler.getTimeStampFromTimestampDate( (String ) field.getObject()))),
713 datatype);
714 return convertedField;
715 default:
716 throw new DException("DSE773", new Object [] {field.getObject(), StaticClass.getDataTypeName(datatype)});
717 }
718
719 case Datatype.ARRAY:
720 case Datatype.MODULE:
721 case Datatype.RECORD:
722 case Datatype.RECORDSET:
723 case Datatype.REF:
724 case Datatype.STRUCT:
725 case Datatype.SUM:
726 case Datatype.TIME_WITH_TIMEZONE:
727 case Datatype.TIMESTAMP_WITH_TIMEZONE:
728 throw new DException("DSE1133", new Object [] {new Integer (datatype)});
729 default:
730 throw new DException("DSE1021", new Object [] {new Integer (datatype)});
731 }
732 }
733
734 public static FieldBase[] convertToAppropriateType(FieldBase[] fields, int[] datatype, int[] size, int[] scale, Collator collator) throws DException {
735 if (fields == null)
736 return null;
737 FieldBase[] fieldsToReturn = new FieldBase[fields.length];
738 for (int i = 0; i < fields.length; i++)
739 fieldsToReturn[i] = convertToAppropriateType(fields[i], datatype[i], size[i], scale[i], collator);
740 return fieldsToReturn;
741 }
742
743 public static FieldBase[] convertToAppropriateType(Object [] fields, int[] datatype, int[] size, int[] scale, Collator collator) throws DException {
744 if (fields == null)
745 return null;
746 FieldBase[] fieldsToReturn = new FieldBase[fields.length];
747 for (int i = 0; i < fields.length; i++)
748 fieldsToReturn[i] = convertToAppropriateType( (FieldBase) fields[i], datatype[i], size[i], scale[i], collator);
749 return fieldsToReturn;
750 }
751
752 public static FieldBase getField(int datatype, Object values, Collator collator) throws DException {
753 switch (datatype) {
754 case Datatype.INT:
755 case Datatype.INTEGER:
756 return FieldBaseConverter.getFieldBase( (Integer ) values, datatype);
757 case Datatype.LONG:
758 case Datatype.BIGINT:
759 return FieldBaseConverter.getFieldBase( (Long ) values, datatype);
760 case Datatype.DOUBLE:
761 case Datatype.DOUBLEPRECISION:
762 case Datatype.FLOAT:
763 return FieldBaseConverter.getFieldBase( (Double ) values, datatype);
764 case Datatype.REAL:
765 return FieldBaseConverter.getFieldBase( (Float ) values, datatype);
766 case Datatype.SMALLINT:
767 case Datatype.SHORT:
768 return FieldBaseConverter.getFieldBase( (Short ) values, datatype);
769 case Datatype.TINYINT:
770 case Datatype.BYTE:
771 return FieldBaseConverter.getFieldBase( (Byte ) values, datatype);
772 case Datatype.BINARY:
773 case Datatype.VARBINARY:
774 return FieldBaseConverter.getFieldBase( (byte[]) values, datatype);
775 case Datatype.DEC:
776 case Datatype.DECIMAL:
777 case Datatype.NUMERIC:
778 case Datatype.BIGDECIMAL:
779 return FieldBaseConverter.getFieldBase( (BigDecimal) values, datatype);
780 case Datatype.VARCHAR:
781 case Datatype.CHAR:
782 case Datatype.CHARACTER:
783 case Datatype.CHARACTERVARYING:
784 case Datatype.CHARVARYING:
785 return FieldBaseConverter.getFieldBase( (String ) values, datatype, collator);
786 case Datatype.BIT:
787 case Datatype.BITVARYING:
788 return FieldBaseConverter.getFieldBase( (String ) values, datatype, null);
789 case Datatype.BLOB:
790 case Datatype.BINARYLARGEOBJECT:
791 case Datatype.LONGVARBINARY:
792 return values instanceof DBlobUpdatable ? values == null ? new DBlobUpdatable(true) : (FieldBase) values
793 : FieldBaseConverter.getFieldBase( (Blob) values);
794 case Datatype.DATE:
795 return FieldBaseConverter.getFieldBase( (java.sql.Date ) values);
796 case Datatype.TIMESTAMP:
797 return FieldBaseConverter.getFieldBase( (java.sql.Timestamp ) values);
798 case Datatype.TIME:
799 return FieldBaseConverter.getFieldBase( (java.sql.Time ) values);
800 case Datatype.BOOLEAN:
801 return FieldBaseConverter.getFieldBase( (Boolean ) values);
802 case Datatype.CHARACTERLARGEOBJECT:
803 case Datatype.CHARLARGEOBJECT:
804 case Datatype.CLOB:
805 case Datatype.LONGVARCHAR:
806 return values instanceof DClobUpdatable ?
807 values == null ? new DClobUpdatable(true) : (FieldBase) values
808 : FieldBaseConverter.getFieldBase( (Clob) values);
809 default:
810 throw new DException("DSE514", new Object [] {StaticClass.getDataTypeName(datatype)});
811 }
812 }
813
814 public static FieldBase getField(int datatype, Object values) throws DException {
815
816 switch (datatype) {
817 case Datatype.INT:
818 case Datatype.INTEGER:
819 return FieldBaseConverter.getFieldBase( (Integer ) values, datatype);
820 case Datatype.LONG:
821 case Datatype.BIGINT:
822 return FieldBaseConverter.getFieldBase( (Long ) values, datatype);
823 case Datatype.DOUBLE:
824 case Datatype.DOUBLEPRECISION:
825 case Datatype.FLOAT:
826 return FieldBaseConverter.getFieldBase( (Double ) values, datatype);
827 case Datatype.REAL:
828 return FieldBaseConverter.getFieldBase( (Float ) values, datatype);
829 case Datatype.SMALLINT:
830 case Datatype.SHORT:
831 return FieldBaseConverter.getFieldBase( (Short ) values, datatype);
832 case Datatype.TINYINT:
833 case Datatype.BYTE:
834 return FieldBaseConverter.getFieldBase( (Byte ) values, datatype);
835 case Datatype.BINARY:
836 case Datatype.VARBINARY:
837 return FieldBaseConverter.getFieldBase( (byte[]) values, datatype);
838 case Datatype.DEC:
839 case Datatype.DECIMAL:
840 case Datatype.NUMERIC:
841 case Datatype.BIGDECIMAL:
842 return FieldBaseConverter.getFieldBase( (BigDecimal) values, datatype);
843 case Datatype.VARCHAR:
844 case Datatype.CHAR:
845 case Datatype.CHARACTER:
846 case Datatype.CHARACTERVARYING:
847 case Datatype.CHARVARYING:
848 return FieldBaseConverter.getFieldBase( (String ) values, datatype, null);
849 case Datatype.BIT:
850 case Datatype.BITVARYING:
851 return FieldBaseConverter.getFieldBase( (String ) values, datatype, null);
852 case Datatype.BLOB:
853 case Datatype.BINARYLARGEOBJECT:
854 case Datatype.LONGVARBINARY:
855 return values instanceof DBlobUpdatable ? values == null ? new DBlobUpdatable(true) : (FieldBase) values
856 : FieldBaseConverter.getFieldBase( (Blob) values);
857 case Datatype.DATE:
858 return FieldBaseConverter.getFieldBase( (java.sql.Date ) values);
859 case Datatype.TIMESTAMP:
860 return FieldBaseConverter.getFieldBase( (java.sql.Timestamp ) values);
861 case Datatype.TIME:
862 return FieldBaseConverter.getFieldBase( (java.sql.Time ) values);
863 case Datatype.BOOLEAN:
864 return FieldBaseConverter.getFieldBase( (Boolean ) values);
865 case Datatype.CHARACTERLARGEOBJECT:
866 case Datatype.CHARLARGEOBJECT:
867 case Datatype.CLOB:
868 case Datatype.LONGVARCHAR:
869 return values instanceof DClobUpdatable ?
870 values == null ? new DClobUpdatable(true) : (FieldBase) values
871 : FieldBaseConverter.getFieldBase( (Clob) values);
872 default:
873 throw new DException("get filed nit implemnetd for datatype " + datatype, null);
874 }
875 }
876
877 public static FieldBase getField(int datatype, BufferRange values) throws DException {
878 switch (datatype) {
879 case Datatype.INT:
880 case Datatype.INTEGER:
881 return new FieldInteger(values, datatype);
882 case Datatype.LONG:
883 case Datatype.BIGINT:
884 return new FieldLong(values, datatype);
885 case Datatype.DOUBLE:
886 case Datatype.DOUBLEPRECISION:
887 case Datatype.FLOAT:
888 return new FieldDouble(values, datatype);
889 case Datatype.REAL:
890 return new FieldReal(values, datatype);
891 case Datatype.SMALLINT:
892 case Datatype.SHORT:
893 return new FieldShort(values, datatype);
894 case Datatype.TINYINT:
895 case Datatype.BYTE:
896 return new FieldByte(values, datatype);
897 case Datatype.BINARY:
898 case Datatype.VARBINARY:
899 return new FieldBinary(values, datatype);
900 case Datatype.DEC:
901 case Datatype.DECIMAL:
902 case Datatype.NUMERIC:
903 case Datatype.BIGDECIMAL:
904 return new FieldBigDecimal(values, datatype);
905 case Datatype.VARCHAR:
906 case Datatype.CHAR:
907 case Datatype.CHARACTER:
908 case Datatype.CHARACTERVARYING:
909 case Datatype.CHARVARYING:
910 return new FieldString(values, datatype, null);
911 case Datatype.DATE:
912 return new FieldDate(values, datatype);
913 case Datatype.TIMESTAMP:
914 return new FieldTimeStamp(values, datatype);
915 case Datatype.TIME:
916 return new FieldTime(values, datatype);
917 case Datatype.BOOLEAN:
918 return new FieldBoolean(values, datatype);
919 default:
920 throw new DException("get field not implemented for datatype " + datatype, null);
921 }
922 }
923
924 public static FieldBase getField(Long value) {
925 return new FieldLong(new BufferRange(CCzufDpowfsufs.getBytes(value)), Datatype.LONG);
926 }
927
928 public static FieldBase getFieldForVariable(Object object) throws DException {
929 FieldBase field = null;
930 if (object == null) {
931 field = new FieldLiteral(null, -1);
932 field.setBufferRange(NULLBUFFERRANGE);
933 } else if (object instanceof Boolean ) {
934 field = new FieldBooleanLiteral( ( (Boolean ) object).booleanValue() ? 0 : 1, Datatype.BOOLEAN);
935 } else if (object instanceof String ) {
936 field = new FieldStringLiteral(object, Datatype.CHAR);
937 } else if (object instanceof byte[]) {
938 field = new FieldBinary(new BufferRange( (byte[]) object), Datatype.BINARY);
939 } else if (object instanceof Blob) {
940 try {
941 field = new DBlobUpdatable( ( (Blob) object).getBinaryStream());
942 } catch (SQLException ex) {
943 throw new DException("DSE0", new Object [] {ex});
944 }
945 } else if (object instanceof Clob) {
946 try {
947 field = new DClobUpdatable( ( (Clob) object).getAsciiStream());
948 } catch (SQLException ex) {
949 throw new DException("DSE0", new Object [] {ex});
950 }
951 } else if (object instanceof Date) {
952 field = new FieldDateLiteral(object);
953 } else if (object instanceof Time) {
954 field = new FieldTimeLiteral(object);
955
956 } else if (object instanceof Timestamp) {
957 field = new FieldTimeStampLiteral(object);
958 } else
959 field = new FieldLiteral(object, -1);
960 return field;
961 }
962
963 public static SuperComparator getAppropriateComparator(int type1, int type2, boolean caseSensitive) {
964 throw new UnsupportedOperationException ("method getField() not implemented");
965 }
966
967 public static FieldBase[] getFields(Object [] object) throws DException {
968 FieldBase[] array = new FieldBase[object.length];
969 for (int i = 0; i < object.length; i++) {
970 array[i] = getFieldForVariable(object[i]);
971 }
972 return array;
973 }
974
975 public static FieldBase[] getFields(int[] datatypes, Collator collator) throws DException {
976 FieldBase[] array = new FieldBase[datatypes.length];
977 for (int i = 0; i < datatypes.length; i++) {
978 array[i] = getField(datatypes[i], null, collator);
979 }
980 return array;
981 }
982
983 public static Object [] getBlankFields(int[] datatypes, Collator collator) throws DException {
984 Object [] array = new Object [datatypes.length];
985 for (int i = 0; i < datatypes.length; i++) {
986 array[i] = getField(datatypes[i], null, collator);
987 }
988 return array;
989 }
990
991 private static FieldBinary convertNonDecimalToBinary(FieldBase field, int size, int fieldType) throws DException {
992 BufferRange bf = field.getBufferRange();
993 int length = bf.getLength();
994 byte[] result = size == length ? bf.getBytes()
995 : size > length ? padBytes(bf.getBytes(), size - length)
996 : truncateBytes(bf.getBytes(), length, size);
997 return new FieldBinary(new BufferRange(result), fieldType);
998 }
999
1000 private static byte[] truncateBytes(byte[] bytes, int length, int size) throws DException {
1001 byte[] result = new byte[length - size];
1002 System.arraycopy(bytes, length - size, result, 0, size);
1003 return result;
1004 }
1005
1006 private static byte[] padBytes(byte[] bytes, int length) throws DException {
1007 byte sign = getSign(bytes[0]);
1008 byte b = sign == -1 ? (byte) - 1 : (byte) 0;
1009 byte[] result = new byte[bytes.length + length];
1010 for (int i = 0; i < length; i++) {
1011 result[i] = b;
1012 }
1013 System.arraycopy(bytes, 0, result, length, bytes.length);
1014 return result;
1015 }
1016
1017 private static byte getSign(byte b) {
1018 return (byte) ( (b >> 7) & 0xff);
1019 }
1020
1021 public static FieldBase[] setFieldLiteralBufferRange(Object [] object) throws DException {
1022 FieldBase[] fbs = new FieldBase[object.length];
1023 FieldBase fb = null;
1024 for (int i = 0, len = object.length; i < len; i++) {
1025 fb = (FieldBase) object[i];
1026 fb.setDatatype(fb.getDatatype());
1027 fbs[i] = fb;
1028 }
1029 return fbs;
1030 }
1031
1032 public static FieldBase[] setFieldLiteralBufferRangeWithArray(Object [] object) throws DException {
1033 FieldBase[] fbs = new FieldBase[object.length];
1034 FieldBase fb = null;
1035 for (int i = 0, len = object.length; i < len; i++) {
1036 if (object[i] instanceof Object [])
1037 fb = (FieldBase) ( (Object []) object[i])[0];
1038 else
1039 fb = (FieldBase) object[i];
1040 fb.setDatatype(fb.getDatatype());
1041 fbs[i] = fb;
1042 }
1043 return fbs;
1044 }
1045
1046 public static FieldBase setFieldLiteralBufferRange(Object object) throws DException {
1047 FieldBase fb = (FieldBase) object;
1048 fb.setDatatype(fb.getDatatype());
1049 return fb;
1050 }
1051
1052 private static void checkPrecisionScale(String object, int size, int scale) throws DException {
1053 char aaa = object.charAt(0);
1054 if (aaa == '-' || aaa == '+') {
1055 object = object.substring(1);
1056 }
1057 int length = object.indexOf('.');
1058 if (length == -1) { int expIndex = object.indexOf('E');
1060 expIndex = expIndex == -1 ? object.indexOf('e') : expIndex;
1061 length = expIndex == -1 ? object.length() : (Integer.parseInt(object.substring(expIndex + 1)) + 1) + expIndex - 1;
1062 if (length > (size - scale))
1063 throw new DException("DSE5546", null);
1064 } else { if (size == scale) {
1066 if ( (length == 1 && !object.startsWith("0")) || length > 1)
1067 throw new DException("DSE5546", null);
1068 } else {
1069 int eIndex = object.indexOf('E');
1070 eIndex = eIndex == -1 ? object.indexOf('e') : eIndex;
1071 length = eIndex == -1 ? length : Integer.parseInt(object.substring(eIndex + 1)) + 1;
1072 if (length > (size - scale)) {
1073 throw new DException("DSE5546", null);
1074 }
1075 }
1076 }
1077 }
1078
1079 public static FieldBase[] changeIntoFildBase(Object obj) throws DException {
1080 Object [] temp = (Object []) obj;
1081 FieldBase[] fb = new FieldBase[temp.length];
1082 for (int i = 0; i < temp.length; i++) {
1083 fb[i] = (FieldBase) temp[i];
1084 }
1085 return fb;
1086 }
1087}
1088 |
Popular Tags |
Java API By Example, From Geeks To Geeks.