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 23 package com.sun.star.wizards.db; 24 25 import com.sun.star.awt.XWindow; 26 import com.sun.star.beans.PropertyVetoException; 27 import com.sun.star.beans.UnknownPropertyException; 28 import com.sun.star.lang.IllegalArgumentException; 29 import com.sun.star.lang.WrappedTargetException; 30 import com.sun.star.sdbc.SQLException; 31 import com.sun.star.wizards.common.JavaTools; 32 import java.util.Vector; 33 34 import com.sun.star.awt.VclWindowPeerAttribute; 35 import com.sun.star.beans.Property; 36 import com.sun.star.beans.PropertyValue; 37 import com.sun.star.beans.XPropertySet; 38 import com.sun.star.container.ContainerEvent; 39 import com.sun.star.container.XContainer; 40 import com.sun.star.container.XContainerListener; 41 import com.sun.star.container.XHierarchicalNameAccess; 42 import com.sun.star.container.XIndexAccess; 43 import com.sun.star.container.XNameAccess; 44 import com.sun.star.lang.EventObject; 45 import com.sun.star.lang.XMultiServiceFactory; 46 import com.sun.star.sdbcx.KeyType; 47 import com.sun.star.sdbcx.XAppend; 48 import com.sun.star.sdbcx.XColumnsSupplier; 49 import com.sun.star.sdbcx.XDataDescriptorFactory; 50 import com.sun.star.sdbcx.XDrop; 51 import com.sun.star.sdbcx.XKeysSupplier; 52 import com.sun.star.uno.AnyConverter; 53 import com.sun.star.uno.UnoRuntime; 54 import com.sun.star.wizards.common.Desktop; 55 import com.sun.star.wizards.common.Properties; 56 import com.sun.star.wizards.common.PropertyNames; 57 58 public class TableDescriptor extends CommandMetaData implements XContainerListener 59 { 60 61 XDataDescriptorFactory xTableDataDescriptorFactory; 62 XPropertySet xPropTableDataDescriptor; 63 private XNameAccess xNameAccessColumns; 64 private XIndexAccess xIndexAccessKeys; 65 public XDataDescriptorFactory xColumnDataDescriptorFactory; 66 XContainer xTableContainer; 67 XAppend xTableAppend; 68 XDrop xTableDrop; 69 private XAppend xKeyAppend; 70 private XDrop xKeyDrop; 71 private String[] sTableFilters = null; 72 private Vector columncontainer; 73 private Vector keycolumncontainer; 74 public XHierarchicalNameAccess xTableHierarchicalNameAccess; 75 private CommandName ComposedTableName; 76 private XAppend xKeyColAppend; 77 private XColumnsSupplier xKeyColumnSupplier; 78 private XPropertySet xKey; 79 private boolean bIDFieldisInserted = false; 80 private String IDFieldName = PropertyNames.EMPTY_STRING; 81 private String sColumnAlreadyExistsMessage = PropertyNames.EMPTY_STRING; 82 // private WizardDialog oUnoDialog; 83 private XWindow xWindow; 84 85 /** 86 * @param xMSF 87 */ TableDescriptor(XMultiServiceFactory xMSF, XWindow _xWindow, String _sColumnAlreadyExistsMessage)88 public TableDescriptor(XMultiServiceFactory xMSF, XWindow _xWindow, String _sColumnAlreadyExistsMessage) 89 { 90 super(xMSF); 91 columncontainer = new Vector(); 92 keycolumncontainer = new Vector(); 93 sColumnAlreadyExistsMessage = _sColumnAlreadyExistsMessage; 94 xWindow = _xWindow; 95 } 96 97 private class ColumnDescriptor 98 { 99 100 String Name; 101 XPropertySet xColPropertySet; 102 ColumnDescriptor(XPropertySet _xColPropertySet, String _Name)103 public ColumnDescriptor(XPropertySet _xColPropertySet, String _Name) 104 { 105 Name = _Name; 106 xColPropertySet = _xColPropertySet; 107 } 108 } 109 getConnection(PropertyValue[] _curPropertyValue)110 public boolean getConnection(PropertyValue[] _curPropertyValue) 111 { 112 if (super.getConnection(_curPropertyValue)) 113 { 114 // XTablesSupplier xDBTables = (XTablesSupplier) UnoRuntime.queryInterface(XTablesSupplier.class, DBConnection); 115 // xTableNames = xDBTables.getTables(); 116 xTableAppend = UnoRuntime.queryInterface( XAppend.class, getTableNamesAsNameAccess() ); 117 xTableDrop = UnoRuntime.queryInterface( XDrop.class, getTableNamesAsNameAccess() ); 118 xTableDataDescriptorFactory = UnoRuntime.queryInterface( XDataDescriptorFactory.class, getTableNamesAsNameAccess() ); 119 xPropTableDataDescriptor = xTableDataDescriptorFactory.createDataDescriptor(); 120 XColumnsSupplier xColumnsSupplier = UnoRuntime.queryInterface( XColumnsSupplier.class, xPropTableDataDescriptor ); 121 xNameAccessColumns = xColumnsSupplier.getColumns(); 122 xColumnDataDescriptorFactory = UnoRuntime.queryInterface( XDataDescriptorFactory.class, xNameAccessColumns ); 123 try 124 { 125 createTypeInspector(); 126 sTableFilters = (String[]) AnyConverter.toArray(getDataSourcePropertySet().getPropertyValue("TableFilter")); 127 } 128 catch (Exception e) 129 { 130 e.printStackTrace(System.out); 131 } 132 return true; 133 } 134 else 135 { 136 return false; 137 } 138 } 139 removePrimaryKeys()140 private void removePrimaryKeys() 141 { 142 if (keycolumncontainer.size() > 0) 143 { 144 for (int i = (keycolumncontainer.size() - 1); i >= 0; i--) 145 { 146 keycolumncontainer.remove(i); 147 } 148 } 149 } 150 createPrimaryKeys(String[] _fieldnames, boolean _bAutoincrementation)151 public boolean createPrimaryKeys(String[] _fieldnames, boolean _bAutoincrementation) 152 { 153 try 154 { 155 XKeysSupplier xKeySupplier = UnoRuntime.queryInterface(XKeysSupplier.class, xPropTableDataDescriptor); 156 xIndexAccessKeys = xKeySupplier.getKeys(); 157 XDataDescriptorFactory xKeyFac = UnoRuntime.queryInterface(XDataDescriptorFactory.class, xIndexAccessKeys); 158 xKeyDrop = UnoRuntime.queryInterface(XDrop.class, xIndexAccessKeys); 159 xKeyAppend = UnoRuntime.queryInterface(XAppend.class, xKeyFac); 160 xKey = xKeyFac.createDataDescriptor(); 161 xKey.setPropertyValue("Type", new Integer(KeyType.PRIMARY)); 162 xKeyColumnSupplier = UnoRuntime.queryInterface(XColumnsSupplier.class, xKey); 163 XDataDescriptorFactory xKeyColFac = UnoRuntime.queryInterface(XDataDescriptorFactory.class, xKeyColumnSupplier.getColumns()); 164 xKeyColAppend = UnoRuntime.queryInterface(XAppend.class, xKeyColFac); 165 removePrimaryKeys(); 166 for (int i = 0; i < _fieldnames.length; i++) 167 { 168 XPropertySet xKeyColPropertySet = xKeyColFac.createDataDescriptor(); 169 xKeyColPropertySet.setPropertyValue(PropertyNames.PROPERTY_NAME, _fieldnames[i]); 170 keycolumncontainer.add(xKeyColPropertySet); 171 XPropertySet xColPropertySet = null; 172 if (hasByName(_fieldnames[i])) 173 { 174 xColPropertySet = getByName(_fieldnames[i]); 175 } 176 else 177 { 178 xColPropertySet = addPrimaryKeyColumn(_fieldnames[i]); 179 } 180 xColPropertySet.setPropertyValue("IsNullable", new Integer(com.sun.star.sdbc.ColumnValue.NO_NULLS)); 181 if (_bAutoincrementation) 182 { 183 int nDataType = oTypeInspector.getAutoIncrementIndex(xColPropertySet); 184 if (nDataType != oTypeInspector.INVALID) 185 { 186 if (xColPropertySet.getPropertySetInfo().hasPropertyByName("IsAutoIncrement")) 187 { 188 xColPropertySet.setPropertyValue("Type", new Integer(nDataType)); 189 xColPropertySet.setPropertyValue("IsAutoIncrement", Boolean.valueOf(_bAutoincrementation)); 190 } 191 } 192 } 193 modifyColumn(_fieldnames[i], xColPropertySet); 194 } 195 return true; 196 } 197 catch (UnknownPropertyException e) 198 { 199 e.printStackTrace(System.out); 200 } 201 catch (PropertyVetoException e) 202 { 203 e.printStackTrace(System.out); 204 } 205 catch (IllegalArgumentException e) 206 { 207 e.printStackTrace(System.out); 208 } 209 catch (WrappedTargetException e) 210 { 211 e.printStackTrace(System.out); 212 } 213 214 return false; 215 } 216 isColunnNameDuplicate(XNameAccess _xColumns, XPropertySet _xToBeAppendedPropertySet)217 public boolean isColunnNameDuplicate(XNameAccess _xColumns, XPropertySet _xToBeAppendedPropertySet) 218 { 219 try 220 { 221 String sColumnName = AnyConverter.toString(_xToBeAppendedPropertySet.getPropertyValue(PropertyNames.PROPERTY_NAME)); 222 if (_xColumns.hasByName(sColumnName)) 223 { 224 String sMessage = JavaTools.replaceSubString(sColumnAlreadyExistsMessage, sColumnName, "%FIELDNAME"); 225 showMessageBox("ErrorBox", VclWindowPeerAttribute.OK, sMessage); 226 return true; 227 } 228 return false; 229 } 230 catch (Exception ex) 231 { 232 ex.printStackTrace(System.out); 233 return false; 234 } 235 } 236 237 /** 238 * creates the table under the passed name 239 * @param _catalogname 240 * @param _schemaname 241 * @param _tablename is made unique if necessary 242 * @param _fieldnames 243 * @return true or false to indicate successful creation or not 244 */ createTable(String _catalogname, String _schemaname, String _tablename, String[] _fieldnames)245 public boolean createTable(String _catalogname, String _schemaname, String _tablename, String[] _fieldnames) 246 { 247 boolean breturn = true; 248 try 249 { 250 XAppend xAppendColumns = UnoRuntime.queryInterface(XAppend.class, xNameAccessColumns); 251 for (int i = 0; i < columncontainer.size(); i++) 252 { 253 XPropertySet xColPropertySet = getByIndex(i); 254 if (!isColunnNameDuplicate(xNameAccessColumns, xColPropertySet)) 255 { 256 xAppendColumns.appendByDescriptor(xColPropertySet); //xColPropertySet.setPropertyValue("Type", 32423) 257 } 258 else 259 { 260 breturn = false; 261 } 262 } 263 if (breturn) 264 { 265 assignTableProperty(PropertyNames.PROPERTY_NAME, _tablename); 266 assignTableProperty("CatalogName", _catalogname); 267 assignTableProperty("SchemaName", _schemaname); 268 xTableContainer = UnoRuntime.queryInterface(XContainer.class, getTableNamesAsNameAccess()); 269 xTableContainer.addContainerListener(this); 270 if (keycolumncontainer.size() > 0) 271 { 272 for (int i = 0; i < keycolumncontainer.size(); i++) 273 { 274 XPropertySet xKeyColPropertySet = (XPropertySet) keycolumncontainer.get(i); 275 if (!isColunnNameDuplicate(xKeyColumnSupplier.getColumns(), xKeyColPropertySet)) 276 { 277 xKeyColAppend.appendByDescriptor(xKeyColPropertySet); 278 } 279 else 280 { 281 breturn = false; 282 } 283 } 284 if (breturn) 285 { 286 xKeyAppend.appendByDescriptor(xKey); 287 } 288 } 289 if (breturn) 290 { 291 // TODO: LLA: describe what is he doing here. 292 xTableAppend.appendByDescriptor(xPropTableDataDescriptor); 293 } 294 } 295 } 296 catch (SQLException oSQLException) 297 { 298 super.callSQLErrorMessageDialog(oSQLException, xWindow); 299 breturn = false; 300 } 301 catch (Exception e) 302 { 303 e.printStackTrace(System.out); 304 breturn = false; 305 } 306 if (!breturn) 307 { 308 removeAllColumnsFromDescriptor(_tablename); 309 this.removePrimaryKeys(); 310 } 311 return breturn; 312 } 313 removeAllColumnsFromDescriptor(String _tablename)314 private boolean removeAllColumnsFromDescriptor(String _tablename) 315 { 316 try 317 { 318 xPropTableDataDescriptor.setPropertyValue(PropertyNames.PROPERTY_NAME, PropertyNames.EMPTY_STRING); 319 if ((xKeyDrop != null) && (xIndexAccessKeys != null)) 320 { 321 int icount = xIndexAccessKeys.getCount(); 322 if (icount > 0) 323 { 324 for (int i = xIndexAccessKeys.getCount() - 1; i >= 0; i--) 325 { 326 xKeyDrop.dropByIndex(i); 327 } 328 } 329 } 330 XDrop xColumnDrop = UnoRuntime.queryInterface(XDrop.class, xNameAccessColumns); 331 for (int i = xNameAccessColumns.getElementNames().length - 1; i >= 0; i--) 332 { 333 xColumnDrop.dropByIndex(i); 334 } 335 if (xTableDrop != null) 336 { 337 if (getTableNamesAsNameAccess().hasByName(_tablename)) 338 { 339 xTableDrop.dropByName(_tablename); 340 } 341 } 342 if (bIDFieldisInserted) 343 { 344 this.dropColumnbyName(this.IDFieldName); 345 bIDFieldisInserted = false; 346 } 347 return false; 348 } 349 catch (SQLException oSQLException) 350 { 351 super.callSQLErrorMessageDialog(oSQLException, xWindow); 352 } 353 catch (Exception e1) 354 { 355 e1.printStackTrace(System.out); 356 } 357 return false; 358 } 359 createTable(String _catalogname, String _schemaname, String _tablename, String[] _keycolumnnames, boolean _bAutoincrementation, String[] _fieldnames)360 public boolean createTable(String _catalogname, String _schemaname, String _tablename, String[] _keycolumnnames, boolean _bAutoincrementation, String[] _fieldnames) 361 { 362 if (createPrimaryKeys(_keycolumnnames, _bAutoincrementation)) 363 { 364 return createTable(_catalogname, _schemaname, _tablename, _fieldnames); 365 } 366 return false; 367 } 368 assignTableProperty(String _spropname, String _svalue)369 private void assignTableProperty(String _spropname, String _svalue) 370 { 371 if (_svalue != null) 372 { 373 if (!_svalue.equals(PropertyNames.EMPTY_STRING)) 374 { 375 try 376 { 377 xPropTableDataDescriptor.setPropertyValue(_spropname, _svalue); 378 } 379 catch (Exception e) 380 { 381 e.printStackTrace(System.out); 382 } 383 } 384 } 385 } 386 modifyColumnName(String _soldname, String _snewname)387 public boolean modifyColumnName(String _soldname, String _snewname) 388 { 389 try 390 { 391 return modifyColumn(_soldname, PropertyNames.PROPERTY_NAME, _snewname); 392 } 393 catch (Exception e) 394 { 395 e.printStackTrace(System.out); 396 showMessageBox("ErrorBox", VclWindowPeerAttribute.OK, e.getMessage()); 397 return false; 398 } 399 } 400 modifyColumn(String _sname, String _spropname, Object _oValue)401 public boolean modifyColumn(String _sname, String _spropname, Object _oValue) 402 { 403 try 404 { 405 if (this.columncontainer.size() > 0) 406 { 407 for (int i = 0; i < columncontainer.size(); i++) 408 { 409 ColumnDescriptor oColumnDescriptor = (ColumnDescriptor) columncontainer.get(i); 410 if (oColumnDescriptor.Name.equals(_sname)) 411 { 412 oColumnDescriptor.xColPropertySet.setPropertyValue(_spropname, _oValue); 413 if (_spropname.equals(PropertyNames.PROPERTY_NAME)) 414 { 415 oColumnDescriptor.Name = (String) _oValue; 416 } 417 columncontainer.remove(i); 418 columncontainer.insertElementAt(oColumnDescriptor, i); 419 return true; 420 } 421 } 422 } 423 } 424 catch (UnknownPropertyException e) 425 { 426 e.printStackTrace(System.out); 427 } 428 catch (PropertyVetoException e) 429 { 430 e.printStackTrace(System.out); 431 } 432 catch (IllegalArgumentException e) 433 { 434 e.printStackTrace(System.out); 435 } 436 catch (WrappedTargetException e) 437 { 438 e.printStackTrace(System.out); 439 } 440 return false; 441 } 442 modifyColumn(String _sname, XPropertySet _xColPropertySet)443 public boolean modifyColumn(String _sname, XPropertySet _xColPropertySet) 444 { 445 try 446 { 447 if (this.columncontainer.size() > 0) 448 { 449 for (int i = 0; i < columncontainer.size(); i++) 450 { 451 ColumnDescriptor oColumnDescriptor = (ColumnDescriptor) columncontainer.get(i); 452 if (oColumnDescriptor.Name.equals(_sname)) 453 { 454 oColumnDescriptor.xColPropertySet = _xColPropertySet; 455 oColumnDescriptor.Name = (String) _xColPropertySet.getPropertyValue(PropertyNames.PROPERTY_NAME); 456 columncontainer.remove(i); 457 columncontainer.insertElementAt(oColumnDescriptor, i); 458 return true; 459 } 460 } 461 } 462 } 463 catch (Exception e) 464 { 465 e.printStackTrace(System.out); 466 } 467 return false; 468 } 469 dropColumnbyName(String _sname)470 public void dropColumnbyName(String _sname) 471 { 472 try 473 { 474 if (columncontainer.size() > 0) 475 { 476 for (int i = 0; i < columncontainer.size(); i++) 477 { 478 ColumnDescriptor oColumnDescriptor = (ColumnDescriptor) columncontainer.get(i); 479 if (oColumnDescriptor != null) 480 { 481 if (oColumnDescriptor.Name.equals(_sname)) 482 { 483 columncontainer.remove(i); 484 } 485 } 486 } 487 } 488 } 489 catch (Exception e) 490 { 491 e.printStackTrace(System.out); 492 } 493 } 494 getColumnNames()495 public String[] getColumnNames() 496 { 497 if (columncontainer.size() > 0) 498 { 499 try 500 { 501 String[] fieldnames = new String[columncontainer.size()]; 502 for (int i = 0; i < columncontainer.size(); i++) 503 { 504 ColumnDescriptor oColumnDescriptor = (ColumnDescriptor) columncontainer.get(i); 505 fieldnames[i] = oColumnDescriptor.Name; 506 } 507 return fieldnames; 508 } 509 catch (RuntimeException e) 510 { 511 e.printStackTrace(System.out); 512 } 513 } 514 return new String[] 515 { 516 }; 517 } 518 hasByName(String _fieldname)519 private boolean hasByName(String _fieldname) 520 { 521 try 522 { 523 if (columncontainer.size() > 0) 524 { 525 for (int i = 0; i < columncontainer.size(); i++) 526 { 527 ColumnDescriptor oColumnDescriptor = (ColumnDescriptor) columncontainer.get(i); 528 if (oColumnDescriptor.Name.equals(_fieldname)) 529 { 530 return true; 531 } 532 } 533 } 534 } 535 catch (RuntimeException e) 536 { 537 e.printStackTrace(System.out); 538 } 539 return false; 540 } 541 getColumnDescriptorByName(String _fieldname)542 private ColumnDescriptor getColumnDescriptorByName(String _fieldname) 543 { 544 try 545 { 546 if (this.columncontainer.size() > 0) 547 { 548 for (int i = 0; i < columncontainer.size(); i++) 549 { 550 ColumnDescriptor oColumnDescriptor = (ColumnDescriptor) columncontainer.get(i); 551 if (oColumnDescriptor.Name.equals(_fieldname)) 552 { 553 return oColumnDescriptor; 554 } 555 } 556 } 557 } 558 catch (RuntimeException e) 559 { 560 e.printStackTrace(System.out); 561 } 562 return null; 563 } 564 getByName(String _fieldname)565 public XPropertySet getByName(String _fieldname) 566 { 567 ColumnDescriptor oColumnDescriptor = getColumnDescriptorByName(_fieldname); 568 if (oColumnDescriptor != null) 569 { 570 return oColumnDescriptor.xColPropertySet; 571 } 572 else 573 { 574 return null; 575 } 576 } 577 getByIndex(int _index)578 private XPropertySet getByIndex(int _index) 579 { 580 try 581 { 582 if (columncontainer.size() > _index) 583 { 584 ColumnDescriptor oColumnDescriptor = (ColumnDescriptor) columncontainer.get(_index); 585 return oColumnDescriptor.xColPropertySet; 586 } 587 } 588 catch (RuntimeException e) 589 { 590 e.printStackTrace(System.out); 591 } 592 return null; 593 } 594 clonePropertySet(String _snewname, XPropertySet _xnewPropertySet)595 public XPropertySet clonePropertySet(String _snewname, XPropertySet _xnewPropertySet) 596 { 597 XPropertySet xRetPropertySet = xColumnDataDescriptorFactory.createDataDescriptor(); 598 try 599 { 600 if (hasByName(_snewname)) 601 { 602 Object oColumn = getByName(_snewname); 603 XPropertySet xPropertySet = UnoRuntime.queryInterface(XPropertySet.class, oColumn); 604 Property[] aColProperties = xPropertySet.getPropertySetInfo().getProperties(); 605 for (int i = 0; i < aColProperties.length; i++) 606 { 607 String sPropName = aColProperties[i].Name; 608 Object oColValue = _xnewPropertySet.getPropertyValue(sPropName); 609 xRetPropertySet.setPropertyValue(sPropName, oColValue); 610 } 611 } 612 } 613 catch (Exception e) 614 { 615 e.printStackTrace(System.out); 616 } 617 return xRetPropertySet; 618 } 619 addColumn(PropertyValue[] _aNewPropertyValues)620 public boolean addColumn(PropertyValue[] _aNewPropertyValues) 621 { 622 try 623 { 624 String sname = (String) Properties.getPropertyValue(_aNewPropertyValues, PropertyNames.PROPERTY_NAME); 625 if (!hasByName(sname)) 626 { 627 ColumnPropertySet oPropertySet = new ColumnPropertySet(oTypeInspector, xColumnDataDescriptorFactory.createDataDescriptor()); 628 oPropertySet.assignPropertyValues(_aNewPropertyValues, true); 629 ColumnDescriptor oColumnDescriptor = new ColumnDescriptor(oPropertySet.xPropertySet, sname); 630 this.columncontainer.add(oColumnDescriptor); 631 return true; 632 } 633 } 634 catch (Exception e) 635 { 636 e.printStackTrace(System.out); 637 } 638 return false; 639 } 640 moveColumn(int _nOldIndex, int _nNewIndex)641 public boolean moveColumn(int _nOldIndex, int _nNewIndex) 642 { 643 try 644 { 645 ColumnDescriptor oColumnDescriptor = (ColumnDescriptor) this.columncontainer.get(_nOldIndex); 646 this.columncontainer.remove(_nOldIndex); 647 columncontainer.add(_nNewIndex, oColumnDescriptor); 648 return true; 649 } 650 catch (Exception e) 651 { 652 e.printStackTrace(System.out); 653 return false; 654 } 655 } 656 addColumn(String _columnname, XPropertySet _xNewColPropertySet)657 public boolean addColumn(String _columnname, XPropertySet _xNewColPropertySet) 658 { 659 try 660 { 661 if (!hasByName(_columnname)) 662 { 663 if (_columnname.equals(PropertyNames.EMPTY_STRING)) 664 { 665 return false; 666 } 667 else 668 { 669 ColumnPropertySet oPropertySet = new ColumnPropertySet(oTypeInspector, xColumnDataDescriptorFactory.createDataDescriptor()); 670 oPropertySet.assignNewPropertySet(_columnname, _xNewColPropertySet); 671 ColumnDescriptor oColumnDescriptor = new ColumnDescriptor(oPropertySet.xPropertySet, _columnname); 672 columncontainer.add(oColumnDescriptor); 673 return true; 674 } 675 } 676 } 677 catch (Exception e) 678 { 679 e.printStackTrace(System.out); 680 } 681 return false; 682 } 683 addPrimaryKeyColumn(String _columnname)684 public XPropertySet addPrimaryKeyColumn(String _columnname) 685 { 686 try 687 { 688 if (!hasByName(_columnname)) 689 { 690 try 691 { 692 XPropertySet xColPropertySet = xColumnDataDescriptorFactory.createDataDescriptor(); 693 IDFieldName = Desktop.getUniqueName(getColumnNames(), _columnname, PropertyNames.EMPTY_STRING); 694 xColPropertySet.setPropertyValue(PropertyNames.PROPERTY_NAME, IDFieldName); 695 696 int nDataType = oTypeInspector.convertDataType(com.sun.star.sdbc.DataType.INTEGER); 697 xColPropertySet.setPropertyValue("Type", new Integer(nDataType)); 698 xColPropertySet.setPropertyValue("TypeName", oTypeInspector.getDefaultTypeName(nDataType, null)); 699 ColumnDescriptor oColumnDescriptor = new ColumnDescriptor(xColPropertySet, IDFieldName); 700 this.columncontainer.add(0, oColumnDescriptor); 701 this.bIDFieldisInserted = true; 702 return xColPropertySet; 703 } 704 catch (RuntimeException e1) 705 { 706 e1.printStackTrace(System.out); 707 } 708 } 709 } 710 catch (Exception e) 711 { 712 e.printStackTrace(System.out); 713 } 714 return null; 715 } 716 getNonBinaryFieldNames()717 public String[] getNonBinaryFieldNames() 718 { 719 Vector NonBinaryFieldNameVector = new Vector(); 720 try 721 { 722 for (int i = 0; i < columncontainer.size(); i++) 723 { 724 ColumnDescriptor oColumnDescriptor = (ColumnDescriptor) columncontainer.get(i); 725 XPropertySet xColPropertySet = getByName(oColumnDescriptor.Name); 726 Property[] aProperties = xColPropertySet.getPropertySetInfo().getProperties(); 727 int itype; 728 try 729 { 730 itype = AnyConverter.toInt(xColPropertySet.getPropertyValue("Type")); 731 if (!isBinaryDataType(itype)) 732 { 733 NonBinaryFieldNameVector.addElement(oColumnDescriptor.Name); 734 } 735 } 736 catch (Exception e) 737 { 738 e.printStackTrace(System.out); 739 } 740 } 741 } 742 catch (RuntimeException e) 743 { 744 e.printStackTrace(System.out); 745 } 746 String[] sbinaryfieldnames = new String[NonBinaryFieldNameVector.size()]; 747 NonBinaryFieldNameVector.toArray(sbinaryfieldnames); 748 return sbinaryfieldnames; 749 } 750 getComposedTableName(String _scatalogname, String _sschemaname, String _stablename)751 public String getComposedTableName(String _scatalogname, String _sschemaname, String _stablename) 752 { 753 ComposedTableName = new CommandName(this, _scatalogname, _sschemaname, _stablename, false); 754 return ComposedTableName.getComposedName(); 755 } 756 getComposedTableName()757 public String getComposedTableName() 758 { 759 if (ComposedTableName != null) 760 { 761 return this.ComposedTableName.getComposedName(); 762 } 763 else 764 { 765 return null; 766 } 767 } 768 769 /* (non-Javadoc) 770 * @see com.sun.star.container.XContainerListener#elementInserted(com.sun.star.container.ContainerEvent) 771 */ elementInserted(ContainerEvent arg0)772 public void elementInserted(ContainerEvent arg0) 773 { 774 try 775 { 776 XPropertySet xTablePropertySet = UnoRuntime.queryInterface(XPropertySet.class, arg0.Element); 777 String stablename = AnyConverter.toString(xTablePropertySet.getPropertyValue(PropertyNames.PROPERTY_NAME)); 778 String sschemaname = AnyConverter.toString(xPropTableDataDescriptor.getPropertyValue("SchemaName")); 779 String scatalogname = AnyConverter.toString(xPropTableDataDescriptor.getPropertyValue("CatalogName")); 780 ComposedTableName = new CommandName(this, scatalogname, sschemaname, stablename, false); 781 appendTableNameToFilter(ComposedTableName.getComposedName()); 782 } 783 catch (Exception e) 784 { 785 e.printStackTrace(System.out); 786 } 787 } 788 789 /* (non-Javadoc) 790 * @see com.sun.star.container.XContainerListener#elementRemoved(com.sun.star.container.ContainerEvent) 791 */ elementRemoved(ContainerEvent arg0)792 public void elementRemoved(ContainerEvent arg0) 793 { 794 } 795 796 /* (non-Javadoc) 797 * @see com.sun.star.container.XContainerListener#elementReplaced(com.sun.star.container.ContainerEvent) 798 */ elementReplaced(ContainerEvent arg0)799 public void elementReplaced(ContainerEvent arg0) 800 { 801 } 802 803 /* (non-Javadoc) 804 * @see com.sun.star.lang.XEventListener#disposing(com.sun.star.lang.EventObject) 805 */ disposing(EventObject arg0)806 public void disposing(EventObject arg0) 807 { 808 } 809 810 /** 811 * @param _stablename 812 * @return 813 */ appendTableNameToFilter(String _scomposedtablename)814 public boolean appendTableNameToFilter(String _scomposedtablename) 815 { 816 boolean bhastoinsert = true; 817 for (int i = 0; i < sTableFilters.length; i++) 818 { 819 if (sTableFilters[i].compareTo("%") > -1) 820 { 821 if (sTableFilters[i].endsWith("." + _scomposedtablename)) 822 { 823 bhastoinsert = false; 824 } 825 else if (sTableFilters[i].length() == 1) 826 { 827 bhastoinsert = false; 828 } 829 } 830 else if (sTableFilters[i].equals(_scomposedtablename)) 831 { 832 bhastoinsert = false; 833 } 834 if (!bhastoinsert) 835 { 836 break; 837 } 838 } 839 if (bhastoinsert) 840 { 841 String[] sNewTableFilters = new String[sTableFilters.length + 1]; 842 System.arraycopy(sTableFilters, 0, sNewTableFilters, 0, sTableFilters.length); 843 sNewTableFilters[sTableFilters.length] = _scomposedtablename; 844 sTableFilters = sNewTableFilters; 845 try 846 { 847 getDataSourcePropertySet().setPropertyValue("TableFilter", sTableFilters); 848 } 849 catch (Exception e) 850 { 851 e.printStackTrace(System.out); 852 bhastoinsert = false; 853 } 854 } 855 return bhastoinsert; 856 } 857 } 858 859