PageRenderTime 77ms CodeModel.GetById 25ms RepoModel.GetById 0ms app.codeStats 0ms

/offapi/com/sun/star/sdbc/XDatabaseMetaData.idl

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