PageRenderTime 47ms CodeModel.GetById 16ms 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

Large files files are truncated, but you can click here to view the full file

  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 tab…

Large files files are truncated, but you can click here to view the full file