1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 package org.apache.openoffice.comp.sdbc.dbtools.util;
23 
24 import java.io.ByteArrayOutputStream;
25 import java.io.UnsupportedEncodingException;
26 
27 import com.sun.star.io.IOException;
28 import com.sun.star.io.XInputStream;
29 import com.sun.star.lang.IllegalArgumentException;
30 import com.sun.star.sdbc.DataType;
31 import com.sun.star.sdbc.SQLException;
32 import com.sun.star.sdbc.XBlob;
33 import com.sun.star.sdbc.XClob;
34 import com.sun.star.uno.Any;
35 import com.sun.star.uno.AnyConverter;
36 import com.sun.star.uno.Type;
37 import com.sun.star.uno.TypeClass;
38 import com.sun.star.uno.UnoRuntime;
39 import com.sun.star.util.Date;
40 import com.sun.star.util.DateTime;
41 import com.sun.star.util.Time;
42 
43 public class ORowSetValue {
44     private Object value;
45     private int typeKind;
46     private int flags;
47     private static final int FLAG_NULL = 0b1000;
48     private static final int FLAG_BOUND = 0b0100;
49     private static final int FLAG_MODIFIED = 0b0010;
50     private static final int FLAG_SIGNED = 0b0001;
51 
ORowSetValue()52     public ORowSetValue() {
53         flags = FLAG_NULL | FLAG_BOUND | FLAG_SIGNED;
54         typeKind = DataType.VARCHAR;
55     }
56 
ORowSetValue(boolean value)57     public ORowSetValue(boolean value) {
58         this();
59         setBoolean(value);
60     }
61 
ORowSetValue(Date value)62     public ORowSetValue(Date value) {
63         this();
64         setDate(value);
65     }
66 
ORowSetValue(DateTime value)67     public ORowSetValue(DateTime value) {
68         this();
69         setDateTime(value);
70     }
71 
ORowSetValue(double value)72     public ORowSetValue(double value) {
73         this();
74         setDouble(value);
75     }
76 
ORowSetValue(float value)77     public ORowSetValue(float value) {
78         this();
79         setFloat(value);
80     }
81 
ORowSetValue(byte value)82     public ORowSetValue(byte value) {
83         this();
84         setInt8(value);
85     }
86 
ORowSetValue(short value)87     public ORowSetValue(short value) {
88         this();
89         setInt16(value);
90     }
91 
ORowSetValue(int value)92     public ORowSetValue(int value) {
93         this();
94         setInt32(value);
95     }
96 
ORowSetValue(long value)97     public ORowSetValue(long value) {
98         this();
99         setLong(value);
100     }
101 
ORowSetValue(byte[] value)102     public ORowSetValue(byte[] value) {
103         this();
104         setSequence(value);
105     }
106 
ORowSetValue(String value)107     public ORowSetValue(String value) {
108         this();
109         setString(value);
110     }
111 
ORowSetValue(Time value)112     public ORowSetValue(Time value) {
113         this();
114         setTime(value);
115     }
116 
isNull()117     public boolean isNull() {
118         return (flags & FLAG_NULL) != 0;
119     }
120 
setNull()121     public void setNull() {
122         free();
123         flags |= FLAG_NULL;
124     }
125 
isBound()126     public boolean isBound() {
127         return (flags & FLAG_BOUND) != 0;
128     }
129 
setBound(boolean isBound)130     public void setBound(boolean isBound) {
131         if (isBound) {
132             flags |= FLAG_BOUND;
133         } else {
134             flags &= ~FLAG_BOUND;
135         }
136     }
137 
isModified()138     public boolean isModified() {
139         return (flags & FLAG_MODIFIED) != 0;
140     }
141 
setModified(boolean isModified)142     public void setModified(boolean isModified) {
143         flags |= FLAG_MODIFIED;
144     }
145 
isSigned()146     public boolean isSigned() {
147         return (flags & FLAG_SIGNED) != 0;
148     }
149 
setSigned()150     public void setSigned() throws IOException, SQLException {
151         setSigned(true);
152     }
153 
setSigned(boolean isSigned)154     public void setSigned(boolean isSigned) {
155         if (isSigned) {
156             flags |= FLAG_SIGNED;
157         } else {
158             flags &= ~FLAG_SIGNED;
159         }
160     }
161 
isStorageCompatible(int _eType1, int _eType2)162     private boolean isStorageCompatible(int _eType1, int _eType2) {
163         boolean bIsCompatible = true;
164 
165         if (_eType1 != _eType2) {
166             switch (_eType1) {
167             case DataType.CHAR:
168             case DataType.VARCHAR:
169             case DataType.DECIMAL:
170             case DataType.NUMERIC:
171             case DataType.LONGVARCHAR:
172                 bIsCompatible = (DataType.CHAR         == _eType2)
173                             ||  (DataType.VARCHAR      == _eType2)
174                             ||  (DataType.DECIMAL      == _eType2)
175                             ||  (DataType.NUMERIC      == _eType2)
176                             ||  (DataType.LONGVARCHAR  == _eType2);
177                 break;
178 
179             case DataType.DOUBLE:
180             case DataType.REAL:
181                 bIsCompatible = (DataType.DOUBLE   == _eType2)
182                             ||  (DataType.REAL     == _eType2);
183                 break;
184 
185             case DataType.BINARY:
186             case DataType.VARBINARY:
187             case DataType.LONGVARBINARY:
188                 bIsCompatible = (DataType.BINARY           == _eType2)
189                             ||  (DataType.VARBINARY        == _eType2)
190                             ||  (DataType.LONGVARBINARY    == _eType2);
191                 break;
192 
193             case DataType.INTEGER:
194                 bIsCompatible = (DataType.SMALLINT == _eType2)
195                             ||  (DataType.TINYINT  == _eType2)
196                             ||  (DataType.BIT      == _eType2)
197                             ||  (DataType.BOOLEAN  == _eType2);
198                 break;
199             case DataType.SMALLINT:
200                 bIsCompatible = (DataType.TINYINT  == _eType2)
201                             ||  (DataType.BIT      == _eType2)
202                             ||  (DataType.BOOLEAN  == _eType2);
203                 break;
204             case DataType.TINYINT:
205                 bIsCompatible = (DataType.BIT      == _eType2)
206                             ||  (DataType.BOOLEAN  == _eType2);
207                 break;
208 
209             case DataType.BLOB:
210             case DataType.CLOB:
211             case DataType.OBJECT:
212                 bIsCompatible = (DataType.BLOB     == _eType2)
213                             ||  (DataType.CLOB     == _eType2)
214                             ||  (DataType.OBJECT   == _eType2);
215                 break;
216 
217             default:
218                 bIsCompatible = false;
219             }
220         }
221         return bIsCompatible;
222     }
223 
getTypeKind()224     public int getTypeKind() {
225         return typeKind;
226     }
227 
setTypeKind(int type)228     public void setTypeKind(int type) throws SQLException {
229         if (!isNull() && !isStorageCompatible(type, typeKind)) {
230             switch (type) {
231             case DataType.VARCHAR:
232             case DataType.CHAR:
233             case DataType.DECIMAL:
234             case DataType.NUMERIC:
235             case DataType.LONGVARCHAR:
236                 setString(getString());
237                 break;
238             case DataType.BIGINT:
239                 setLong(getLong());
240                 break;
241 
242             case DataType.FLOAT:
243                 setFloat(getFloat());
244                 break;
245             case DataType.DOUBLE:
246             case DataType.REAL:
247                 setDouble(getDouble());
248                 break;
249             case DataType.TINYINT:
250                 setInt8(getInt8());
251                 break;
252             case DataType.SMALLINT:
253                 setInt16(getInt16());
254                 break;
255             case DataType.INTEGER:
256                 setInt32(getInt32());
257                 break;
258             case DataType.BIT:
259             case DataType.BOOLEAN:
260                 setBoolean(getBoolean());
261                 break;
262             case DataType.DATE:
263                 setDate(getDate());
264                 break;
265             case DataType.TIME:
266                 setTime(getTime());
267                 break;
268             case DataType.TIMESTAMP:
269                 setDateTime(getDateTime());
270                 break;
271             case DataType.BINARY:
272             case DataType.VARBINARY:
273             case DataType.LONGVARBINARY:
274                 setSequence(getSequence());
275                 break;
276             case DataType.BLOB:
277             case DataType.CLOB:
278             case DataType.OBJECT:
279             case DataType.OTHER:
280                 setAny(getAny());
281                 break;
282             default:
283                 setAny(getAny());
284                 //OSL_ENSURE(0,"ORowSetValue:operator==(): UNSPUPPORTED TYPE!");
285             }
286         }
287         typeKind = type;
288     }
289 
free()290     private void free() {
291         if (!isNull()) {
292             value = null;
293             flags |= FLAG_NULL;
294         }
295     }
296 
fill(Object any)297     public void fill(Object any) {
298         final Type type = AnyConverter.getType(any);
299 
300         switch (type.getTypeClass().getValue()) {
301         case TypeClass.VOID_value:
302             setNull();
303             break;
304         case TypeClass.BOOLEAN_value: {
305             boolean value = false;
306             try {
307                 value = AnyConverter.toBoolean(any);
308             } catch (IllegalArgumentException illegalArgumentException) {
309             }
310             setBoolean(value);
311             break;
312         }
313         case TypeClass.CHAR_value: {
314             char value = 0;
315             try {
316                 value = AnyConverter.toChar(any);
317             } catch (IllegalArgumentException illegalArgumentException) {
318             }
319             setString(Character.toString(value));
320             break;
321         }
322         case TypeClass.STRING_value: {
323             String value = "";
324             try {
325                 value = AnyConverter.toString(any);
326             } catch (IllegalArgumentException illegalArgumentException) {
327             }
328             setString(value);
329             break;
330         }
331         case TypeClass.FLOAT_value: {
332             float value = 0.0f;
333             try {
334                 value = AnyConverter.toFloat(any);
335             } catch (IllegalArgumentException illegalArgumentException) {
336             }
337             setFloat(value);
338             break;
339         }
340         case TypeClass.DOUBLE_value: {
341             double value = 0.0;
342             try {
343                 value = AnyConverter.toDouble(any);
344             } catch (IllegalArgumentException illegalArgumentException) {
345             }
346             setDouble(value);
347             break;
348         }
349         case TypeClass.BYTE_value: {
350             byte value = 0;
351             try {
352                 value = AnyConverter.toByte(any);
353             } catch (IllegalArgumentException illegalArgumentException) {
354             }
355             setInt8(value);
356             break;
357         }
358         case TypeClass.SHORT_value: {
359             short value = 0;
360             try {
361                 AnyConverter.toShort(any);
362             } catch (IllegalArgumentException illegalArgumentException) {
363             }
364             setInt16(value);
365             break;
366         }
367         case TypeClass.UNSIGNED_SHORT_value: {
368             short value = 0;
369             try {
370                 AnyConverter.toUnsignedShort(any);
371             } catch (IllegalArgumentException illegalArgumentException) {
372             }
373             setInt16(value);
374             setSigned(false);
375             break;
376         }
377         case TypeClass.LONG_value: {
378             int value = 0;
379             try {
380                 value = AnyConverter.toInt(any);
381             } catch (IllegalArgumentException illegalArgumentException) {
382             }
383             setInt32(value);
384             break;
385         }
386         case TypeClass.UNSIGNED_LONG_value: {
387             int value = 0;
388             try {
389                 value = AnyConverter.toUnsignedInt(any);
390             } catch (IllegalArgumentException illegalArgumentException) {
391             }
392             setInt32(value);
393             setSigned(false);
394             break;
395         }
396         case TypeClass.HYPER_value: {
397             long value = 0;
398             try {
399                 value = AnyConverter.toLong(any);
400             } catch (IllegalArgumentException illegalArgumentException) {
401             }
402             setLong(value);
403             break;
404         }
405         case TypeClass.UNSIGNED_HYPER_value: {
406             long value = 0;
407             try {
408                 value = AnyConverter.toUnsignedLong(any);
409             } catch (IllegalArgumentException illegalArgumentException) {
410             }
411             setLong(value);
412             setSigned(false);
413             break;
414         }
415         case TypeClass.ENUM_value: {
416             // FIXME: is this how an enum is unboxed from Any?
417             int value = 0;
418             try {
419                 Object object = AnyConverter.toObject(type, any);
420                 if (object instanceof com.sun.star.uno.Enum) {
421                     value = ((com.sun.star.uno.Enum)object).getValue();
422                 }
423             } catch (IllegalArgumentException illegalArgumentException) {
424             }
425             setInt32(value);
426             break;
427         }
428         case TypeClass.SEQUENCE_value: {
429             byte[] value = new byte[0];
430             try {
431                 Object array = AnyConverter.toArray(value);
432                 if (array instanceof byte[]) {
433                     value = (byte[]) array;
434                 }
435             } catch (IllegalArgumentException illegalArgumentException) {
436             }
437             setSequence(value);
438             break;
439         }
440         case TypeClass.STRUCT_value:
441         case TypeClass.INTERFACE_value: {
442             try {
443                 Object object = AnyConverter.toObject(Object.class, any);
444                 if (object instanceof Date) {
445                     setDate((Date)object);
446                 } else if (object instanceof Time) {
447                     setTime((Time)object);
448                 } else if (object instanceof DateTime) {
449                     setDateTime((DateTime)object);
450                 } else {
451                     XClob clob = UnoRuntime.queryInterface(XClob.class, object);
452                     if (clob != null) {
453                         setAny(clob);
454                     } else {
455                         XBlob blob = UnoRuntime.queryInterface(XBlob.class, object);
456                         if (blob != null) {
457                             setAny(blob);
458                         }
459                     }
460                 }
461             } catch (IllegalArgumentException illegalArgumentException) {
462             }
463             break;
464         }
465         default:
466             // unknown type
467         }
468     }
469 
getAny()470     public Object getAny() {
471         return value;
472     }
473 
getBoolean()474     public boolean getBoolean() {
475         boolean bRet = false;
476         if (!isNull()) {
477             switch (getTypeKind()) {
478             case DataType.CHAR:
479             case DataType.VARCHAR:
480             case DataType.LONGVARCHAR:
481                 if (((String)value).equals("true")) {
482                     bRet = true;
483                 } else if (((String)value).equals("false")) {
484                     bRet = false;
485                 }
486                 // fall through
487             case DataType.DECIMAL:
488             case DataType.NUMERIC:
489                 bRet = DBTypeConversion.safeParseInt((String)value) != 0;
490                 break;
491             case DataType.BIGINT:
492                 bRet = (long)value != 0;
493                 break;
494             case DataType.FLOAT:
495                 bRet = (float)value != 0.0;
496                 break;
497             case DataType.DOUBLE:
498             case DataType.REAL:
499                 bRet = (double)value != 0.0;
500                 break;
501             case DataType.DATE:
502             case DataType.TIME:
503             case DataType.TIMESTAMP:
504             case DataType.BINARY:
505             case DataType.VARBINARY:
506             case DataType.LONGVARBINARY:
507                 break;
508             case DataType.BIT:
509             case DataType.BOOLEAN:
510                 bRet = (boolean)value;
511                 break;
512             case DataType.TINYINT:
513                 bRet = (byte)value != 0;
514                 break;
515             case DataType.SMALLINT:
516                 bRet = (short)value != 0;
517                 break;
518             case DataType.INTEGER:
519                 bRet = (int)value != 0;
520                 break;
521             default:
522                 try {
523                     bRet = AnyConverter.toBoolean(value);
524                 } catch (com.sun.star.lang.IllegalArgumentException e) {
525                 }
526                 break;
527             }
528         }
529         return bRet;
530     }
531 
getDate()532     public Date getDate() throws SQLException {
533         Date aValue = new Date();
534         if (!isNull()) {
535             switch (getTypeKind()) {
536             case DataType.CHAR:
537             case DataType.VARCHAR:
538             case DataType.LONGVARCHAR:
539                 aValue = DBTypeConversion.toDate(getString());
540                 break;
541             case DataType.DECIMAL:
542             case DataType.NUMERIC:
543             case DataType.FLOAT:
544             case DataType.DOUBLE:
545             case DataType.REAL:
546                 aValue = DBTypeConversion.toDate(getDouble());
547                 break;
548             case DataType.DATE:
549                 Date date    = (Date)value;
550                 aValue.Day   = date.Day;
551                 aValue.Month = date.Month;
552                 aValue.Year  = date.Year;
553                 break;
554             case DataType.TIMESTAMP:
555                 DateTime dateTime = (DateTime)value;
556                 aValue.Day        = dateTime.Day;
557                 aValue.Month      = dateTime.Month;
558                 aValue.Year       = dateTime.Year;
559                 break;
560             case DataType.BIT:
561             case DataType.BOOLEAN:
562             case DataType.TINYINT:
563             case DataType.SMALLINT:
564             case DataType.INTEGER:
565             case DataType.BIGINT:
566                 aValue = DBTypeConversion.toDate((double)getLong());
567                 break;
568 
569             case DataType.BLOB:
570             case DataType.CLOB:
571             case DataType.OBJECT:
572             default:
573                 //OSL_ENSURE( false, "ORowSetValue::getDate: cannot retrieve the data!" );
574                 // NO break!
575 
576             case DataType.BINARY:
577             case DataType.VARBINARY:
578             case DataType.LONGVARBINARY:
579             case DataType.TIME:
580                 aValue = DBTypeConversion.toDate(0.0);
581                 break;
582             }
583         }
584         return aValue;
585 
586     }
587 
getDateTime()588     public DateTime getDateTime() throws SQLException {
589         DateTime aValue = new DateTime();
590         if (!isNull()) {
591             switch (getTypeKind()) {
592             case DataType.CHAR:
593             case DataType.VARCHAR:
594             case DataType.LONGVARCHAR:
595                 aValue = DBTypeConversion.toDateTime(getString());
596                 break;
597             case DataType.DECIMAL:
598             case DataType.NUMERIC:
599             case DataType.FLOAT:
600             case DataType.DOUBLE:
601             case DataType.REAL:
602                 aValue = DBTypeConversion.toDateTime(getDouble());
603                 break;
604             case DataType.DATE:
605                 Date date       = (Date)value;
606                 aValue.Day      = date.Day;
607                 aValue.Month    = date.Month;
608                 aValue.Year     = date.Year;
609                 break;
610             case DataType.TIME:
611                 Time time               = (Time)value;
612                 aValue.HundredthSeconds = time.HundredthSeconds;
613                 aValue.Seconds          = time.Seconds;
614                 aValue.Minutes          = time.Minutes;
615                 aValue.Hours            = time.Hours;
616                 break;
617             case DataType.TIMESTAMP:
618                 DateTime dateTime       = (DateTime)value;
619                 aValue.Year             = dateTime.Year;
620                 aValue.Month            = dateTime.Month;
621                 aValue.Day              = dateTime.Day;
622                 aValue.Hours            = dateTime.Hours;
623                 aValue.Minutes          = dateTime.Minutes;
624                 aValue.Seconds          = dateTime.Seconds;
625                 aValue.HundredthSeconds = dateTime.HundredthSeconds;
626                 break;
627             default:
628                 try {
629                     DateTime any            = AnyConverter.toObject(DateTime.class, value);
630                     aValue.Year             = any.Year;
631                     aValue.Month            = any.Month;
632                     aValue.Day              = any.Day;
633                     aValue.Hours            = any.Hours;
634                     aValue.Minutes          = any.Minutes;
635                     aValue.Seconds          = any.Seconds;
636                     aValue.HundredthSeconds = any.HundredthSeconds;
637                 } catch (com.sun.star.lang.IllegalArgumentException e) {
638                 } catch (ClassCastException classCastException) {
639                 }
640                 break;
641             }
642         }
643         return aValue;
644     }
645 
getDouble()646     public double getDouble() {
647         double nRet = 0.0;
648         if (!isNull()) {
649             switch (getTypeKind()) {
650             case DataType.CHAR:
651             case DataType.VARCHAR:
652             case DataType.DECIMAL:
653             case DataType.NUMERIC:
654             case DataType.LONGVARCHAR:
655                 nRet = DBTypeConversion.safeParseDouble((String)value);
656                 break;
657             case DataType.BIGINT:
658                 nRet = isSigned() ? (long)value : DBTypeConversion.unsignedLongToDouble((long)value);
659                 break;
660             case DataType.FLOAT:
661                 nRet = (float)value;
662                 break;
663             case DataType.DOUBLE:
664             case DataType.REAL:
665                 nRet = (double)value;
666                 break;
667             case DataType.DATE:
668                 nRet = DBTypeConversion.toDouble((Date)value);
669                 break;
670             case DataType.TIME:
671                 nRet = DBTypeConversion.toDouble((Time)value);
672                 break;
673             case DataType.TIMESTAMP:
674                 nRet = DBTypeConversion.toDouble((DateTime)value);
675                 break;
676             case DataType.BINARY:
677             case DataType.VARBINARY:
678             case DataType.LONGVARBINARY:
679             case DataType.BLOB:
680             case DataType.CLOB:
681                 //OSL_ASSERT(!"getDouble() for this type is not allowed!");
682                 break;
683             case DataType.BIT:
684             case DataType.BOOLEAN:
685                 nRet = (boolean)value ? 1 : 0;
686                 break;
687             case DataType.TINYINT:
688                 nRet = isSigned() ? (byte)value : 0xff & (byte)value;
689                 break;
690             case DataType.SMALLINT:
691                 nRet = isSigned() ? (short)value : 0xffff & (short)value;
692                 break;
693             case DataType.INTEGER:
694                 nRet = isSigned() ? (int)value : 0xffffFFFFL & (int)value;
695                 break;
696             default:
697                 try {
698                     nRet = AnyConverter.toDouble(value);
699                 } catch (com.sun.star.lang.IllegalArgumentException e) {
700                 }
701                 break;
702             }
703         }
704         return nRet;
705     }
706 
getFloat()707     public float getFloat() {
708         float nRet = 0.0f;
709         if (!isNull()) {
710             switch (getTypeKind()) {
711             case DataType.CHAR:
712             case DataType.VARCHAR:
713             case DataType.DECIMAL:
714             case DataType.NUMERIC:
715             case DataType.LONGVARCHAR:
716                 nRet = DBTypeConversion.safeParseFloat((String)value);
717                 break;
718             case DataType.BIGINT:
719                 nRet = isSigned() ? (long)value : DBTypeConversion.unsignedLongToFloat((long)value);
720                 break;
721             case DataType.FLOAT:
722                 nRet = (float)value;
723                 break;
724             case DataType.DOUBLE:
725             case DataType.REAL:
726                 nRet = (float)(double)value;
727                 break;
728             case DataType.DATE:
729                 nRet = (float)DBTypeConversion.toDouble((Date)value);
730                 break;
731             case DataType.TIME:
732                 nRet = (float)DBTypeConversion.toDouble((Time)value);
733                 break;
734             case DataType.TIMESTAMP:
735                 nRet = (float)DBTypeConversion.toDouble((DateTime)value);
736                 break;
737             case DataType.BINARY:
738             case DataType.VARBINARY:
739             case DataType.LONGVARBINARY:
740             case DataType.BLOB:
741             case DataType.CLOB:
742                 //OSL_ASSERT(!"getDouble() for this type is not allowed!");
743                 break;
744             case DataType.BIT:
745             case DataType.BOOLEAN:
746                 nRet = (boolean)value ? 1 : 0;
747                 break;
748             case DataType.TINYINT:
749                 nRet = isSigned() ? (byte)value : 0xff & (byte)value;
750                 break;
751             case DataType.SMALLINT:
752                 nRet = isSigned() ? (short)value : 0xffff & (short)value;
753                 break;
754             case DataType.INTEGER:
755                 nRet = isSigned() ? (int)value : 0xffffFFFFL & (int)value;
756                 break;
757             default:
758                 try {
759                     nRet = AnyConverter.toFloat(value);
760                 } catch (com.sun.star.lang.IllegalArgumentException e) {
761                 }
762                 break;
763             }
764         }
765         return nRet;
766     }
767 
getInt8()768     public byte getInt8() {
769         byte nRet = 0;
770         if (!isNull()) {
771             switch (getTypeKind()) {
772             case DataType.CHAR:
773             case DataType.VARCHAR:
774             case DataType.DECIMAL:
775             case DataType.NUMERIC:
776             case DataType.LONGVARCHAR:
777                 nRet = (byte)DBTypeConversion.safeParseInt((String)value);
778                 break;
779             case DataType.BIGINT:
780                 nRet = (byte)(long)value;
781                 break;
782             case DataType.FLOAT:
783                 nRet = (byte)(float)value;
784                 break;
785             case DataType.DOUBLE:
786             case DataType.REAL:
787                 nRet = (byte)(double)value;
788                 break;
789             case DataType.DATE:
790             case DataType.TIME:
791             case DataType.TIMESTAMP:
792             case DataType.BINARY:
793             case DataType.VARBINARY:
794             case DataType.LONGVARBINARY:
795             case DataType.BLOB:
796             case DataType.CLOB:
797                 break;
798             case DataType.BIT:
799             case DataType.BOOLEAN:
800                 nRet = (byte)((boolean)value ? 1 : 0);
801                 break;
802             case DataType.TINYINT:
803                 nRet = (byte)value;
804                 break;
805             case DataType.SMALLINT:
806                 nRet = (byte)(short)value;
807                 break;
808             case DataType.INTEGER:
809                 nRet = (byte)(int)value;
810                 break;
811             default:
812                 try {
813                     nRet = AnyConverter.toByte(value);
814                 } catch (com.sun.star.lang.IllegalArgumentException e) {
815                 }
816                 break;
817             }
818         }
819         return nRet;
820     }
821 
getInt16()822     public short getInt16() {
823         short nRet = 0;
824         if (!isNull()) {
825             switch (getTypeKind()) {
826             case DataType.CHAR:
827             case DataType.VARCHAR:
828             case DataType.DECIMAL:
829             case DataType.NUMERIC:
830             case DataType.LONGVARCHAR:
831                 nRet = (short)DBTypeConversion.safeParseInt((String)value);
832                 break;
833             case DataType.BIGINT:
834                 nRet = (short)(long)value;
835                 break;
836             case DataType.FLOAT:
837                 nRet = (short)(float)value;
838                 break;
839             case DataType.DOUBLE:
840             case DataType.REAL:
841                 nRet = (short)(double)value;
842                 break;
843             case DataType.DATE:
844             case DataType.TIME:
845             case DataType.TIMESTAMP:
846             case DataType.BINARY:
847             case DataType.VARBINARY:
848             case DataType.LONGVARBINARY:
849             case DataType.BLOB:
850             case DataType.CLOB:
851                 break;
852             case DataType.BIT:
853             case DataType.BOOLEAN:
854                 nRet = (short)((boolean)value ? 1 : 0);
855                 break;
856             case DataType.TINYINT:
857                 nRet = (short)(isSigned() ? (byte)value : 0xff & (byte)value);
858                 break;
859             case DataType.SMALLINT:
860                 nRet = (short)value;
861                 break;
862             case DataType.INTEGER:
863                 nRet = (short)(int)value;
864                 break;
865             default:
866                 try {
867                     nRet = AnyConverter.toShort(value);
868                 } catch (com.sun.star.lang.IllegalArgumentException e) {
869                 }
870                 break;
871             }
872         }
873         return nRet;
874     }
875 
getInt32()876     public int getInt32() {
877         int nRet = 0;
878         if (!isNull()) {
879             switch (getTypeKind()) {
880             case DataType.CHAR:
881             case DataType.VARCHAR:
882             case DataType.DECIMAL:
883             case DataType.NUMERIC:
884             case DataType.LONGVARCHAR:
885                 nRet = DBTypeConversion.safeParseInt((String)value);
886                 break;
887             case DataType.BIGINT:
888                 nRet = (int)(long)value;
889                 break;
890             case DataType.FLOAT:
891                 nRet = (int)(float)value;
892                 break;
893             case DataType.DOUBLE:
894             case DataType.REAL:
895                 nRet = (int)(double)value;
896                 break;
897             case DataType.DATE:
898                 nRet = DBTypeConversion.toDays((Date)value);
899                 break;
900             case DataType.TIME:
901             case DataType.TIMESTAMP:
902             case DataType.BINARY:
903             case DataType.VARBINARY:
904             case DataType.LONGVARBINARY:
905             case DataType.BLOB:
906             case DataType.CLOB:
907                 break;
908             case DataType.BIT:
909             case DataType.BOOLEAN:
910                 nRet = (boolean)value ? 1 : 0;
911                 break;
912             case DataType.TINYINT:
913                 nRet = isSigned() ? (byte)value : 0xff & (byte)value;
914                 break;
915             case DataType.SMALLINT:
916                 nRet = isSigned() ? (short)value : 0xffff & (short)value;
917                 break;
918             case DataType.INTEGER:
919                 nRet = (int)value;
920                 break;
921             default:
922                 try {
923                     nRet = AnyConverter.toInt(value);
924                 } catch (com.sun.star.lang.IllegalArgumentException e) {
925                 }
926                 break;
927             }
928         }
929         return nRet;
930     }
931 
getLong()932     public long getLong() {
933         long nRet = 0;
934         if (!isNull()) {
935             switch (getTypeKind()) {
936             case DataType.CHAR:
937             case DataType.VARCHAR:
938             case DataType.DECIMAL:
939             case DataType.NUMERIC:
940             case DataType.LONGVARCHAR:
941                 nRet = DBTypeConversion.safeParseLong((String)value);
942                 break;
943             case DataType.BIGINT:
944                 nRet = (long)value;
945                 break;
946             case DataType.FLOAT:
947                 nRet = (long)(float)value;
948                 break;
949             case DataType.DOUBLE:
950             case DataType.REAL:
951                 nRet = (long)(double)value;
952                 break;
953             case DataType.DATE:
954                 nRet = DBTypeConversion.toDays((Date)value);
955                 break;
956             case DataType.TIME:
957             case DataType.TIMESTAMP:
958             case DataType.BINARY:
959             case DataType.VARBINARY:
960             case DataType.LONGVARBINARY:
961             case DataType.BLOB:
962             case DataType.CLOB:
963                 break;
964             case DataType.BIT:
965             case DataType.BOOLEAN:
966                 nRet = (boolean)value ? 1 : 0;
967                 break;
968             case DataType.TINYINT:
969                 nRet = isSigned() ? (byte)value : 0xff & (byte)value;
970                 break;
971             case DataType.SMALLINT:
972                 nRet = isSigned() ? (short)value : 0xffff & (short)value;
973                 break;
974             case DataType.INTEGER:
975                 nRet = isSigned() ? (int)value : 0xffffFFFFL & (int)value;
976                 break;
977             default:
978                 try {
979                     nRet = AnyConverter.toInt(value);
980                 } catch (com.sun.star.lang.IllegalArgumentException e) {
981                 }
982                 break;
983             }
984         }
985         return nRet;
986     }
987 
getSequence()988     public byte[] getSequence() throws SQLException {
989         byte[] aSeq = new byte[0];
990         if (!isNull()) {
991             switch (getTypeKind()) {
992             case DataType.OBJECT:
993             case DataType.CLOB:
994             case DataType.BLOB:
995                 XInputStream xStream = null;
996                 if (value != null) {
997                     XBlob blob = UnoRuntime.queryInterface(XBlob.class, value);
998                     if (blob != null) {
999                         xStream = blob.getBinaryStream();
1000                     } else {
1001                         XClob clob = UnoRuntime.queryInterface(XClob.class, value);
1002                         if (clob != null) {
1003                             xStream = clob.getCharacterStream();
1004                         }
1005                     }
1006                     if (xStream != null) {
1007                         try {
1008                             try {
1009                                 final int bytesToRead = 65535;
1010                                 byte[][] aReadSeq = new byte[1][];
1011                                 ByteArrayOutputStream baos = new ByteArrayOutputStream();
1012                                 int read;
1013                                 do {
1014                                     read = xStream.readBytes(aReadSeq, bytesToRead);
1015                                     baos.write(aReadSeq[0], 0, read);
1016                                 } while (read == bytesToRead);
1017                                 aSeq = baos.toByteArray();
1018                             } finally {
1019                                 xStream.closeInput();
1020                             }
1021                         } catch (IOException ioException) {
1022                             throw new SQLException(ioException.getMessage());
1023                         }
1024                     }
1025                 }
1026                 break;
1027             case DataType.VARCHAR:
1028             case DataType.LONGVARCHAR:
1029                 try {
1030                     aSeq = ((String)value).getBytes("UTF-16");
1031                 } catch (UnsupportedEncodingException unsupportedEncodingException) {
1032                 }
1033                 break;
1034             case DataType.BINARY:
1035             case DataType.VARBINARY:
1036             case DataType.LONGVARBINARY:
1037                 aSeq = ((byte[])value).clone();
1038                 break;
1039             default:
1040                 try {
1041                     aSeq = ((byte[])AnyConverter.toArray(value)).clone();
1042                 } catch (com.sun.star.lang.IllegalArgumentException e) {
1043                 } catch (ClassCastException classCastException) {
1044                 }
1045                 break;
1046             }
1047         }
1048         return aSeq;
1049     }
1050 
getString()1051     public String getString() throws SQLException {
1052         String aRet = "";
1053         if (!isNull()) {
1054             switch (getTypeKind()) {
1055             case DataType.CHAR:
1056             case DataType.VARCHAR:
1057             case DataType.DECIMAL:
1058             case DataType.NUMERIC:
1059             case DataType.LONGVARCHAR:
1060                 aRet = (String)value;
1061                 break;
1062             case DataType.BIGINT:
1063                 aRet = isSigned() ? Long.toString((long)value) : DBTypeConversion.toUnsignedString((long)value);
1064                 break;
1065             case DataType.FLOAT:
1066                 aRet = ((Float)value).toString();
1067                 break;
1068             case DataType.DOUBLE:
1069             case DataType.REAL:
1070                 aRet = ((Double)value).toString();
1071                 break;
1072             case DataType.DATE:
1073                 aRet = DBTypeConversion.toDateString((Date)value);
1074                 break;
1075             case DataType.TIME:
1076                 aRet = DBTypeConversion.toTimeString((Time)value);
1077                 break;
1078             case DataType.TIMESTAMP:
1079                 aRet = DBTypeConversion.toDateTimeString((DateTime)value);
1080                 break;
1081             case DataType.BINARY:
1082             case DataType.VARBINARY:
1083             case DataType.LONGVARBINARY:
1084                 {
1085                     StringBuilder sVal = new StringBuilder("0x");
1086                     byte[] sSeq = getSequence();
1087                     for (byte b : sSeq) {
1088                         sVal.append(String.format("%02x", DBTypeConversion.toUnsignedInt(b)));
1089                     }
1090                     aRet = sVal.toString();
1091                 }
1092                 break;
1093             case DataType.BIT:
1094             case DataType.BOOLEAN:
1095                 aRet = ((Boolean)value).toString();
1096                 break;
1097             case DataType.TINYINT:
1098                 aRet = isSigned() ? Integer.toString((byte)value) : DBTypeConversion.toUnsignedString(0xff & (byte)value);
1099                 break;
1100             case DataType.SMALLINT:
1101                 aRet = isSigned() ? Integer.toString((short)value) : DBTypeConversion.toUnsignedString(0xffff & (short)value);
1102                 break;
1103             case DataType.INTEGER:
1104                 aRet = isSigned() ? Integer.toString((int)value) : DBTypeConversion.toUnsignedString((int)value);
1105                 break;
1106             case DataType.CLOB:
1107                 if (AnyConverter.isObject(value)) {
1108                     try {
1109                         XClob clob = AnyConverter.toObject(XClob.class, value);
1110                         if (clob != null) {
1111                             aRet = clob.getSubString(1, (int)clob.length());
1112                         }
1113                     } catch (ClassCastException classCastException) {
1114                     } catch (com.sun.star.lang.IllegalArgumentException e) {
1115                     }
1116                 }
1117                 break;
1118             default:
1119                 try {
1120                     aRet = AnyConverter.toString(value);
1121                 } catch (com.sun.star.lang.IllegalArgumentException e) {
1122                 }
1123                 break;
1124             }
1125         }
1126         return aRet;
1127     }
1128 
getTime()1129     public Time getTime() throws SQLException {
1130         Time aValue = new Time();
1131         if (!isNull()) {
1132             switch (getTypeKind()) {
1133                 case DataType.CHAR:
1134                 case DataType.VARCHAR:
1135                 case DataType.LONGVARCHAR:
1136                     aValue = DBTypeConversion.toTime(getString());
1137                     break;
1138                 case DataType.DECIMAL:
1139                 case DataType.NUMERIC:
1140                     aValue = DBTypeConversion.toTime(getDouble());
1141                     break;
1142                 case DataType.FLOAT:
1143                 case DataType.DOUBLE:
1144                 case DataType.REAL:
1145                     aValue = DBTypeConversion.toTime(getDouble());
1146                     break;
1147                 case DataType.TIMESTAMP:
1148                     DateTime pDateTime      = (DateTime)value;
1149                     aValue.HundredthSeconds = pDateTime.HundredthSeconds;
1150                     aValue.Seconds          = pDateTime.Seconds;
1151                     aValue.Minutes          = pDateTime.Minutes;
1152                     aValue.Hours            = pDateTime.Hours;
1153                     break;
1154                 case DataType.TIME:
1155                     Time time               = (Time)value;
1156                     aValue.Hours            = time.Hours;
1157                     aValue.Minutes          = time.Minutes;
1158                     aValue.Seconds          = time.Seconds;
1159                     aValue.HundredthSeconds = time.HundredthSeconds;
1160                     break;
1161                 default:
1162                     try {
1163                         aValue = AnyConverter.toObject(Time.class, value);
1164                     } catch (com.sun.star.lang.IllegalArgumentException e) {
1165                     } catch (ClassCastException classCastException) {
1166                     }
1167                     break;
1168             }
1169         }
1170         return aValue;
1171     }
1172 
setAny(Object value)1173     public void setAny(Object value) {
1174         flags &= ~FLAG_NULL;
1175         this.value = value;
1176         typeKind = DataType.OBJECT;
1177     }
1178 
setBoolean(boolean value)1179     public void setBoolean(boolean value) {
1180         flags &= ~FLAG_NULL;
1181         this.value = value;
1182         typeKind = DataType.BIT;
1183     }
1184 
setDate(Date date)1185     public void setDate(Date date) {
1186         flags &= ~FLAG_NULL;
1187         this.value = new Date(date.Day, date.Month, date.Year);
1188         typeKind = DataType.DATE;
1189     }
1190 
setDateTime(DateTime value)1191     public void setDateTime(DateTime value) {
1192         flags &= ~FLAG_NULL;
1193         this.value = new DateTime(value.HundredthSeconds, value.Seconds, value.Minutes, value.Hours,
1194                 value.Day, value.Minutes, value.Year);
1195         typeKind = DataType.TIMESTAMP;
1196     }
1197 
setDouble(double value)1198     public void setDouble(double value) {
1199         flags &= ~FLAG_NULL;
1200         this.value = value;
1201         typeKind = DataType.DOUBLE;
1202     }
1203 
setFloat(float value)1204     public void setFloat(float value) {
1205         flags &= ~FLAG_NULL;
1206         this.value = value;
1207         typeKind = DataType.FLOAT;
1208     }
1209 
setInt8(byte value)1210     public void setInt8(byte value) {
1211         flags &= ~FLAG_NULL;
1212         this.value = value;
1213         typeKind = DataType.TINYINT;
1214     }
1215 
setInt16(short value)1216     public void setInt16(short value) {
1217         flags &= ~FLAG_NULL;
1218         this.value = value;
1219         typeKind = DataType.SMALLINT;
1220     }
1221 
setInt32(int value)1222     public void setInt32(int value) {
1223         flags &= ~FLAG_NULL;
1224         this.value = value;
1225         typeKind = DataType.INTEGER;
1226     }
1227 
setLong(long value)1228     public void setLong(long value) {
1229         flags &= ~FLAG_NULL;
1230         this.value = value;
1231         typeKind = DataType.BIGINT;
1232     }
1233 
setSequence(byte[] value)1234     public void setSequence(byte[] value) {
1235         flags &= ~FLAG_NULL;
1236         this.value = value.clone();
1237         typeKind = DataType.LONGVARBINARY;
1238     }
1239 
setString(String value)1240     public void setString(String value) {
1241         flags &= ~FLAG_NULL;
1242         this.value = value;
1243         typeKind = DataType.VARCHAR;
1244     }
1245 
setTime(Time value)1246     public void setTime(Time value) {
1247         flags &= ~FLAG_NULL;
1248         this.value = new Time(value.Hours, value.Minutes, value.Seconds, value.HundredthSeconds);
1249         typeKind = DataType.TIME;
1250     }
1251 
makeAny()1252     public Object makeAny() {
1253         Object rValue = Any.VOID;
1254         if(isBound() && !isNull()) {
1255             switch (getTypeKind()) {
1256             case DataType.CHAR:
1257             case DataType.VARCHAR:
1258             case DataType.DECIMAL:
1259             case DataType.NUMERIC:
1260             case DataType.LONGVARCHAR:
1261                 rValue = value;
1262                 break;
1263             case DataType.BIGINT:
1264                 rValue = value;
1265                 break;
1266             case DataType.FLOAT:
1267                 rValue = value;
1268                 break;
1269             case DataType.DOUBLE:
1270             case DataType.REAL:
1271                 rValue = value;
1272                 break;
1273             case DataType.DATE:
1274                 Date date = (Date)value;
1275                 Date dateOut = new Date();
1276                 dateOut.Day = date.Day;
1277                 dateOut.Month = date.Month;
1278                 dateOut.Year = date.Year;
1279                 rValue = dateOut;
1280                 break;
1281             case DataType.TIME:
1282                 Time time = (Time)value;
1283                 Time timeOut = new Time();
1284                 timeOut.Hours = time.Hours;
1285                 timeOut.Minutes = time.Minutes;
1286                 timeOut.Seconds = time.Seconds;
1287                 timeOut.HundredthSeconds = time.HundredthSeconds;
1288                 rValue = timeOut;
1289                 break;
1290             case DataType.TIMESTAMP:
1291                 DateTime dateTime = (DateTime)value;
1292                 DateTime dateTimeOut = new DateTime(dateTime.HundredthSeconds, dateTime.Seconds, dateTime.Minutes, dateTime.Hours,
1293                         dateTime.Day, dateTime.Minutes, dateTime.Year);
1294                 rValue = dateTimeOut;
1295                 break;
1296             case DataType.BINARY:
1297             case DataType.VARBINARY:
1298             case DataType.LONGVARBINARY:
1299                 rValue = ((byte[])value).clone();
1300                 break;
1301             case DataType.BLOB:
1302             case DataType.CLOB:
1303             case DataType.OBJECT:
1304             case DataType.OTHER:
1305                 rValue = getAny();
1306                 break;
1307             case DataType.BIT:
1308             case DataType.BOOLEAN:
1309                 rValue = (boolean)value;
1310                 break;
1311             case DataType.TINYINT:
1312                 rValue = (byte)value;
1313                 break;
1314             case DataType.SMALLINT:
1315                 rValue = (short)value;
1316                 break;
1317             case DataType.INTEGER:
1318                 rValue = (int)value;
1319                 break;
1320             default:
1321                 rValue = getAny();
1322                 break;
1323             }
1324         }
1325         return rValue;
1326     }
1327 }
1328 
1329