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