Small doc changes.

Author: anthony-tuininga

doc/src/api_manual/soda.rst

@@ -323,9 +323,9 @@ SodaOperation Methods
 
     .. seealso::
 
-        Oracle Database SQL Tuning Guide documentation `MONITOR and NO_MONITOR
-        Hints <https://www.oracle.com/pls/topic/lookup?ctx=dblatest&id=GUID-
-        19E0F73C-A959-41E4-A168-91E436DEE1F1>`__ and `Monitoring Database
+        Oracle AI Database SQL Tuning Guide documentation `MONITOR and
+        NO_MONITOR Hints <https://www.oracle.com/pls/topic/lookup?ctx=dblatest&
+        id=GUID-19E0F73C-A959-41E4-A168-91E436DEE1F1>`__ and `Monitoring Database
         Operations <https://www.oracle.com/pls/topic/lookup?ctx=dblatest&id=
         GUID-C941CE9D-97E1-42F8-91ED-4949B2B710BF>`__
 

doc/src/user_guide/appendix_a.rst

@@ -258,7 +258,7 @@ For more details see :ref:`driverdiff` and :ref:`upgrading83`.
       - Yes
       - Yes
     * - Oracle Transactional Event Queues and Advanced Queuing (AQ) (see :ref:`aqusermanual`)
-      - Yes - only "Classic" queues are supported (RAW, named Oracle object, and JSON payloads)
+      - Yes
       - Yes
       - Yes
     * - Call timeouts (see :attr:`Connection.call_timeout`)
@@ -367,13 +367,13 @@ For more details see :ref:`driverdiff` and :ref:`upgrading83`.
 Supported Oracle Database Data Types
 ====================================
 
-The following table lists the Oracle Database types that are supported in the
-python-oracledb driver.  See `Oracle Database Types <https://www.oracle.com/
-pls/topic/lookup?ctx=dblatest&id=GUID-A3C0D836-BADB-44E5-A5D4-265BA5968483>`__
-and `PL/SQL Types <https://www.oracle.com/pls/topic/lookup?ctx=dblatest&id=GUID
--391C58FD-16AF-486C-AF28-173E309CDBA5>`__.  The python-oracledb constant shown
-is the common one.  In some python-oracledb APIs you may use other types, for
-example when binding numeric values.
+The following table lists the Oracle Database types that are supported in
+the python-oracledb driver.  See `Oracle Database Types <https://www.oracle.
+com/pls/topic/lookup?ctx=dblatest&id=GUID-A3C0D836-BADB-44E5-A5D4-
+265BA5968483>`__ and `PL/SQL Types <https://www.oracle.com/pls/topic/lookup?
+ctx=dblatest&id=GUID-391C58FD-16AF-486C-AF28-173E309CDBA5>`__.  The
+python-oracledb constant shown is the common one.  In some python-oracledb
+APIs you may use other types, for example when binding numeric values.
 
 .. list-table-with-summary::  Oracle Database Data Types Supported
     :header-rows: 1

doc/src/user_guide/appendix_c.rst

@@ -25,16 +25,16 @@ to python-oracledb:
   See :ref:`installation` for details.
 
 - By default, python-oracledb runs in a 'Thin' mode which connects directly to
-  Oracle Database.  This mode does not need Oracle Client libraries.  However,
-  some :ref:`additional functionality <featuresummary>` is available when
-  python-oracledb uses them.  Python-oracledb is said to be in 'Thick' mode
-  when Oracle Client libraries are used.  See :ref:`enablingthick`.  Both modes
-  have comprehensive functionality supporting the Python Database API v2.0
-  Specification. The Thick mode is equivalent to cx_Oracle.
+  Oracle Database.  This mode does not need Oracle Client libraries.
+  However, some :ref:`additional functionality <featuresummary>` is available
+  when python-oracledb uses them.  Python-oracledb is said to be in 'Thick'
+  mode when Oracle Client libraries are used.  See :ref:`enablingthick`.  Both
+  modes have comprehensive functionality supporting the Python Database API
+  v2.0 Specification. The Thick mode is equivalent to cx_Oracle.
 
   cx_Oracle always runs in a Thick mode using Oracle Client libraries.  The
-  features in python-oracledb Thick mode and cx_Oracle 8.3 are the same, subject
-  to the :ref:`new features <releasenotes>`, some :ref:`deprecations
+  features in python-oracledb Thick mode and cx_Oracle 8.3 are the same,
+  subject to the :ref:`new features <releasenotes>`, some :ref:`deprecations
   <deprecations>`, and to other changes noted in the documentation.
 
 - python-oracledb Thin and Thick modes have the same level of support for the
@@ -400,12 +400,12 @@ need to be made in addition to the common :ref:`commonupgrade`:
    ``network/admin/`` subdirectory may not be automatically loaded in Thin mode
    on some platforms. A ``tnsnames.ora`` file identified by the Windows
    registry, or in ``$ORACLE_BASE/homes/XYZ/network/admin/`` (in a read-only
-   Oracle Database home) will never be automatically located by python-oracledb
-   Thin mode.
+   Oracle Database home) will never be automatically located by
+   python-oracledb Thin mode.
 
-   Only python-oracledb Thick mode will read :ref:`sqlnet.ora <optnetfiles>` and
-   :ref:`oraaccess.xml <optclientfiles>` files.  The Thin mode lets equivalent
-   properties be set in the application when connecting.
+   Only python-oracledb Thick mode will read :ref:`sqlnet.ora <optnetfiles>`
+   and :ref:`oraaccess.xml <optclientfiles>` files.  The Thin mode lets
+   equivalent properties be set in the application when connecting.
 
 6. To use python-oracledb Thin mode in an ``ORACLE_HOME`` database installation
    environment, you must use an explicit connection string since the

doc/src/user_guide/appendix_d.rst

@@ -110,7 +110,7 @@ Pooled Connections in SQLAlchemy
 
 Most multi-user applications should use a :ref:`connection pool <connpooling>`.
 The python-oracledb pool is preferred because of its high availability
-support. Some single-user applications may also benfit from these availability
+support. Some single-user applications may also benefit from these availability
 features.
 
 To use a python-oracledb connection pool in SQLAlchemy:

doc/src/user_guide/aq.rst

@@ -19,8 +19,8 @@ Queuing. They were previously called AQ Sharded Queues.
 
 .. note::
 
-    Transactional Event Queues are only supported in python-oracledb
-    :ref:`Thick mode <enablingthick>`.
+    Transactional Event Queues with JMS payloads are only supported in
+    python-oracledb :ref:`Thick mode <enablingthick>`.
 
 Python-oracledb API calls are the same for Transactional Event Queues and
 Classic Queues, however there are differences in support for some payload
@@ -37,17 +37,15 @@ types which are detailed below.
       - Transactional Event Queues
     * - RAW
       - Supported
-      - Supported for single and array message enqueuing and dequeuing when using Oracle Client 19c (or later) and connected to Oracle Database 19c (or later).
+      - Supported for single and array message enqueuing and dequeuing when using Oracle Database 19c (or later). In python-oracledb Thick mode, Oracle Client libraries 19c (or later) are needed.
     * - Named Oracle Objects
       - Supported
-      - Supported for single and array message enqueuing and dequeuing when using Oracle Client 19c (or later) and connected to Oracle Database 19c (or later).
+      - Supported for single and array message enqueuing and dequeuing when using Oracle Database 19c (or later). In python-oracledb Thick mode, Oracle Client libraries 19c (or later) are needed.
     * - JSON
       - Supported when using Oracle Database 21c (or later). In python-oracle Thick mode, Oracle Client libraries 21c (or later) are also needed.
 
         Buffered messaging using the :data:`~oracledb.MSG_BUFFERED` delivery mode is not supported for JSON payloads.
-      - Supported for single message enqueuing and dequeuing when using Oracle Client libraries 21c (or later) and Oracle Database 21c (or later).
-
-        Array enqueuing and dequeuing is not supported for JSON payloads.
+      - Supported for single and array message enqueuing and dequeuing when using Oracle Database 21c (or later). In python-oracledb Thick mode, Oracle Client libraries 21c (or later) are needed.
 
         Buffered messaging using the :data:`~oracledb.MSG_BUFFERED` delivery mode is not supported for JSON payloads.
     * - JMS
@@ -56,9 +54,13 @@ types which are detailed below.
 
 **Usage Notes**
 
-For classic queues, the use of :data:`oracledb.ENQ_IMMEDIATE` with bulk
-enqueuing, and JMS payloads are only supported in python-oracledb
-:ref:`Thick mode <enablingthick>`.
+For Classic Queues and Transactional Event Queues, the use of
+:data:`oracledb.ENQ_IMMEDIATE` with bulk enqueuing, and JMS payloads are only
+supported in python-oracledb :ref:`Thick mode <enablingthick>`.
+
+The ``payload_type`` parameter in :meth:`Connection.queue()` must be
+specified when the payload is JSON or Named Oracle Objects. This parameter need
+not be specified for RAW payloads.
 
 Transactional Event Queues do not support :attr:`EnqOptions.transformation`,
 :attr:`DeqOptions.transformation`, or :ref:`Recipient Lists <reciplists>`.

doc/src/user_guide/asyncio.rst

@@ -6,9 +6,9 @@
 Concurrent Programming with asyncio and Pipelining
 **************************************************
 
-:ref:`concurrentprogramming` and :ref:`Oracle Database Pipelining <pipelining>`
-significantly enhances the overall performance and responsiveness of
-applications.
+:ref:`concurrentprogramming` and :ref:`Oracle Database Pipelining
+<pipelining>` significantly enhances the overall performance and responsiveness
+of applications.
 
 .. _concurrentprogramming:
 
@@ -169,10 +169,10 @@ Executing SQL Using Asynchronous Methods
 This section covers executing SQL using the asynchronous programming model.
 For discussion of synchronous programming, see :ref:`sqlexecution`.
 
-Your application communicates with Oracle Database by executing SQL
-statements. Statements such as queries (statements beginning with SELECT or
-WITH), Data Manipulation Language (DML), and Data Definition Language (DDL) are
-executed using the asynchronous methods :meth:`AsyncCursor.execute()` or
+Your application communicates with Oracle Database by executing SQL statements.
+Statements such as queries (statements beginning with SELECT or WITH), Data
+Manipulation Language (DML), and Data Definition Language (DDL) are executed
+using the asynchronous methods :meth:`AsyncCursor.execute()` or
 :meth:`AsyncCursor.executemany()`. Rows can be iterated over, or fetched using
 one of the methods :meth:`AsyncCursor.fetchone()`,
 :meth:`AsyncCursor.fetchone()`, :meth:`AsyncCursor.fetchmany()`, or
@@ -363,9 +363,9 @@ Pipelined operations are executed sequentially by the database. They do not
 execute concurrently. It is local tasks that can be executed at the same time
 the database is working.
 
-Effective use of Oracle Database Pipelining can increase the responsiveness of
-an application and improve overall system throughput. Pipelining is useful when
-many small operations are being performed in rapid succession. It is most
+Effective use of Oracle Database Pipelining can increase the responsiveness
+of an application and improve overall system throughput. Pipelining is useful
+when many small operations are being performed in rapid succession. It is most
 beneficial when the network to the database is slow. This is because of its
 reduction in :ref:`round-trips <roundtrips>` compared with those required if
 the equivalent SQL statements were individually executed with calls like
@@ -381,8 +381,8 @@ about Oracle Database Pipelining.
 
 .. note::
 
-    True pipelining only occurs when you are connected to Oracle Database
-    version 23, or later.
+    True pipelining only occurs when you are connected to Oracle AI Database
+    26ai, or later.
 
     When you connect to an older database, operations are sequentially
     executed by python-oracledb. Each operation concludes before the next is
@@ -439,7 +439,6 @@ operation. The objects contain information about the execution of the relevant
 operation, such as any error number, PL/SQL function return value, or any query
 rows and column metadata.
 
-
 The :attr:`Connection.call_timeout` value has no effect on pipeline operations.
 To limit the time for a pipeline, use an `asyncio timeout
 <https://docs.python.org/3/library/asyncio-task.html#timeouts>`__, available

doc/src/user_guide/authentication_methods.rst

@@ -21,11 +21,11 @@ Database Authentication
 
 Database Authentication is the most basic authentication method that allows
 users to connect to Oracle Database by using a valid database username and
-their associated password. Oracle Database verifies the username and password
-specified in the python-oracledb connection method with the information stored
-in the database. See `Database Authentication of Users <https://www.oracle.com
-/pls/topic/lookup?ctx=dblatest&id=GUID-1F783131-CD1C-4EA0-9300-C132651B0700>`__
-for more information.
+their associated password. Oracle Database verifies the username and
+password specified in the python-oracledb connection method with the
+information stored in the database. See `Database Authentication of Users
+<https://www.oracle.com/pls/topic/lookup?ctx=dblatest&id=GUID-1F783131-CD1C-
+4EA0-9300-C132651B0700>`__ for more information.
 
 :ref:`Standalone connections <standaloneconnection>` and
 :ref:`pooled connections <connpooling>` can be created in python-oracledb Thin
@@ -149,8 +149,8 @@ Using an Oracle Wallet for External Authentication
 
 The following steps give an overview of using an Oracle Wallet.  Wallets should
 be kept securely.  Wallets can be managed with `Oracle Wallet Manager
-<https://docs.oracle.com/en/database/oracle/oracle-database/21/dbimi/using-
-oracle-wallet-manager.html#GUID-E3E16C82-E174-4814-98D5-EADF1BCB3C37>`__.
+<https://www.oracle.com/pls/topic/lookup?ctx=db21&id=GUID-E3E16C82-E174-4814-
+98D5-EADF1BCB3C37>`__.
 
 In this example the wallet is created for the ``myuser`` schema in the
 directory ``/home/oracle/wallet_dir``.  The ``mkstore`` command is available
@@ -334,8 +334,8 @@ steps give an overview of how to implement OS Authentication on Linux.
         ------------------------------------ ----------- ------------------------------
         os_authent_prefix                    string      ops$
 
-3.  Create an Oracle database user using the ``os_authent_prefix`` determined in
-    step 2, and the operating system user name:
+3.  Create an Oracle Database user using the ``os_authent_prefix`` determined
+    in step 2, and the operating system user name:
 
    .. code-block:: sql
 
@@ -354,7 +354,7 @@ If your database is not on the same computer as Python, you can perform testing
 by setting the database configuration parameter ``remote_os_authent=true``.
 Beware of security concerns because this is insecure.
 
-See `Oracle Database Security Guide
+See `Oracle AI Database Security Guide
 <https://www.oracle.com/pls/topic/lookup?ctx=dblatest&
 id=GUID-37BECE32-58D5-43BF-A098-97936D66968F>`__ for more information about
 Operating System Authentication.
@@ -877,10 +877,10 @@ OAuth 2.0 Token-Based Authentication
 Oracle Cloud Infrastructure (OCI) users can be centrally managed in a Microsoft
 Entra ID (formerly Microsoft Azure Active Directory) service. Open
 Authorization (OAuth 2.0) token-based authentication allows users to
-authenticate to Oracle Database using Entra ID OAuth2 tokens. Ensure that you
-have a Microsoft Azure account and your Oracle Database is registered with
-Microsoft Entra ID. See `Configuring the Oracle Database for Microsoft Entra
-ID Integration <https://www.oracle.com/pls/topic/lookup?ctx=dblatest&id=
+authenticate to Oracle Database using Entra ID OAuth2 tokens. Ensure that
+you have a Microsoft Azure account and your Oracle Database is registered
+with Microsoft Entra ID. See `Configuring the Oracle Database for Microsoft
+Entra ID Integration <https://www.oracle.com/pls/topic/lookup?ctx=dblatest&id=
 GUID-0A60F22D-56A3-408D-8EC8-852C38C159C0>`_ for more information. Both Thin
 and Thick modes of the python-oracledb driver support OAuth 2.0 token-based
 authentication.
@@ -1429,9 +1429,9 @@ information, see `Accessing the Database Using an Instance Principal
 4BCE-91D0-239D287C638B>`__.
 
 Also, make sure that external authentication is enabled on Oracle ADB and
-Oracle Database parameter ``IDENTITY_PROVIDER_TYPE`` is set to *OCI_IAM*. For
-the steps, see `Enable IAM Authentication on ADB <https://docs.oracle.com/en/
-cloud/paas/autonomous-database/serverless/adbsb/enable-iam-authentication
+Oracle Database parameter ``IDENTITY_PROVIDER_TYPE`` is set to *OCI_IAM*.
+For the steps, see `Enable IAM Authentication on ADB <https://docs.oracle.com/
+en/cloud/paas/autonomous-database/serverless/adbsb/enable-iam-authentication
 .html>`__.
 
 **Step 6: Deploy your application on the Compute Instance**

doc/src/user_guide/batch_statement.rst

@@ -778,4 +778,5 @@ python-oracledb requirement or API needed to take advantage of the feature.
 
 To use the Memoptimized Rowstore see Oracle Database documentation `Enabling
 High Performance Data Streaming with the Memoptimized Rowstore
-<https://www.oracle.com/pls/topic/lookup?ctx=dblatest&id=GUID-9752E93D-55A7-4584-B09B-9623B33B5CCF>`__.
+<https://www.oracle.com/pls/topic/lookup?ctx=dblatest&id=GUID-9752E93D-55A7-
+4584-B09B-9623B33B5CCF>`__.

doc/src/user_guide/bind.rst

@@ -6,9 +6,9 @@
 Using Bind Variables
 ********************
 
-SQL and PL/SQL statements that pass data to and from Oracle Database should use
-placeholders in SQL and PL/SQL statements that mark where data is supplied or
-returned.  A bind variable placeholder is a colon-prefixed identifier or
+SQL and PL/SQL statements that pass data to and from Oracle Database should
+use placeholders in SQL and PL/SQL statements that mark where data is supplied
+or returned.  A bind variable placeholder is a colon-prefixed identifier or
 numeral. For example, ``:dept_id`` and ``:dept_name`` are the two bind variable
 placeholders in this SQL statement:
 
@@ -796,9 +796,9 @@ unexpected values or the Python application segfaulting.
 Binding Spatial Data Types
 ==========================
 
-Oracle Spatial data types objects can be represented by Python objects and their
-attribute values can be read and updated. The objects can further be bound and
-committed to database. This is similar to the examples above.
+Oracle Spatial data types objects can be represented by Python objects and
+their attribute values can be read and updated. The objects can further be
+bound and committed to database. This is similar to the examples above.
 
 An example of fetching SDO_GEOMETRY is in :ref:`Oracle Database Objects and
 Collections <fetchobjects>`.
@@ -847,8 +847,8 @@ will accept them but there will be no processing benefit.
 It is not uncommon for SQL statements to have low hundreds of
 versions. Sometimes this is expected and not a result of any issue. To
 determine the reason, find the SQL identifier of the statement and then query
-the Oracle Database view `V$SQL_SHARED_CURSOR <https://www.oracle.com/pls/topic
-/lookup?ctx=dblatest&id=GUID-4993A6DE-5658-4745-B43E-F5AD9DB8DCCC>`__.
+the Oracle Database view `V$SQL_SHARED_CURSOR <https://www.oracle.com/pls/
+topic/lookup?ctx=dblatest&id=GUID-4993A6DE-5658-4745-B43E-F5AD9DB8DCCC>`__.
 
 The SQL identifier of a statement can be found in Oracle Database views like
 `V$SQLAREA <https://www.oracle.com/pls/topic/lookup?ctx=dblatest&id=GUID-
@@ -1013,8 +1013,8 @@ This will produce the same output as the original example.
 
 Reusing the same SQL statement like this for a variable number of values,
 instead of constructing a unique statement per set of values, allows best reuse
-of Oracle Database resources. Additionally, if a statement with a large number
-of bind variable placeholders is executed many times with varying string
+of Oracle Database resources. Additionally, if a statement with a large
+number of bind variable placeholders is executed many times with varying string
 lengths for each execution, then consider using :func:`Cursor.setinputsizes()`
 to reduce Oracle Database's SQL ":ref:`version count <sqlversioncount>`" for
 the statement. For example, if the columns are VARCHAR2(25), then add this
@@ -1079,8 +1079,8 @@ The best way to do the '<something that returns a list of values>' depends on
 how the data is initially represented and the number of items. For example you
 might look at using a global temporary table.
 
-One method for large IN lists is to use an Oracle Database collection with the
-``TABLE()`` clause. For example, if the following type was created::
+One method for large IN lists is to use an Oracle Database collection with
+the ``TABLE()`` clause. For example, if the following type was created::
 
     SQL> CREATE OR REPLACE TYPE name_array AS TABLE OF VARCHAR2(25);
       2  /