/offapi/com/sun/star/sdbc/XDatabaseMetaData.idl
IDL | 2453 lines | 197 code | 159 blank | 2097 comment | 0 complexity | b8bf9ee063eae02d0787a8aef2d7855b MD5 | raw file
Possible License(s): GPL-3.0, LGPL-3.0, MPL-2.0-no-copyleft-exception, LGPL-2.1, BSD-3-Clause-No-Nuclear-License-2014
1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ 2/* 3 * This file is part of the LibreOffice project. 4 * 5 * This Source Code Form is subject to the terms of the Mozilla Public 6 * License, v. 2.0. If a copy of the MPL was not distributed with this 7 * file, You can obtain one at http://mozilla.org/MPL/2.0/. 8 * 9 * This file incorporates work covered by the following license notice: 10 * 11 * Licensed to the Apache Software Foundation (ASF) under one or more 12 * contributor license agreements. See the NOTICE file distributed 13 * with this work for additional information regarding copyright 14 * ownership. The ASF licenses this file to you under the Apache 15 * License, Version 2.0 (the "License"); you may not use this file 16 * except in compliance with the License. You may obtain a copy of 17 * the License at http://www.apache.org/licenses/LICENSE-2.0 . 18 */ 19#ifndef __com_sun_star_sdbc_XDatabaseMetaData_idl__ 20#define __com_sun_star_sdbc_XDatabaseMetaData_idl__ 21 22#include <com/sun/star/uno/XInterface.idl> 23 24#include <com/sun/star/sdbc/SQLException.idl> 25 26 27 module com { module sun { module star { module sdbc { 28 29 published interface XResultSet; 30 published interface XConnection; 31 32/** provides comprehensive information about the database as a whole. 33 34 35 <p>Many of the methods here return lists of information in 36 the form of 37 <type scope="com::sun::star::sdbc">XResultSet</type> 38 objects. 39 You can use the normal <type scope="com::sun::star::sdbc">XRow</type> 40 (or <type scope="com::sun::star::sdb">XColumn</type>) 41 methods such as 42 <member scope="com::sun::star::sdbc">XRow::getString()</member> 43 and 44 <member scope="com::sun::star::sdbc">XRow::getInt()</member> 45 to retrieve the data from these XResultSets. If a given form of 46 metadata is not available, these methods should throw a 47 <type scope="com::sun::star::sdbc">SQLException</type> 48 . 49 After calling one of the getXXX() methods, 50 one can check whether that value is <NULL/> 51 with the method <member scope="com::sun::star::sdbc">XRow::wasNull()</member>. 52 In the text only "(may be <NULL/>)" is mentioned for this case. 53 </p> 54 <p>Some of these methods take arguments that are String patterns. These 55 arguments all have names such as fooPattern. Within a pattern String, "%" 56 means match any substring of 0 or more characters, and "_" means match 57 any one character. Only metadata entries matching the search pattern 58 are returned. If a search pattern argument is set to <VOID/>, 59 that argument's criteria will be dropped from the search. 60 </p> 61 <p> 62 A 63 <type scope="com::sun::star::sdbc">SQLException</type> 64 will be thrown if a driver does not support 65 a metadata method. In the case of methods that return an XResultSet, 66 either an XResultSet (which may be empty) is returned or a 67 SQLException is thrown.</p> 68 */ 69published interface XDatabaseMetaData: com::sun::star::uno::XInterface 70{ 71 72 /** Can all the procedures returned by getProcedures be called by the 73 current user? 74 75 @return 76 <TRUE/> 77 if the user is allowed to call all procedures returned by getProcedures 78 otherwise 79 <FALSE/> 80 . 81 @throws SQLException 82 if a database access error occurs. 83 */ 84 boolean allProceduresAreCallable() raises (SQLException); 85 86 /** Can all the tables returned by getTable be SELECTed by the 87 current user? 88 @returns 89 <TRUE/> if so 90 @throws SQLException 91 if a database access error occurs. 92 */ 93 boolean allTablesAreSelectable() raises (SQLException); 94 95 /** returns the URL for the database connection 96 */ 97 string getURL() raises (SQLException); 98 99 /** returns the user name from this database connection. 100 */ 101 string getUserName() raises (SQLException); 102 103 /** checks if the database in read-only mode. 104 @returns 105 <TRUE/> if so 106 @throws SQLException 107 if a database access error occurs. 108 */ 109 boolean isReadOnly() raises (SQLException); 110 111 /** Are NULL values sorted high? 112 @returns 113 <TRUE/> if so 114 @throws SQLException 115 if a database access error occurs. 116 */ 117 boolean nullsAreSortedHigh() raises (SQLException); 118 119 /** Are NULL values sorted low? 120 @returns 121 <TRUE/> if so 122 @throws SQLException 123 if a database access error occurs. 124 */ 125 boolean nullsAreSortedLow() raises (SQLException); 126 127 /** Are NULL values sorted at the start regardless of sort order? 128 @returns 129 <TRUE/> if so 130 @throws SQLException 131 if a database access error occurs. 132 */ 133 boolean nullsAreSortedAtStart() raises (SQLException); 134 135 /** Are NULL values sorted at the end, regardless of sort order? 136 @returns 137 <TRUE/> if so 138 @throws SQLException 139 if a database access error occurs. 140 */ 141 boolean nullsAreSortedAtEnd() raises (SQLException); 142 143 /** returns the name of the database product. 144 */ 145 string getDatabaseProductName() raises (SQLException); 146 147 /** returns the version of the database product. 148 */ 149 string getDatabaseProductVersion() raises (SQLException); 150 151 /** returns the name of the SDBC driver. 152 */ 153 string getDriverName() raises (SQLException); 154 155 /** returns the version number of the SDBC driver. 156 */ 157 string getDriverVersion() raises (SQLException); 158 159 /** returns the SDBC driver major version number. 160 */ 161 long getDriverMajorVersion(); 162 163 /** returns the SDBC driver minor version number. 164 */ 165 long getDriverMinorVersion(); 166 167 /** use the database local files to save the tables. 168 @returns 169 <TRUE/> if so 170 @throws SQLException 171 if a database access error occurs. 172 */ 173 boolean usesLocalFiles() raises (SQLException); 174 175 /** use the database one local file to save for each table. 176 @returns 177 <TRUE/> if so 178 @throws SQLException 179 if a database access error occurs. 180 */ 181 boolean usesLocalFilePerTable() raises (SQLException); 182 183 /** use the database "mixed case unquoted SQL identifiers" case sensitive. 184 @returns 185 <TRUE/> if so 186 @throws SQLException 187 if a database access error occurs. 188 */ 189 boolean supportsMixedCaseIdentifiers() raises (SQLException); 190 191 /** Does the database treat mixed case unquoted SQL identifiers as 192 case insensitive and store them in upper case? 193 @returns 194 <TRUE/> if so 195 @throws SQLException 196 if a database access error occurs. 197 */ 198 boolean storesUpperCaseIdentifiers() raises (SQLException); 199 200 /** Does the database treat mixed case unquoted SQL identifiers as 201 case insensitive and store them in lower case? 202 @returns 203 <TRUE/> if so 204 @throws SQLException 205 if a database access error occurs. 206 */ 207 boolean storesLowerCaseIdentifiers() raises (SQLException); 208 209 /** Does the database treat mixed case unquoted SQL identifiers as 210 case insensitive and store them in mixed case? 211 @returns 212 <TRUE/> if so 213 @throws SQLException 214 if a database access error occurs. 215 */ 216 boolean storesMixedCaseIdentifiers() raises (SQLException); 217 218 /** Does the database treat mixed case quoted SQL identifiers as 219 case sensitive and as a result store them in mixed case? 220 @returns 221 <TRUE/> if so 222 @throws SQLException 223 if a database access error occurs. 224 */ 225 boolean supportsMixedCaseQuotedIdentifiers() raises (SQLException); 226 227 /** Does the database treat mixed case quoted SQL identifiers as 228 case insensitive and store them in upper case? 229 @returns 230 <TRUE/> if so 231 @throws SQLException 232 if a database access error occurs. 233 */ 234 boolean storesUpperCaseQuotedIdentifiers() raises (SQLException); 235 236 /** Does the database treat mixed case quoted SQL identifiers as 237 case insensitive and store them in lower case? 238 @returns 239 <TRUE/> if so 240 @throws SQLException 241 if a database access error occurs. 242 */ 243 boolean storesLowerCaseQuotedIdentifiers() raises (SQLException); 244 245 /** Does the database treat mixed case quoted SQL identifiers as 246 case insensitive and store them in mixed case? 247 @returns 248 <TRUE/> if so 249 @throws SQLException 250 if a database access error occurs. 251 */ 252 boolean storesMixedCaseQuotedIdentifiers() raises (SQLException); 253 254 /** What's the string used to quote SQL identifiers? 255 This returns a space " " if identifier quoting is not supported. 256 @returns 257 <TRUE/> if so 258 @throws SQLException 259 if a database access error occurs. 260 */ 261 string getIdentifierQuoteString() raises (SQLException); 262 263 /** gets a comma-separated list of all a database's SQL keywords 264 that are NOT also SQL92 keywords. 265 @returns 266 <TRUE/> if so 267 @throws SQLException 268 if a database access error occurs. 269 */ 270 string getSQLKeywords() raises (SQLException); 271 272 /** gets a comma-separated list of math functions. These are the 273 X/Open CLI math function names used in the SDBC function escape 274 clause. 275 @returns 276 <TRUE/> if so 277 @throws SQLException 278 if a database access error occurs. 279 */ 280 string getNumericFunctions() raises (SQLException); 281 282 /** gets a comma-separated list of string functions. These are the 283 X/Open CLI string function names used in the SDBC function escape 284 clause. 285 @returns 286 <TRUE/> if so 287 @throws SQLException 288 if a database access error occurs. 289 */ 290 string getStringFunctions() raises (SQLException); 291 292 /** gets a comma-separated list of system functions. These are the 293 X/Open CLI system function names used in the SDBC function escape 294 clause. 295 @returns 296 <TRUE/> if so 297 @throws SQLException 298 if a database access error occurs. 299 */ 300 string getSystemFunctions() raises (SQLException); 301 302 /** gets a comma-separated list of time and date functions. 303 @returns 304 <TRUE/> if so 305 @throws SQLException 306 if a database access error occurs. 307 */ 308 string getTimeDateFunctions() raises (SQLException); 309 310 /** gets the string that can be used to escape wildcard characters. 311 This is the string that can be used to escape "_" or "%" in 312 the string pattern style catalog search parameters. 313 314 315 <p> 316 The "_" character represents any single character. 317 </p> 318 <p> 319 The "%" character represents any sequence of zero or 320 more characters. 321 </p> 322 @returns 323 <TRUE/> if so 324 @throws SQLException 325 if a database access error occurs. 326 */ 327 string getSearchStringEscape() raises (SQLException); 328 329 /** gets all the "extra" characters that can be used in unquoted 330 identifier names (those beyond a-z, A-Z, 0-9 and _). 331 @returns 332 <TRUE/> if so 333 @throws SQLException 334 if a database access error occurs. 335 */ 336 string getExtraNameCharacters() raises (SQLException); 337 338 /** support the Database "ALTER TABLE" with add column? 339 @returns 340 <TRUE/> if so 341 @throws SQLException 342 if a database access error occurs. 343 */ 344 boolean supportsAlterTableWithAddColumn() raises (SQLException); 345 346 /** support the Database "ALTER TABLE" with drop column? 347 @returns 348 <TRUE/> if so 349 @throws SQLException 350 if a database access error occurs. 351 */ 352 boolean supportsAlterTableWithDropColumn() raises (SQLException); 353 354 /** support the Database column aliasing? 355 356 357 <p> 358 The SQL AS clause can be used to provide names for 359 computed columns or to provide alias names for columns as required. 360 </p> 361 @returns 362 <TRUE/> if so 363 @throws SQLException 364 if a database access error occurs. 365 */ 366 boolean supportsColumnAliasing() raises (SQLException); 367 368 /** are concatenations between NULL and non-NULL values NULL? 369 @returns 370 <TRUE/> if so 371 @throws SQLException 372 if a database access error occurs. 373 */ 374 boolean nullPlusNonNullIsNull() raises (SQLException); 375 376 /** <TRUE/> 377 , if the Database supports the CONVERT function between SQL types, 378 otherwise 379 <FALSE/> 380 . 381 @returns 382 <TRUE/> if so 383 @throws SQLException 384 if a database access error occurs. 385 */ 386 boolean supportsTypeConversion() raises (SQLException); 387 388 /** <TRUE/> 389 , if the Database supports the CONVERT between the given SQL types 390 otherwise 391 <FALSE/> 392 . 393 @returns 394 <TRUE/> if so 395 @throws SQLException 396 if a database access error occurs. 397 */ 398 boolean supportsConvert([in]long fromType, [in]long toType) 399 raises (SQLException); 400 401 /** Are table correlation names supported? 402 @returns 403 <TRUE/> if so 404 @throws SQLException 405 if a database access error occurs. 406 */ 407 boolean supportsTableCorrelationNames() raises (SQLException); 408 409 /** If table correlation names are supported, are they restricted 410 to be different from the names of the tables? 411 @returns 412 <TRUE/> if so 413 @throws SQLException 414 if a database access error occurs. 415 */ 416 boolean supportsDifferentTableCorrelationNames() 417 raises (SQLException); 418 419 /** Are expressions in "ORDER BY" lists supported? 420 @returns 421 <TRUE/> if so 422 @throws SQLException 423 if a database access error occurs. 424 */ 425 boolean supportsExpressionsInOrderBy() raises (SQLException); 426 427 /** Can an "ORDER BY" clause use columns not in the SELECT statement? 428 @returns 429 <TRUE/> if so 430 @throws SQLException 431 if a database access error occurs. 432 */ 433 boolean supportsOrderByUnrelated() raises (SQLException); 434 435 /** Is some form of "GROUP BY" clause supported? 436 @returns 437 <TRUE/> if so 438 @throws SQLException 439 if a database access error occurs. 440 */ 441 boolean supportsGroupBy() raises (SQLException); 442 443 /** Can a "GROUP BY" clause use columns not in the SELECT? 444 @returns 445 <TRUE/> if so 446 @throws SQLException 447 if a database access error occurs. 448 */ 449 boolean supportsGroupByUnrelated() raises (SQLException); 450 451 /** Can a "GROUP BY" clause add columns not in the SELECT 452 provided it specifies all the columns in the SELECT? 453 @returns 454 <TRUE/> if so 455 @throws SQLException 456 if a database access error occurs. 457 */ 458 boolean supportsGroupByBeyondSelect() raises (SQLException); 459 460 /** Is the escape character in "LIKE" clauses supported? 461 @returns 462 <TRUE/> if so 463 @throws SQLException 464 if a database access error occurs. 465 */ 466 boolean supportsLikeEscapeClause() raises (SQLException); 467 468 /** Are multiple XResultSets from a single execute supported? 469 @returns 470 <TRUE/> if so 471 @throws SQLException 472 if a database access error occurs. 473 */ 474 boolean supportsMultipleResultSets() raises (SQLException); 475 476 /** Can we have multiple transactions open at once (on different 477 connections)? 478 @returns 479 <TRUE/> if so 480 @throws SQLException 481 if a database access error occurs. 482 */ 483 boolean supportsMultipleTransactions() raises (SQLException); 484 485 /** Can columns be defined as non-nullable? 486 @returns 487 <TRUE/> if so 488 @throws SQLException 489 if a database access error occurs. 490 */ 491 boolean supportsNonNullableColumns() raises (SQLException); 492 493 /** <TRUE/>, if the database supports ODBC Minimum SQL grammar, 494 otherwise <FALSE/>. 495 @returns 496 <TRUE/> if so 497 @throws SQLException 498 if a database access error occurs. 499 */ 500 boolean supportsMinimumSQLGrammar() raises (SQLException); 501 502 /** <TRUE/>, if the database supports ODBC Core SQL grammar, 503 otherwise <FALSE/>. 504 @returns 505 <TRUE/> if so 506 @throws SQLException 507 if a database access error occurs. 508 */ 509 boolean supportsCoreSQLGrammar() raises (SQLException); 510 511 /** 512 <TRUE/>, if the database supports ODBC Extended SQL grammar, 513 otherwise <FALSE/>. 514 @returns 515 <TRUE/> if so 516 @throws SQLException 517 if a database access error occurs. 518 */ 519 boolean supportsExtendedSQLGrammar() raises (SQLException); 520 521 /** @returns 522 <TRUE/>, if the database supports ANSI92 entry level SQL grammar, 523 otherwise <FALSE/>. 524 @throws SQLException 525 if a database access error occurs. 526 */ 527 boolean supportsANSI92EntryLevelSQL() raises (SQLException); 528 529 /** @returns 530 <TRUE/>, if the database supports ANSI92 intermediate SQL grammar, 531 otherwise <FALSE/>. 532 @throws SQLException 533 if a database access error occurs. 534 */ 535 boolean supportsANSI92IntermediateSQL() raises (SQLException); 536 537 /** @returns 538 <TRUE/>, if the database supports ANSI92 full SQL grammar, 539 otherwise <FALSE/>. 540 @throws SQLException 541 if a database access error occurs. 542 */ 543 boolean supportsANSI92FullSQL() raises (SQLException); 544 545 /** returns 546 <TRUE/>, if the Database supports SQL Integrity Enhancement Facility, 547 otherwise <FALSE/>. 548 @throws SQLException 549 if a database access error occurs. 550 */ 551 boolean supportsIntegrityEnhancementFacility() raises (SQLException); 552 553 /** @returns 554 <TRUE/>, if some form of outer join is supported, 555 otherwise <FALSE/>. 556 @throws SQLException 557 if a database access error occurs. 558 */ 559 boolean supportsOuterJoins() raises (SQLException); 560 561 /** @returns 562 <TRUE/>, if full nested outer joins are supported, 563 otherwise <FALSE/>. 564 @throws SQLException 565 if a database access error occurs. 566 */ 567 boolean supportsFullOuterJoins() raises (SQLException); 568 569 /** @returns 570 <TRUE/>, if there is limited support for outer joins. 571 (This will be <TRUE/> if supportFullOuterJoins is <TRUE/>.) 572 <FALSE/> is returned otherwise. 573 @throws SQLException 574 if a database access error occurs. 575 */ 576 boolean supportsLimitedOuterJoins() raises (SQLException); 577 578 /** return the database vendor's preferred term for "schema" 579 @returns 580 <TRUE/> if so 581 @throws SQLException 582 if a database access error occurs. 583 */ 584 string getSchemaTerm() raises (SQLException); 585 586 /** return the database vendor's preferred term for "procedure" 587 @returns 588 <TRUE/> if so 589 @throws SQLException 590 if a database access error occurs. 591 */ 592 string getProcedureTerm() raises (SQLException); 593 594 /** return the database vendor's preferred term for "catalog" 595 @returns 596 <TRUE/> if so 597 @throws SQLException 598 if a database access error occurs. 599 */ 600 string getCatalogTerm() raises (SQLException); 601 602 /** Does a catalog appear at the start of a qualified table name? 603 (Otherwise it appears at the end) 604 @returns 605 <TRUE/> if so 606 @throws SQLException 607 if a database access error occurs. 608 */ 609 boolean isCatalogAtStart() raises (SQLException); 610 611 /** return the separator between catalog and table name 612 @returns 613 <TRUE/> if so 614 @throws SQLException 615 if a database access error occurs. 616 */ 617 string getCatalogSeparator() raises (SQLException); 618 619 /** Can a schema name be used in a data manipulation statement? 620 @returns 621 <TRUE/> if so 622 @throws SQLException 623 if a database access error occurs. 624 */ 625 boolean supportsSchemasInDataManipulation() raises (SQLException); 626 627 /** Can a schema name be used in a procedure call statement? 628 @returns 629 <TRUE/> if so 630 @throws SQLException 631 if a database access error occurs. 632 */ 633 boolean supportsSchemasInProcedureCalls() raises (SQLException); 634 635 /** Can a schema name be used in a table definition statement? 636 @returns 637 <TRUE/> if so 638 @throws SQLException 639 if a database access error occurs. 640 */ 641 boolean supportsSchemasInTableDefinitions() raises (SQLException); 642 643 /** Can a schema name be used in an index definition statement? 644 @returns 645 <TRUE/> if so 646 @throws SQLException 647 if a database access error occurs. 648 */ 649 boolean supportsSchemasInIndexDefinitions() raises (SQLException); 650 651 /** Can a schema name be used in a privilege definition statement? 652 @returns 653 <TRUE/> if so 654 @throws SQLException 655 if a database access error occurs. 656 */ 657 boolean supportsSchemasInPrivilegeDefinitions() 658 raises (SQLException); 659 660 /** Can a catalog name be used in a data manipulation statement? 661 @returns 662 <TRUE/> if so 663 @throws SQLException 664 if a database access error occurs. 665 */ 666 boolean supportsCatalogsInDataManipulation() raises (SQLException); 667 668 /** Can a catalog name be used in a procedure call statement? 669 @returns 670 <TRUE/> if so 671 @throws SQLException 672 if a database access error occurs. 673 */ 674 boolean supportsCatalogsInProcedureCalls() raises (SQLException); 675 676 /** Can a catalog name be used in a table definition statement? 677 @returns 678 <TRUE/> if so 679 @throws SQLException 680 if a database access error occurs. 681 */ 682 boolean supportsCatalogsInTableDefinitions() raises (SQLException); 683 684 /** Can a catalog name be used in an index definition statement? 685 @returns 686 <TRUE/> if so 687 @throws SQLException 688 if a database access error occurs. 689 */ 690 boolean supportsCatalogsInIndexDefinitions() raises (SQLException); 691 692 /** Can a catalog name be used in a privilege definition statement? 693 @returns 694 <TRUE/> if so 695 @throws SQLException 696 if a database access error occurs. 697 */ 698 boolean supportsCatalogsInPrivilegeDefinitions() 699 raises (SQLException); 700 701 /** Is positioned DELETE supported? 702 @returns 703 <TRUE/> if so 704 @throws SQLException 705 if a database access error occurs. 706 */ 707 boolean supportsPositionedDelete() raises (SQLException); 708 709 /** Is positioned UPDATE supported? 710 @returns 711 <TRUE/> if so 712 @throws SQLException 713 if a database access error occurs. 714 */ 715 boolean supportsPositionedUpdate() raises (SQLException); 716 717 /** Is SELECT for UPDATE supported? 718 @returns 719 <TRUE/> if so 720 @throws SQLException 721 if a database access error occurs. 722 */ 723 boolean supportsSelectForUpdate() raises (SQLException); 724 725 /** Are stored procedure calls using the stored procedure escape 726 syntax supported? 727 @returns 728 <TRUE/> if so 729 @throws SQLException 730 if a database access error occurs. 731 */ 732 boolean supportsStoredProcedures() raises (SQLException); 733 734 /** Are subqueries in comparison expressions supported? 735 @returns 736 <TRUE/> if so 737 @throws SQLException 738 if a database access error occurs. 739 */ 740 boolean supportsSubqueriesInComparisons() raises (SQLException); 741 742 /** Are subqueries in "exists" expressions supported? 743 @returns 744 <TRUE/> if so 745 @throws SQLException 746 if a database access error occurs. 747 */ 748 boolean supportsSubqueriesInExists() raises (SQLException); 749 750 /** Are subqueries in "in" statements supported? 751 @returns 752 <TRUE/> if so 753 @throws SQLException 754 if a database access error occurs. 755 */ 756 boolean supportsSubqueriesInIns() raises (SQLException); 757 758 /** Are subqueries in quantified expressions supported? 759 @returns 760 <TRUE/> if so 761 @throws SQLException 762 if a database access error occurs. 763 */ 764 boolean supportsSubqueriesInQuantifieds() raises (SQLException); 765 766 /** Are correlated subqueries supported? 767 @returns 768 <TRUE/> if so 769 @throws SQLException 770 if a database access error occurs. 771 */ 772 boolean supportsCorrelatedSubqueries() raises (SQLException); 773 774 /** Is SQL UNION supported? 775 @returns 776 <TRUE/> if so 777 @throws SQLException 778 if a database access error occurs. 779 */ 780 boolean supportsUnion() raises (SQLException); 781 782 /** Is SQL UNION ALL supported? 783 @returns 784 <TRUE/> if so 785 @throws SQLException 786 if a database access error occurs. 787 */ 788 boolean supportsUnionAll() raises (SQLException); 789 790 /** Can cursors remain open across commits? 791 @returns 792 <TRUE/> if so 793 @throws SQLException 794 if a database access error occurs. 795 */ 796 boolean supportsOpenCursorsAcrossCommit() raises (SQLException); 797 798 /** Can cursors remain open across rollbacks? 799 @returns 800 <TRUE/> if so 801 @throws SQLException 802 if a database access error occurs. 803 */ 804 boolean supportsOpenCursorsAcrossRollback() raises (SQLException); 805 806 /** Can statements remain open across commits? 807 @returns 808 <TRUE/> if so 809 @throws SQLException 810 if a database access error occurs. 811 */ 812 boolean supportsOpenStatementsAcrossCommit() raises (SQLException); 813 814 /** Can statements remain open across rollbacks? 815 @returns 816 <TRUE/> if so 817 @throws SQLException 818 if a database access error occurs. 819 */ 820 boolean supportsOpenStatementsAcrossRollback() 821 raises (SQLException); 822 823 /** return the maximal number of hex characters in an inline binary literal 824 @returns 825 <TRUE/> if so 826 @throws SQLException 827 if a database access error occurs. 828 */ 829 long getMaxBinaryLiteralLength() raises (SQLException); 830 831 /** return the max length for a character literal 832 @returns 833 <TRUE/> if so 834 @throws SQLException 835 if a database access error occurs. 836 */ 837 long getMaxCharLiteralLength() raises (SQLException); 838 839 /** return the limit on column name length 840 @returns 841 <TRUE/> if so 842 @throws SQLException 843 if a database access error occurs. 844 */ 845 long getMaxColumnNameLength() raises (SQLException); 846 847 /** return the maximum number of columns in a "GROUP BY" clause 848 @returns 849 <TRUE/> if so 850 @throws SQLException 851 if a database access error occurs. 852 */ 853 long getMaxColumnsInGroupBy() raises (SQLException); 854 855 /** return the maximum number of columns allowed in an index 856 @returns 857 <TRUE/> if so 858 @throws SQLException 859 if a database access error occurs. 860 */ 861 long getMaxColumnsInIndex() raises (SQLException); 862 863 /** return the maximum number of columns in an "ORDER BY" clause 864 @returns 865 <TRUE/> if so 866 @throws SQLException 867 if a database access error occurs. 868 */ 869 long getMaxColumnsInOrderBy() raises (SQLException); 870 871 /** return the maximum number of columns in a "SELECT" list 872 @returns 873 <TRUE/> if so 874 @throws SQLException 875 if a database access error occurs. 876 */ 877 long getMaxColumnsInSelect() raises (SQLException); 878 879 /** return the maximum number of columns in a table 880 @returns 881 <TRUE/> if so 882 @throws SQLException 883 if a database access error occurs. 884 */ 885 long getMaxColumnsInTable() raises (SQLException); 886 887 /** return the number of active connections at a time to this database. 888 @returns 889 <TRUE/> if so 890 @throws SQLException 891 if a database access error occurs. 892 */ 893 long getMaxConnections() raises (SQLException); 894 895 /** return the maximum cursor name length 896 @returns 897 <TRUE/> if so 898 @throws SQLException 899 if a database access error occurs. 900 */ 901 long getMaxCursorNameLength() raises (SQLException); 902 903 /** return the maximum length of an index (in bytes) 904 @returns 905 <TRUE/> if so 906 @throws SQLException 907 if a database access error occurs. 908 */ 909 long getMaxIndexLength() raises (SQLException); 910 911 /** return the maximum length allowed for a schema name 912 @returns 913 <TRUE/> if so 914 @throws SQLException 915 if a database access error occurs. 916 */ 917 long getMaxSchemaNameLength() raises (SQLException); 918 919 /** return the maximum length of a procedure name 920 @returns 921 <TRUE/> if so 922 @throws SQLException 923 if a database access error occurs. 924 */ 925 long getMaxProcedureNameLength() raises (SQLException); 926 927 /** return the maximum length of a catalog name 928 @returns 929 <TRUE/> if so 930 @throws SQLException 931 if a database access error occurs. 932 */ 933 long getMaxCatalogNameLength() raises (SQLException); 934 935 /** return the maximum length of a single row. 936 @returns 937 <TRUE/> if so 938 @throws SQLException 939 if a database access error occurs. 940 */ 941 long getMaxRowSize() raises (SQLException); 942 943 /** Did getMaxRowSize() include LONGVARCHAR and LONGVARBINARY 944 blobs? 945 @returns 946 <TRUE/> if so 947 @throws SQLException 948 if a database access error occurs. 949 */ 950 boolean doesMaxRowSizeIncludeBlobs() raises (SQLException); 951 952 /** return the maximum length of a SQL statement 953 @returns 954 <TRUE/> if so 955 @throws SQLException 956 if a database access error occurs. 957 */ 958 long getMaxStatementLength() raises (SQLException); 959 960 /** return the maximal number of open active statements at one time to this database 961 @returns 962 <TRUE/> if so 963 @throws SQLException 964 if a database access error occurs. 965 */ 966 long getMaxStatements() raises (SQLException); 967 968 /** return the maximum length of a table name 969 @returns 970 <TRUE/> if so 971 @throws SQLException 972 if a database access error occurs. 973 */ 974 long getMaxTableNameLength() raises (SQLException); 975 976 /** return the maximum number of tables in a SELECT statement 977 @returns 978 <TRUE/> if so 979 @throws SQLException 980 if a database access error occurs. 981 */ 982 long getMaxTablesInSelect() raises (SQLException); 983 984 /** return the maximum length of a user name 985 @returns 986 <TRUE/> if so 987 @throws SQLException 988 if a database access error occurs. 989 */ 990 long getMaxUserNameLength() raises (SQLException); 991 992 /** return the database default transaction isolation level. 993 The values are defined in 994 <type scope="com::sun::star::sdbc">TransactionIsolation</type>. 995 @returns 996 <TRUE/> if so 997 @throws SQLException 998 if a database access error occurs. 999 @see com::sun::star::sdbc::XConnection 1000 */ 1001 long getDefaultTransactionIsolation() raises (SQLException); 1002 1003 /** support the Database transactions? 1004 If not, invoking the method 1005 <member scope="com::sun::star::sdbc">XConnection::commit()</member> 1006 is a noop and the 1007 isolation level is TransactionIsolation_NONE. 1008 @returns 1009 <TRUE/> if so 1010 @throws SQLException 1011 if a database access error occurs. 1012 */ 1013 boolean supportsTransactions() raises (SQLException); 1014 1015 /** Does this database support the given transaction isolation level? 1016 @returns 1017 <TRUE/> if so 1018 @throws SQLException 1019 if a database access error occurs. 1020 @see com::sun::star::sdbc::Connection 1021 */ 1022 boolean supportsTransactionIsolationLevel([in]long level) 1023 raises (SQLException); 1024 1025 /** support the Database both data definition and data manipulation statements 1026 within a transaction? 1027 @returns 1028 <TRUE/> if so 1029 @throws SQLException 1030 if a database access error occurs. 1031<!-- JRH: Unclear on the intent of these many support questions. 1032 If asking, it should state, "Does the Database support both ....? 1033 If declaring, it should state something like the following: 1034 1035 metadata: supportsDataDefinitionAndDataManipulationTransactions 1036 1037 "provides support for both data definition and data manipulation statements within a transaction." 1038 --> */ 1039 boolean supportsDataDefinitionAndDataManipulationTransactions() 1040 raises (SQLException); 1041 1042 /** are only data manipulation statements within a transaction 1043 supported? 1044 @returns 1045 <TRUE/> if so 1046 @throws SQLException 1047 if a database access error occurs. 1048 */ 1049 boolean supportsDataManipulationTransactionsOnly() 1050 raises (SQLException); 1051 1052 /** does a data definition statement within a transaction force the 1053 transaction to commit? 1054 @returns 1055 <TRUE/> if so 1056 @throws SQLException 1057 if a database access error occurs. 1058 */ 1059 boolean dataDefinitionCausesTransactionCommit() 1060 raises (SQLException); 1061 1062 /** is a data definition statement within a transaction ignored? 1063 @returns 1064 <TRUE/> if so 1065 @throws SQLException 1066 if a database access error occurs. 1067 */ 1068 boolean dataDefinitionIgnoredInTransactions() 1069 raises (SQLException); 1070 1071 /** Gets a description of the stored procedures available in a 1072 catalog. 1073 1074 1075 <p> 1076 Only procedure descriptions matching the schema and 1077 procedure name criteria are returned. They are ordered by 1078 PROCEDURE_SCHEM, and PROCEDURE_NAME. 1079 </p> 1080 <p> 1081 Each procedure description has the following columns: 1082 </p> 1083 <ol> 1084 <li> 1085 <b>PROCEDURE_CAT</b> string => procedure catalog (may be <NULL/>) 1086 </li> 1087 <li> 1088 <b>PROCEDURE_SCHEM</b> string => procedure schema (may be <NULL/>) 1089 </li> 1090 <li> 1091 <b>PROCEDURE_NAME</b> string => procedure name 1092 </li> 1093 <li> reserved for future use 1094 </li> 1095 <li> reserved for future use 1096 </li> 1097 <li> reserved for future use 1098 </li> 1099 <li> 1100 <b>REMARKS</b> string => explanatory comment on the procedure 1101 </li> 1102 <li> 1103 <b>PROCEDURE_TYPE</b> short => kind of procedure: 1104 <ul> 1105 <li> UNKNOWN - May return a result 1106 </li> 1107 <li> NO - Does not return a result 1108 </li> 1109 <li> RETURN - Returns a result 1110 </li> 1111 </ul> 1112 </li> 1113 </ol> 1114 @param catalog 1115 a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria 1116 @param schemaPattern 1117 a schema name pattern; "" retrieves those without a schema 1118 @param procedureNamePattern 1119 a procedure name pattern 1120 @returns 1121 each row is a procedure description 1122 @throws SQLException 1123 if a database access error occurs. 1124 */ 1125 XResultSet getProcedures([in]any catalog, [in]string schemaPattern, 1126 [in]string procedureNamePattern) raises (SQLException); 1127 1128 /** gets a description of a catalog's stored procedure parameters 1129 and result columns. 1130 1131 1132 <p> 1133 Only descriptions matching the schema, procedure and 1134 parameter name criteria are returned. They are ordered by 1135 PROCEDURE_SCHEM and PROCEDURE_NAME. Within this, the return value, 1136 if any, is first. Next are the parameter descriptions in call 1137 order. The column descriptions follow in column number order. 1138 </p> 1139 <p>Each row in the XResultSet is a parameter description or 1140 column description with the following fields: 1141 </p> 1142 <ol> 1143 <li> 1144 <b>PROCEDURE_CAT</b> string => procedure catalog (may be <NULL/>) 1145 </li> 1146 <li> 1147 <b>PROCEDURE_SCHEM</b> string => procedure schema (may be <NULL/>) 1148 </li> 1149 <li> 1150 <b>PROCEDURE_NAME</b> string => procedure name 1151 </li> 1152 <li> 1153 <b>COLUMN_NAME</b> string => column/parameter name 1154 </li> 1155 <li> 1156 <b>COLUMN_TYPE</b> Short => kind of column/parameter: 1157 <ul> 1158 <li> UNKNOWN - nobody knows 1159 </li> 1160 <li> IN - IN parameter 1161 </li> 1162 <li> INOUT - INOUT parameter 1163 </li> 1164 <li> OUT - OUT parameter 1165 </li> 1166 <li> RETURN - procedure return value 1167 </li> 1168 <li> RESULT - result column in XResultSet 1169 </li> 1170 </ul> 1171 </li> 1172 <li> 1173 <b>DATA_TYPE</b> short => SQL type from java.sql.Types 1174 </li> 1175 <li> 1176 <b>TYPE_NAME</b> string => SQL type name, for a UDT type the 1177 type name is fully qualified 1178 </li> 1179 <li> 1180 <b>PRECISION</b> long => precision 1181 </li> 1182 <li> 1183 <b>LENGTH</b> long => length in bytes of data 1184 </li> 1185 <li> 1186 <b>SCALE</b> short => scale 1187 </li> 1188 <li> 1189 <b>RADIX</b> short => radix 1190 </li> 1191 <li> 1192 <b>NULLABLE</b> short => can it contain NULL? 1193 <ul> 1194 <li> NO_NULLS - does not allow NULL values 1195 </li> 1196 <li> NULLABLE - allows NULL values 1197 </li> 1198 <li> NULLABLE_UNKNOWN - nullability unknown 1199 </li> 1200 </ul> 1201 </li> 1202 <li> 1203 <b>REMARKS</b> string => comment describing parameter/column 1204 </li> 1205 </ol> 1206 <p> 1207 <b>Note:</b> Some databases may not return the column 1208 descriptions for a procedure. Additional columns beyond 1209 REMARKS can be defined by the database. 1210 </p> 1211 @param catalog 1212 a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria 1213 @param schemaPattern 1214 a schema name pattern; "" retrieves those without a schema 1215 @param procedureNamePattern 1216 a procedure name pattern 1217 @param columnNamePattern 1218 a column name pattern 1219 @returns 1220 each row describes a stored procedure parameter or column 1221 @throws SQLException 1222 if a database access error occurs. 1223 */ 1224 XResultSet getProcedureColumns([in]any catalog, [in]string schemaPattern, 1225 [in]string procedureNamePattern, 1226 [in]string columnNamePattern) 1227 raises (SQLException); 1228 1229 /** gets a description of tables available in a catalog. 1230 1231 1232 <p>Only table descriptions matching the catalog, schema, table 1233 name, and type criteria are returned. They are ordered by 1234 TABLE_TYPE, TABLE_SCHEM, and TABLE_NAME. 1235 </p> 1236 <p>Each table description has the following columns: 1237 </p> 1238 <ol> 1239 <li> 1240 <b>TABLE_CAT</b> string => table catalog (may be <NULL/>) 1241 </li> 1242 <li> 1243 <b>TABLE_SCHEM</b> string => table schema (may be <NULL/>) 1244 </li> 1245 <li> 1246 <b>TABLE_NAME</b> string => table name 1247 </li> 1248 <li> 1249 <b>TABLE_TYPE</b> string => table type. Typical types are "TABLE", 1250 "VIEW", "SYSTEM TABLE", "GLOBAL TEMPORARY", 1251 "LOCAL TEMPORARY", "ALIAS", "SYNONYM". 1252 </li> 1253 <li> 1254 <b>REMARKS</b> string => explanatory comment on the table 1255 </li> 1256 </ol> 1257 <p> 1258 <b>Note:</b> Some databases may not return information for 1259 all tables. 1260 </p> 1261 @param catalog 1262 a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria 1263 @param schemaPattern 1264 a schema name pattern; "" retrieves those without a schema 1265 @param tableNamePattern 1266 a table name pattern 1267 @param types 1268 a list of table types to include 1269 @returns 1270 each row is a table description 1271 @throws SQLException 1272 if a database access error occurs. 1273 */ 1274 XResultSet getTables([in]any catalog, [in]string schemaPattern, 1275 [in]string tableNamePattern, [in]sequence<string> types) 1276 raises (SQLException); 1277 1278 /** Gets the schema names available in this database. The results 1279 are ordered by schema name. 1280 1281 1282 <p>The schema column is: 1283 </p> 1284 <ol> 1285 <li> 1286 <b>TABLE_SCHEM</b> string => schema name 1287 </li> 1288 </ol> 1289 @returns 1290 each row has a single String column that is a schema name 1291 @throws SQLException 1292 if a database access error occurs. 1293 */ 1294 XResultSet getSchemas() raises (SQLException); 1295 1296 /** gets the catalog names available in this database. The results 1297 are ordered by catalog name. 1298 1299 1300 <p>The catalog column is: 1301 </p> 1302 <ol> 1303 <li> 1304 <b>TABLE_CAT</b> string => catalog name 1305 </li> 1306 </ol> 1307 @returns 1308 each row has a single String column that is a catalog name 1309 @throws SQLException 1310 if a database access error occurs. 1311 */ 1312 XResultSet getCatalogs() raises (SQLException); 1313 1314 /** gets the table types available in this database. The results 1315 are ordered by table type. 1316 1317 1318 <p>The table type is: 1319 </p> 1320 <ol> 1321 <li> 1322 <b>TABLE_TYPE</b> string => table type. Typical types are "TABLE", 1323 "VIEW", "SYSTEM TABLE", "GLOBAL TEMPORARY", 1324 "LOCAL TEMPORARY", "ALIAS", "SYNONYM". 1325 </li> 1326 </ol> 1327 @returns 1328 each row has a single String column that is a table type 1329 @throws SQLException 1330 if a database access error occurs. 1331 */ 1332 XResultSet getTableTypes() raises (SQLException); 1333 1334 /** gets a description of table columns available in 1335 the specified catalog. 1336 1337 1338 <p>Only column descriptions matching the catalog, schema, table 1339 and column name criteria are returned. They are ordered by 1340 TABLE_SCHEM, TABLE_NAME, and ORDINAL_POSITION. 1341 </p> 1342 <p>Each column description has the following columns: 1343 </p> 1344 <ol> 1345 <li> 1346 <b>TABLE_CAT</b> string => table catalog (may be <NULL/>) 1347 </li> 1348 <li> 1349 <b>TABLE_SCHEM</b> string => table schema (may be <NULL/>) 1350 </li> 1351 <li> 1352 <b>TABLE_NAME</b> string => table name 1353 </li> 1354 <li> 1355 <b>COLUMN_NAME</b> string => column name 1356 </li> 1357 <li> 1358 <b>DATA_TYPE</b> short => SQL type from java.sql.Types 1359 </li> 1360 <li> 1361 <b>TYPE_NAME</b> string => Data source dependent type name, 1362 for a UDT the type name is fully qualified 1363 </li> 1364 <li> 1365 <b>COLUMN_SIZE</b> long => column size. For char or date 1366 types this is the maximum number of characters, for numeric or 1367 decimal types this is precision. 1368 </li> 1369 <li> 1370 <b>BUFFER_LENGTH</b> is not used. 1371 </li> 1372 <li> 1373 <b>DECIMAL_DIGITS</b> long => the number of fractional digits 1374 </li> 1375 <li> 1376 <b>NUM_PREC_RADIX</b> long => Radix (typically either 10 or 2) 1377 </li> 1378 <li> 1379 <b>NULLABLE</b> long => is NULL allowed? 1380 <ul> 1381 <li> NO_NULLS - might not allow NULL values 1382 </li> 1383 <li> NULLABLE - definitely allows NULL values 1384 </li> 1385 <li> NULLABLE_UNKNOWN - nullability unknown 1386 </li> 1387 </ul> 1388 </li> 1389 <li> 1390 <b>REMARKS</b> string => comment describing column (may be <NULL/>) 1391 </li> 1392 <li> 1393 <b>COLUMN_DEF</b> string => default value (may be <NULL/>) 1394 </li> 1395 <li> 1396 <b>SQL_DATA_TYPE</b> long => unused 1397 </li> 1398 <li> 1399 <b>SQL_DATETIME_SUB</b> long => unused 1400 </li> 1401 <li> 1402 <b>CHAR_OCTET_LENGTH</b> long => for char types the 1403 maximum number of bytes in the column 1404 </li> 1405 <li> 1406 <b>ORDINAL_POSITION</b> int => index of column in table 1407 (starting at 1) 1408 </li> 1409 <li> 1410 <b>IS_NULLABLE</b> string => "NO" means column definitely 1411 does not allow NULL values; "YES" means the column might 1412 allow NULL values. An empty string means nobody knows. 1413 </li> 1414 </ol> 1415 @param catalog 1416 a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria 1417 @param schemaPattern 1418 a schema name pattern; "" retrieves those without a schema 1419 @param tableNamePattern 1420 a table name pattern 1421 @param columnNamePattern 1422 a column name pattern 1423 @returns 1424 each row is a column description 1425 @throws SQLException 1426 if a database access error occurs. 1427 */ 1428 XResultSet getColumns([in]any catalog, [in]string schemaPattern, 1429 [in]string tableNamePattern, [in]string columnNamePattern) 1430 raises (SQLException); 1431 1432 /** gets a description of the access rights for a table's columns. 1433 1434 1435 <p> 1436 Only privileges matching the column name criteria are 1437 returned. They are ordered by COLUMN_NAME and PRIVILEGE. 1438 </p> 1439 <p>Each privilege description has the following columns: 1440 </p> 1441 <ol> 1442 <li> 1443 <b>TABLE_CAT</b> string => table catalog (may be <NULL/>) 1444 </li> 1445 <li> 1446 <b>TABLE_SCHEM</b> string => table schema (may be <NULL/>) 1447 </li> 1448 <li> 1449 <b>TABLE_NAME</b> string => table name 1450 </li> 1451 <li> 1452 <b>COLUMN_NAME</b> string => column name 1453 </li> 1454 <li> 1455 <b>GRANTOR</b> => granter of access (may be <NULL/>) 1456 </li> 1457 <li> 1458 <b>GRANTEE</b> string => grantee of access 1459 </li> 1460 <li> 1461 <b>PRIVILEGE</b> string => name of access (SELECT, 1462 INSERT, UPDATE, REFERENCES, ...) 1463 </li> 1464 <li> 1465 <b>IS_GRANTABLE</b> string => "YES" if grantee is permitted 1466 to grant to others; "NO" if not; <NULL/> if unknown 1467 </li> 1468 </ol> 1469 @param catalog 1470 a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria 1471 @param schema 1472 a schema name ; "" retrieves those without a schema 1473 @param table 1474 a table name 1475 @param columnNamePattern 1476 a column name pattern 1477 @returns 1478 each row is a column privilege description 1479 @throws SQLException 1480 if a database access error occurs. 1481 */ 1482 XResultSet getColumnPrivileges([in]any catalog, [in]string schema, 1483 [in]string table, [in]string columnNamePattern) raises (SQLException); 1484 1485 /** gets a description of the access rights for each table available 1486 in a catalog. Note that a table privilege applies to one or 1487 more columns in the table. It would be wrong to assume that 1488 this privilege applies to all columns (this may be <TRUE/> for 1489 some systems but is not <TRUE/> for all.) 1490 1491 1492 <p>Only privileges matching the schema and table name 1493 criteria are returned. They are ordered by TABLE_SCHEM, 1494 TABLE_NAME, and PRIVILEGE. 1495 </p> 1496 <p>Each privilege description has the following columns: 1497 </p> 1498 <ol> 1499 <li> 1500 <b>TABLE_CAT</b> string => table catalog (may be <NULL/>) 1501 </li> 1502 <li> 1503 <b>TABLE_SCHEM</b> string => table schema (may be <NULL/>) 1504 </li> 1505 <li> 1506 <b>TABLE_NAME</b> string => table name 1507 </li> 1508 <li> 1509 <b>GRANTOR</b> => granter of access (may be <NULL/>) 1510 </li> 1511 <li> 1512 <b>GRANTEE</b> string => grantee of access 1513 </li> 1514 <li> 1515 <b>PRIVILEGE</b> string => name of access (SELECT, 1516 INSERT, UPDATE, REFERENCES, ...) 1517 </li> 1518 <li> 1519 <b>IS_GRANTABLE</b> string => "YES" if grantee is permitted 1520 to grant to others; "NO" if not; <NULL/> if unknown 1521 </li> 1522 </ol> 1523 @param catalog 1524 a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria 1525 @param schemaPattern 1526 a schema name pattern; "" retrieves those without a schema 1527 @param tableNamePattern 1528 a table name pattern 1529 @returns 1530 each row is a table privilege description 1531 @throws SQLException 1532 if a database access error occurs. 1533 */ 1534 XResultSet getTablePrivileges([in]any catalog, [in]string schemaPattern, 1535 [in]string tableNamePattern) raises (SQLException); 1536 1537 /** gets a description of a table's optimal set of columns that 1538 uniquely identifies a row. They are ordered by SCOPE. 1539 1540 1541 <p>Each column description has the following columns: 1542 </p> 1543 <ol> 1544 <li> 1545 <b>SCOPE</b> short => actual scope of result 1546 <ul> 1547 <li> TEMPORARY - very temporary, while using row 1548 </li> 1549 <li> TRANSACTION - valid for remainder of current transaction 1550 </li> 1551 <li> SESSION - valid for remainder of current session 1552 </li> 1553 </ul> 1554 </li> 1555 <li> 1556 <b>COLUMN_NAME</b> string => column name 1557 </li> 1558 <li> 1559 <b>DATA_TYPE</b> short => SQL data type from java.sql.Types 1560 </li> 1561 <li> 1562 <b>TYPE_NAME</b> string => Data source dependent type name, 1563 for a UDT the type name is fully qualified 1564 </li> 1565 <li> 1566 <b>COLUMN_SIZE</b> long => precision 1567 </li> 1568 <li> 1569 <b>BUFFER_LENGTH</b> long => not used 1570 </li> 1571 <li> 1572 <b>DECIMAL_DIGITS</b> short => scale 1573 </li> 1574 <li> 1575 <b>PSEUDO_COLUMN</b> short => is this a pseudo column 1576 like an Oracle ROWID 1577 <ul> 1578 <li> UNKNOWN - may or may not be pseudo column 1579 </li> 1580 <li> NOT_PSEUDO - is NOT a pseudo column 1581 </li> 1582 <li> PSEUDO - is a pseudo column 1583 </li> 1584 </ul> 1585 </li> 1586 </ol> 1587 @param catalog 1588 a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria 1589 @param schema 1590 a schema name; "" retrieves those without a schema 1591 @param table 1592 a table name 1593 @param scope 1594 the scope of interest; use same values as SCOPE 1595 @param nullable 1596 include columns that are nullable? 1597 @returns 1598 each row is a column description 1599 @throws SQLException 1600 if a database access error occurs. 1601 */ 1602 XResultSet getBestRowIdentifier([in]any catalog, [in]string schema, 1603 [in]string table, [in]long scope, [in] boolean nullable) 1604 raises (SQLException); 1605 1606 /** gets a description of a table's columns that are automatically 1607 updated when any value in a row is updated. They are 1608 unordered. 1609 1610 1611 <p>Each column description has the following columns: 1612 </p> 1613 <ol> 1614 <li> 1615 <b>SCOPE</b> short => is not used 1616 </li> 1617 <li> 1618 <b>COLUMN_NAME</b> string => column name 1619 </li> 1620 <li> 1621 <b>DATA_TYPE</b> short => SQL data type from java.sql.Types 1622 </li> 1623 <li> 1624 <b>TYPE_NAME</b> string => Data source dependent type name 1625 </li> 1626 <li> 1627 <b>COLUMN_SIZE</b> long => precision 1628 </li> 1629 <li> 1630 <b>BUFFER_LENGTH</b> long => length of column value in bytes 1631 </li> 1632 <li> 1633 <b>DECIMAL_DIGITS</b> short => scale 1634 </li> 1635 <li> 1636 <b>PSEUDO_COLUMN</b> short => is this a pseudo column 1637 like an Oracle ROWID 1638 <ul> 1639 <li> UNKNOWN - may or may not be pseudo column 1640 </li> 1641 <li> NOT_PSEUDO - is NOT a pseudo column 1642 </li> 1643 <li> PSEUDO - is a pseudo column 1644 </li> 1645 </ul> 1646 </li> 1647 </ol> 1648 @param catalog 1649 a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria 1650 @param schema 1651 a schema name; "" retrieves those without a schema 1652 @param table 1653 a table name 1654 @returns 1655 each row is a column description 1656 @throws SQLException 1657 if a database access error occurs. 1658 */ 1659 XResultSet getVersionColumns([in]any catalog, [in]string schema, 1660 [in]string table) raises (SQLException); 1661 1662 /** gets a description of a table's primary key columns. They 1663 are ordered by COLUMN_NAME. 1664 1665 1666 <p>Each primary key column description has the following columns: 1667 </p> 1668 <ol> 1669 <li> 1670 <b>TABLE_CAT</b> string => table catalog (may be <NULL/>) 1671 </li> 1672 <li> 1673 <b>TABLE_SCHEM</b> string => table schema (may be <NULL/>) 1674 </li> 1675 <li> 1676 <b>TABLE_NAME</b> string => table name 1677 </li> 1678 <li> 1679 <b>COLUMN_NAME</b> string => column name 1680 </li> 1681 <li> 1682 <b>KEY_SEQ</b> short => sequence number within primary key 1683 </li> 1684 <li> 1685 <b>PK_NAME</b> string => primary key name (may be <NULL/>) 1686 </li> 1687 </ol> 1688 @param catalog 1689 a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria 1690 @param schema 1691 a schema name; "" retrieves those without a schema 1692 @param table 1693 a table name 1694 @returns 1695 each row is a primary key column description 1696 @throws SQLException 1697 if a database access error occurs. 1698 */ 1699 XResultSet getPrimaryKeys([in]any catalog, [in]string schema, 1700 [in]string table) raises (SQLException); 1701 1702 /** gets a description of the primary key columns that are 1703 referenced by a table's foreign key columns (the primary keys 1704 imported by a table). They are ordered by PKTABLE_CAT, 1705 PKTABLE_SCHEM, PKTABLE_NAME, and KEY_SEQ. 1706 1707 1708 <p>Each primary key column description has the following columns: 1709 </p> 1710 <ol> 1711 <li> 1712 <b>PKTABLE_CAT</b> string => primary key table catalog 1713 being imported (may be <NULL/>) 1714 </li> 1715 <li> 1716 <b>PKTABLE_SCHEM</b> string => primary key table schema 1717 being imported (may be <NULL/>) 1718 </li> 1719 <li> 1720 <b>PKTABLE_NAME</b> string => primary key table name 1721 being imported 1722 </li> 1723 <li> 1724 <b>PKCOLUMN_NAME</b> string => primary key column name 1725 being imported 1726 </li> 1727 <li> 1728 <b>FKTABLE_CAT</b> string => foreign key table catalog (may be <NULL/>) 1729 </li> 1730 <li> 1731 <b>FKTABLE_SCHEM</b> string => foreign key table schema (may be <NULL/>) 1732 </li> 1733 <li> 1734 <b>FKTABLE_NAME</b> string => foreign key table name 1735 </li> 1736 <li> 1737 <b>FKCOLUMN_NAME</b> string => foreign key column name 1738 </li> 1739 <li> 1740 <b>KEY_SEQ</b> short => sequence number within foreign key 1741 </li> 1742 <li> 1743 <b>UPDATE_RULE</b> short => What happens to 1744 foreign key when primary is updated: 1745 <ul> 1746 <li> importedNoAction - do not allow update of primary 1747 key if it has been imported 1748 </li> 1749 <li> importedKeyCascade - change imported key to agree 1750 with primary key update 1751 </li> 1752 <li> importedKeySetNull - change imported key to NULL if 1753 its primary key has been updated 1754 </li> 1755 <li> importedKeySetDefault - change imported key to default values 1756 if its primary key has been updated 1757 </li> 1758 <li> importedKeyRestrict - same as importedKeyNoAction 1759 (for ODBC 2.x compatibility) 1760 </li> 1761 </ul> 1762 </li> 1763 <li> 1764 <b>DELETE_RULE</b> short => What happens to 1765 the foreign key when primary is deleted. 1766 <ul> 1767 <li> importedKeyNoAction - do not allow delete of primary 1768 key if it has been imported 1769 </li> 1770 <li> importedKeyCascade - delete rows that import a deleted key 1771 </li> 1772 <li> importedKeySetNull - change imported key to NULL if 1773 its primary key has been deleted 1774 </li> 1775 <li> importedKeyRestrict - same as importedKeyNoAction 1776 (for ODBC 2.x compatibility) 1777 </li> 1778 <li> importedKeySetDefault - change imported key to default if 1779 its primary key has been deleted 1780 </li> 1781 </ul> 1782 </li> 1783 <li> 1784 <b>FK_NAME</b> string => foreign key name (may be <NULL/>) 1785 </li> 1786 <li> 1787 <b>PK_NAME</b> string => primary key name (may be <NULL/>) 1788 </li> 1789 <li> 1790 <b>DEFERRABILITY</b> short => can the evaluation of foreign key 1791 constraints be deferred until commit 1792 <ul> 1793 <li> importedKeyInitiallyDeferred - see SQL92 for definition 1794 </li> 1795 <li> importedKeyInitiallyImmediate - see SQL92 for definition 1796 </li> 1797 <li> importedKeyNotDeferrable - see SQL92 for definition 1798 </li> 1799 </ul> 1800 </li> 1801 </ol> 1802 @param catalog 1803 a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria 1804 @param schema 1805 a schema name; "" retrieves those without a schema 1806 @param table 1807 a table name 1808 @returns 1809 each row is a primary key column description 1810 @throws SQLException 1811 if a database access error occurs. 1812 */ 1813 XResultSet getImportedKeys([in]any catalog, [in]string schema, 1814 [in]string table) raises (SQLException); 1815 1816 /** gets a description of the foreign key columns that reference a 1817 table's primary key columns (the foreign keys exported by a 1818 table). They are ordered by FKTABLE_CAT, FKTABLE_SCHEM, 1819 FKTABLE_NAME, and KEY_SEQ. 1820 1821 1822 <p>Each foreign key column description has the following columns: 1823 </p> 1824 <ol> 1825 <li> 1826 <b>PKTABLE_CAT</b> string => primary key table catalog (may be <NULL/>) 1827 </li> 1828 <li> 1829 <b>PKTABLE_SCHEM</b> string => primary key table schema (may be <NULL/>) 1830 </li> 1831 <li> 1832 <b>PKTABLE_NAME</b> string => primary key table name 1833 </li> 1834 <li> 1835 <b>PKCOLUMN_NAME</b> string => primary key column name 1836 </li> 1837 <li> 1838 <b>FKTABLE_CAT</b> string => foreign key table catalog (may be <NULL/>) 1839 being exported (may be <NULL/>) 1840 </li> 1841 <li> 1842 <b>FKTABLE_SCHEM</b> string => foreign key table schema (may be <NULL/>) 1843 being exported (may be <NULL/>) 1844 </li> 1845 <li> 1846 <b>FKTABLE_NAME</b> string => foreign key table name 1847 being exported 1848 </li> 1849 <li> 1850 <b>FKCOLUMN_NAME</b> string => foreign key column name 1851 being exported 1852 </li> 1853 <li> 1854 <b>KEY_SEQ</b> short => sequence number within foreign key 1855 </li> 1856 <li> 1857 <b>UPDATE_RULE</b> short => What happens to 1858 foreign key when primary is updated: 1859 <ul> 1860 <li> NO_ACTION - do not allow update of primary 1861 key if it has been imported 1862 </li> 1863 <li> CASCADE - change imported key to agree 1864 with primary key update 1865 </li> 1866 <li> SET_NULL - change imported key to NULL if 1867 its primary key has been updated 1868 </li> 1869 <li> SET_DEFAULT - change imported key to default values 1870 if its primary key has been updated 1871 </li> 1872 <li> RESTRICT - same as importedKeyNoAction 1873 (for ODBC 2.x compatibility) 1874 </li> 1875 </ul> 1876 </li> 1877 <li> 1878 <b>DELETE_RULE</b> short => What happens to 1879 the foreign key when primary is deleted. 1880 <ul> 1881 <li> NO_ACTION - do not allow delete of primary 1882 key if it has been imported 1883 </li> 1884 <li> CASCADE - delete rows that import a deleted key 1885 </li> 1886 <li> SET_NULL - change imported key to NULL if 1887 its primary key has been deleted 1888 </li> 1889 <li> RESTRICT - same as importedKeyNoAction 1890 (for ODBC 2.x compatibility) 1891 </li> 1892 <li> SET_DEFAULT - change imported key to default if 1893 its primary key has been deleted 1894 </li> 1895 </ul> 1896 </li> 1897 <li> 1898 <b>FK_NAME</b> string => foreign key name (may be <NULL/>) 1899 </li> 1900 <li> 1901 <b>PK_NAME</b> string => primary key name (may be <NULL/>) 1902 </li> 1903 <li> 1904 <b>DEFERRABILITY</b> short => can the evaluation of foreign key 1905 constraints be deferred until commit 1906 <ul> 1907 <li> INITIALLY_DEFERRED - see SQL92 for definition 1908 </li> 1909 <li> INITIALLY_IMMEDIATE - see SQL92 for definition 1910 </li> 1911 <li> NONE - see SQL92 for definition 1912 </li> 1913 </ul> 1914 </li> 1915 </ol> 1916 @param catalog 1917 a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria 1918 @param schema 1919 a schema name; "" retrieves those without a schema 1920 @param table 1921 a table name 1922 @returns 1923 each row is a foreign key column description 1924 @throws SQLException 1925 if a database access error occurs. 1926 */ 1927 XResultSet getExportedKeys([in]any catalog, [in]string schema, 1928 [in]string table) raises (SQLException); 1929 1930 /** gets a description of the foreign key columns in the foreign key 1931 table that reference the primary key columns of the primary key 1932 table (describe how one table imports another's key.) This 1933 should normally return a single foreign key/primary key pair 1934 (most tables only import a foreign key from a table once.). They 1935 are ordered by FKTABLE_CAT, FKTABLE_SCHEM, FKTABLE_NAME, and 1936 KEY_SEQ. 1937 1938 1939 <p>Each foreign key column description has the following columns: 1940 </p> 1941 <ol> 1942 <li> 1943 <b>PKTABLE_CAT</b> string => primary key table catalog (may be <NULL/>) 1944 </li> 1945 <li> 1946 <b>PKTABLE_SCHEM</b> string => primary key table schema (may be <NULL/>) 1947 </li> 1948 <li> 1949 <b>PKTABLE_NAME</b> string => primary key table name 1950 </li> 1951 <li> 1952 <b>PKCOLUMN_NAME</b> string => primary key column name 1953 </li> 1954 <li> 1955 <b>FKTABLE_CAT</b> string => foreign key table catalog (may be <NULL/>) 1956 being exported (may be <NULL/>) 1957 </li> 1958 <li> 1959 <b>FKTABLE_SCHEM</b> string => foreign key table schema (may be <NULL/>) 1960 being exported (may be <NULL/>) 1961 </li> 1962 <li> 1963 <b>FKTABLE_NAME</b> string => foreign key table name 1964 being exported 1965 </li> 1966 <li> 1967 <b>FKCOLUMN_NAME</b> string => foreign key column name 1968 being exported 1969 </li> 1970 <li> 1971 <b>KEY_SEQ</b> short => sequence number within foreign key 1972 </li> 1973 <li> 1974 <b>UPDATE_RULE</b> short => What happens to 1975 foreign key when primary is updated: 1976 <ul> 1977 <li> NO_ACTION - do not allow update of primary 1978 key if it has been imported 1979 </li> 1980 <li> CASCADE - change imported key to agree 1981 with primary key update 1982 </li> 1983 <li> SET_NULL - change imported key to NULL if 1984 its primary key has been updated 1985 </li> 1986 <li> SET_DEFAULT - change imported key to default values 1987 if its primary key has been updated 1988 </li> 1989 <li> RESTRICT - same as importedKeyNoAction 1990 (for ODBC 2.x compatibility) 1991 </li> 1992 </ul> 1993 </li> 1994 <li> 1995 <b>DELETE_RULE</b> short => What happens to 1996 the foreign key when primary is deleted. 1997 <ul> 1998 <li> NO_ACTION - do not allow delete of primary 1999 key if it has been imported 2000 </li> 2001 <li> CASCADE - delete rows that import a deleted key 2002 </li> 2003 <li> SET_NULL - change imported key to NULL if 2004 its primary key has been deleted 2005 </li> 2006 <li> RESTRICT - same as importedKeyNoAction 2007 (for ODBC 2.x compatibility) 2008 </li> 2009 <li> SET_DEFAULT - change imported key to default if 2010 its primary key has been deleted 2011 </li> 2012 </ul> 2013 </li> 2014 <li> 2015 <b>FK_NAME</b> string => foreign key name (may be <NULL/>) 2016 </li> 2017 <li> 2018 <b>PK_NAME</b> string => primary key name (may be <NULL/>) 2019 </li> 2020 <li> 2021 <b>DEFERRABILITY</b> short => can the evaluation of foreign key 2022 constraints be deferred until commit 2023 <ul> 2024 <li> INITIALLY_DEFERRED - see SQL92 for definition 2025 </li> 2026 <li> INITIALLY_IMMEDIATE - see SQL92 for definition 2027 </li> 2028 <li> NONE - see SQL92 for definition 2029 </li> 2030 </ul> 2031 </li> 2032 </ol> 2033 @param primaryCatalog 2034 a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria 2035 @param primarySchema 2036 a schema name; "" retrieves those without a schema 2037 @param primaryTable 2038 the table name that exports the key 2039 @param foreignCatalog 2040 a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria 2041 @param foreignSchema 2042 a schema name; "" retrieves those without a schema 2043 @param foreignTable 2044 the table name that imports the key 2045 @returns 2046 each row is a foreign key column description 2047 @throws SQLException 2048 if a database access error occurs. 2049 */ 2050 XResultSet getCrossReference( 2051 [in]any primaryCatalog, [in]string primarySchema, 2052 [in]string primaryTable, 2053 [in]any foreignCatalog, [in]string foreignSchema, 2054 [in]string foreignTable) raises (SQLException); 2055 2056 /** gets a description of all the standard SQL types supported by 2057 this database. They are ordered by DATA_TYPE and then by how 2058 closely the data type maps to the corresponding SDBC SQL type. 2059 2060 2061 2062 <p>Each type description has the following columns: 2063 </p> 2064 <ol> 2065 <li> 2066 <b>TYPE_NAME</b> string => Type name 2067 </li> 2068 <li> 2069 <b>DATA_TYPE</b> short => SQL data type from java.sql.Types 2070 </li> 2071 <li> 2072 <b>PRECISION</b> long => maximum precision 2073 </li> 2074 <li> 2075 <b>LITERAL_PREFIX</b> string => prefix used to quote a literal 2076 (may be <NULL/>) 2077 </li> 2078 <li> 2079 <b>LITERAL_SUFFIX</b> string => suffix used to quote a literal 2080 (may be <NULL/>) 2081 </li> 2082 <li> 2083 <b>CREATE_PARAMS</b> string => parameters used in creating 2084 the type (may be <NULL/>) 2085 </li> 2086 <li> 2087 <b>NULLABLE</b> short => can you use NULL for this type? 2088 <ul> 2089 <li> NO_NULLS - does not allow NULL values 2090 </li> 2091 <li> NULLABLE - allows NULL values 2092 </li> 2093 <li> NULLABLE_UNKNOWN - nullability unknown 2094 </li> 2095 </ul> 2096 </li> 2097 <li> 2098 <b>CASE_SENSITIVE</b> boolean=> is it case sensitive? 2099 </li> 2100 <li> 2101 <b>SEARCHABLE</b> short => can you use "WHERE" based on this type: 2102 <ul> 2103 <li> NONE - No support 2104 </li> 2105 <li> CHAR - Only supported with WHERE .. LIKE 2106 </li> 2107 <li> BASIC - Supported except for WHERE .. LIKE 2108 </li> 2109 <li> FULL - Supported for all WHERE .. 2110 </li> 2111 </ul> 2112 </li> 2113 <li> 2114 <b>UNSIGNED_ATTRIBUTE</b> boolean => is it unsigned? 2115 </li> 2116 <li> 2117 <b>FIXED_PREC_SCALE</b> boolean => can it be a money value? 2118 </li> 2119 <li> 2120 <b>AUTO_INCREMENT</b> boolean => can it be used for an 2121 auto-increment value? 2122 </li> 2123 <li> 2124 <b>LOCAL_TYPE_NAME</b> string => localized version of type name 2125 (may be <NULL/>) 2126 </li> 2127 <li> 2128 <b>MINIMUM_SCALE</b> short => minimum scale supported 2129 </li> 2130 <li> 2131 <b>MAXIMUM_SCALE</b> short => maximum scale supported 2132 </li> 2133 <li> 2134 <b>SQL_DATA_TYPE</b> long => unused 2135 </li> 2136 <li> 2137 <b>SQL_DATETIME_SUB</b> long => unused 2138 </li> 2139 <li> 2140 <b>NUM_PREC_RADIX</b> long => usually 2 or 10 2141 </li> 2142 </ol> 2143 @returns 2144 each row is a SQL type description 2145 @throws SQLException 2146 if a database access error occurs. 2147 */ 2148 XResultSet getTypeInfo() raises (SQLException); 2149 2150 /** gets a description of a table's indices and statistics. They are 2151 ordered by NON_UNIQUE, TYPE, INDEX_NAME, and ORDINAL_POSITION. 2152 2153 2154 <p>Each index column description has the following columns: 2155 </p> 2156 <ol> 2157 <li> 2158 <b>TABLE_CAT</b> string => table catalog (may be <NULL/>) 2159 </li> 2160 <li> 2161 <b>TABLE_SCHEM</b> string => table schema (may be <NULL/>) 2162 </li> 2163 <li> 2164 <b>TABLE_NAME</b> string => table name 2165 </li> 2166 <li> 2167 <b>NON_UNIQUE</b> boolean => Can index values be non-unique? 2168 <FALSE/> when TYPE is tableIndexStatistic 2169 </li> 2170 <li> 2171 <b>INDEX_QUALIFIER</b> string => index catalog (may be <NULL/>); 2172 <NULL/> when TYPE is tableIndexStatistic 2173 </li> 2174 <li> 2175 <b>INDEX_NAME</b> string => index name; <NULL/> when TYPE is 2176 tableIndexStatistic 2177 </li> 2178 <li> 2179 <b>TYPE</b> short => index type: 2180 <ul> 2181 <li> 0 - this identifies table statistics that are 2182 returned in conjunction with a table's index descriptions 2183 </li> 2184 <li> CLUSTERED - this is a clustered index 2185 </li> 2186 <li> HASHED - this is a hashed index 2187 </li> 2188 <li> OTHER - this is some other style of index 2189 </li> 2190 </ul> 2191 </li> 2192 <li> 2193 <b>ORDINAL_POSITION</b> short => column sequence number 2194 within index; zero when TYPE is tableIndexStatistic 2195 </li> 2196 <li> 2197 <b>COLUMN_NAME</b> string => column name; <NULL/> when TYPE is 2198 tableIndexStatistic 2199 </li> 2200 <li> 2201 <b>ASC_OR_DESC</b> string => column sort sequence, "A" => ascending, 2202 "D" => descending, may be <NULL/> if sort sequence is not supported; 2203 <NULL/> when TYPE is tableIndexStatistic 2204 </li> 2205 <li> 2206 <b>CARDINALITY</b> long => When TYPE is tableIndexStatistic, then 2207 this is the number of rows in the table; otherwise, it is the 2208 number of unique values in the index. 2209 </li> 2210 <li> 2211 <b>PAGES</b> long => When TYPE is tableIndexStatisic then 2212 this is the number of pages used for the table, otherwise it 2213 is the number of pages used for the current index. 2214 </li> 2215 <li> 2216 <b>FILTER_CONDITION</b> string => Filter condition, if any. 2217 (may be <NULL/>) 2218 </li> 2219 </ol> 2220 @param catalog 2221 a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria 2222 @param schema 2223 a schema name; "" retrieves those without a schema 2224 @param table 2225 the table name that exports the key 2226 @param unique 2227 when <TRUE/>, return only indices for unique values; when <FALSE/>, return indices regardless of whether unique or not 2228 @param approximate 2229 when <TRUE/>, result is allowed to reflect approximate or out of data values; when <FALSE/>, results are requested to be accurate 2230 @returns 2231 each row is an index column description 2232 @throws SQLException 2233 if a database access error occurs. 2234 */ 2235 XResultSet getIndexInfo([in]any catalog, [in]string schema, [in]string table, 2236 [in]boolean unique, [in]boolean approximate) 2237 raises (SQLException); 2238 2239 /** Does the database support the given result set type? 2240 @param setType 2241 defined in 2242 <type scope="com::sun::star::sdbc">ResultSetType</type> 2243 @returns 2244 <TRUE/> if so 2245 @throws SQLException 2246 if a database access error occurs. 2247 */ 2248 boolean supportsResultSetType([in]long setType) raises (SQLException); 2249 2250 /** Does the database support the concurrency type in combination 2251 with the given result set type? 2252 @param setType 2253 defined in 2254 <type scope="com::sun::star::sdbc">ResultSetType</type> 2255 @param concurrency 2256 defined in 2257 <type scope="com::sun::star::sdbc">ResultSetConcurrency</type> 2258 @returns 2259 <TRUE/> if so 2260 @throws SQLException 2261 if a database access error occurs. 2262 */ 2263 boolean supportsResultSetConcurrency([in]long setType, 2264 [in]long concurrency) 2265 raises (SQLException); 2266 2267 /** indicates whether a result set's own updates are visible. 2268 @param setType 2269 defined in 2270 <type scope="com::sun::star::sdbc">ResultSetType</type> 2271 @returns 2272 <TRUE/> if so 2273 @throws SQLException 2274 if a database access error occurs. 2275 */ 2276 boolean ownUpdatesAreVisible([in]long setType) raises (SQLException); 2277 2278 /** indicates whether a result set's own deletes are visible. 2279 @param setType 2280 defined in 2281 <type scope="com::sun::star::sdbc">ResultSetType</type> 2282 @returns 2283 <TRUE/> if so 2284 @throws SQLException 2285 if a database access error occurs. 2286 */ 2287 boolean ownDeletesAreVisible([in]long setType) raises (SQLException); 2288 2289 /** indicates whether a result set's own inserts are visible. 2290 @param setType 2291 defined in 2292 <type scope="com::sun::star::sdbc">ResultSetType</type> 2293 @returns 2294 <TRUE/> if so 2295 @throws SQLException 2296 if a database access error occurs. 2297 */ 2298 boolean ownInsertsAreVisible([in]long setType) raises (SQLException); 2299 2300 /** indicates whether updates made by others are visible. 2301 @param setType 2302 defined in 2303 <type scope="com::sun::star::sdbc">ResultSetType</type> 2304 @returns 2305 <TRUE/> if so 2306 @throws SQLException 2307 if a database access error occurs. 2308 */ 2309 boolean othersUpdatesAreVisible([in]long setType) raises (SQLException); 2310 2311 /** indicates whether deletes made by others are visible. 2312 @param setType 2313 defined in 2314 <type scope="com::sun::star::sdbc">ResultSetType</type> 2315 @returns 2316 <TRUE/> if so 2317 @throws SQLException 2318 if a database access error occurs. 2319 */ 2320 boolean othersDeletesAreVisible([in]long setType) raises (SQLException); 2321 2322 /** indicates whether inserts made by others are visible. 2323 @param setType 2324 defined in 2325 <type scope="com::sun::star::sdbc">ResultSetType</type> 2326 @returns 2327 <TRUE/> if so 2328 @throws SQLException 2329 if a database access error occurs. 2330 */ 2331 boolean othersInsertsAreVisible([in]long setType) raises (SQLException); 2332 2333 /** indicates whether or not a visible row update can be detected by 2334 calling the method 2335 <code>XResultSet.rowUpdated</code>. 2336 @param setType 2337 defined in 2338 <type scope="com::sun::star::sdbc">ResultSetType</type> 2339 @returns 2340 <TRUE/> if so 2341 @throws SQLException 2342 if a database access error occurs. 2343 */ 2344 boolean updatesAreDetected([in]long setType) raises (SQLException); 2345 2346 /** indicates whether or not a visible row delete can be detected by 2347 calling 2348 <member scope="com::sun::star::sdbc">XResultSet::rowDeleted()</member> 2349 . If deletesAreDetected() 2350 returns <FALSE/>, then deleted rows are removed from the result set. 2351 @param setType 2352 defined in 2353 <type scope="com::sun::star::sdbc">ResultSetType</type> 2354 @returns 2355 <TRUE/> if so 2356 @throws SQLException 2357 if a database access error occurs. 2358 */ 2359 boolean deletesAreDetected([in]long setType) raises (SQLException); 2360 2361 /** indicates whether or not a visible row insert can be detected 2362 by calling 2363 <member scope="com::sun::star::sdbc">XResultSet::rowInserted().</member> 2364 @param setType 2365 defined in 2366 <type scope="com::sun::star::sdbc">ResultSetType</type> 2367 @returns 2368 <TRUE/> if so 2369 @throws SQLException 2370 if a database access error occurs. 2371 */ 2372 boolean insertsAreDetected([in]long setType) raises (SQLException); 2373 2374 /** indicates whether the driver supports batch updates. 2375 @returns 2376 <TRUE/> if so 2377 @throws SQLException 2378 if a database access error occurs. 2379 */ 2380 boolean supportsBatchUpdates() raises (SQLException); 2381 2382 /** Gets a description of the user-defined types defined in a particular 2383 schema. Schema-specific UDTs may have type OBJECT, STRUCT, 2384 or DISTINCT. 2385 2386 2387 <p>Only types matching the catalog, schema, type name, and type 2388 criteria are returned. They are ordered by DATA_TYPE, TYPE_SCHEM, 2389 and TYPE_NAME. The type name parameter may be a fully-qualified 2390 name. In this case, the catalog and schemaPattern parameters are 2391 ignored. 2392 </p> 2393 <p>Each type description has the following columns: 2394 </p> 2395 <ol> 2396 <li> 2397 <b>TYPE_CAT</b> string => the type's catalog (may be <NULL/>) 2398 </li> 2399 <li> 2400 <b>TYPE_SCHEM</b> string => type's schema (may be <NULL/>) 2401 </li> 2402 <li> 2403 <b>TYPE_NAME</b> string => type name 2404 </li> 2405 <li> 2406 <b>CLASS_NAME</b> string => Java class name or service name 2407 </li> 2408 <li> 2409 <b>DATA_TYPE</b> string => type value. 2410 One of OBJECT, STRUCT, or DISTINCT 2411 </li> 2412 <li> 2413 <b>REMARKS</b> string => explanatory comment on the type 2414 </li> 2415 </ol> 2416 <p> 2417 <b>Note:</b> If the driver does not support UDTs, an empty 2418 result set is returned. 2419 </p> 2420 @param catalog 2421 a catalog name; "" retrieves those without a catalog; <VOID/> means drop catalog name from the selection criteria 2422 @param schemaPattern 2423 a schema name pattern; "" retrieves those without a schema 2424 @param typeNamePattern 2425 a type name pattern; may be a fully-qualified name 2426 @param types 2427 a list of user-named types to include (OBJECT, STRUCT, or DISTINCT) 2428 @returns 2429 each row is a type description 2430 @throws SQLException 2431 if a database access error occurs. 2432 */ 2433 XResultSet getUDTs([in]any catalog, [in]string schemaPattern, 2434 [in]string typeNamePattern, [in]sequence<long> types) 2435 raises (SQLException); 2436 2437 /** retrieves the connection that produced this metadata object. 2438 @returns 2439 the Connection object 2440 @throws SQLException 2441 if a database access error occurs. 2442 */ 2443 XConnection getConnection() raises (SQLException); 2444}; 2445 2446 2447}; }; }; }; 2448 2449/*=========================================================================== 2450===========================================================================*/ 2451#endif 2452 2453/* vim:set shiftwidth=4 softtabstop=4 expandtab: */