i;y ddlZddlZddlZddlmZmZmZmZmZm Z ddl Z ddl m Z m Z mZmZmZddl mZddlmZmZmZddlmZddlmZdd l mZmZmZmZdd lm Z dd l!m"Z"m#Z#dd l$m%Z%dd l&m'Z'm(Z(ddl)m*Z*m+Z+ddl,m-Z-m.Z.ddl/m0Z0ddl1m2Z2ddl3m4Z4ej5dgdZ6GddeZ7Gdde7Z8dede8fdede8ffdZ9e9 d`dde8ddddddddddddddddddddddddddddddddddddddddddddddddddddddd9dee:d ed!d"ee:d#ee8d$ee d%ee:d&ee:d'ee:d(ee:d)ee:d*ee e:e;efd+ee:d,ee<d-ee:d.ee:d/ee<d0ee:d1ee:d2ee:d3ee:d4ee:d5ee j=d6ee<d7ee<d8ee<d9ee>d:ee?d;ee:dee?d?ee j@d@ee?dAee<dBee:dCee:dDee?dEee:dFeeAdGeeAdHeeAdIee:dJee:dKeedLee<dMee:dNee?dOeejBdPee:dQee:dRee:dSee:dTee:dUee?dVee?dWeeCdXee:dYee<de8fvdZZDGd[d\e7ZEdedeEfdedeEffd]ZFeF d`ddeEddddddddddddddddddddddddddddddddddddddddddddddddddddddd9dee:d ed^d"ee:d#eeEd$ee d%ee:d&ee:d'ee:d(ee:d)ee:d*ee e:e;efd+ee:d,ee<d-ee:d.ee:d/ee<d0ee:d1ee:d2ee:d3ee:d4ee:d5ee j=d6ee<d7ee<d8ee<d9ee>d:ee?d;ee:dee?d?ee j@d@ee?dAee<dBee:dCee:dDee?dEee:dFeeAdGeeAdHeeAdIee:dJee:dKeedLee<dMee:dNee?dOeejBdPee:dQee:dRee:dSee:dTee:dUee?dVee?dWeeCdXee:dYee<deEfvd_ZGdS)aN)AnyCallableIteratorTypeOptionalUnion) base_impl driver_modeerrors thick_impl thin_impl)pool) AsyncQueueQueueMessageProperties)ArrowSchemaImpl) BaseMetaClass) DB_TYPE_BLOB DB_TYPE_CLOB DB_TYPE_NCLOBDbType) ConnectParams) AsyncCursorCursor) DataFrame) DbObjectTypeDbObject)AsyncLOBLOB)PipelinePipelineOpResult) SodaDatabase) Subscription)$normalize_sessionless_transaction_idXid) format_idglobal_transaction_idbranch_qualifierc@eZdZdZdZdZdVdZdeddfdZe de fdZ e j d e ddfd Z e de fd Zej d e ddfd Z dWdeee efdede defdZe defdZej d eddfdZdVdZe de fdZej d e ddfdZe de fdZej d e ddfdZe de fdZej d e ddfdZe de fdZe de fdZe de fdZej d e ddfdZd edefd!Ze de fd"Ze de fd#Zej d e ddfd$Ze de fd%Z d edefd&Z!e de fd'Z"e"j d e ddfd(Z"e de#fd)Z$e$j d e#ddfd*Z$e de fd+Z%e de fd,Z&e&j d e ddfd-Z&de fd.Z'e defd/Z(e defd0Z)e defd1Z*e de fd2Z+e+j d e ddfd3Z+ dXd4eeee e,fd5ee d6eed7ee d8eed9eed:ee-de.fd;Z/ dYdd<d=e d>eee0e fd?ee0dee1e2ffd@Z3e de#fdAZ4e4j d e#ddfdBZ4e dee dffdCZ5 dZdee efdede defdDZ6e defdEZ7e defdFZ8e de fdGZ9e defdHZ:e defdIZ;e;j d eddfdJZ;e de fdKZe de fdOZ?e de fdPZ@e deeAjBdffdQZCdRedSeee fdTeee fdefdUZDdS)[BaseConnectionNcd|_dSN)_versionselfs c/var/www/html/Pagina-Ingenieria-Requisitos/venv/lib/python3.11/site-packages/oracledb/connection.py__init__zBaseConnection.__init__Ds  cz|jj}|jd|dS|jd|dSd|d|jd|jdS)Nz to externally identified user>z to @>) __class__ _public_name_implusernamedsn)r0cls_names r1__repr__zBaseConnection.__repr__Gsc>. : /x/// / ] "@x@@@ @<8<<<<<<<`__ value. An example is "36b8f84d-df4e-4d49-b662-bcde71a8764f". Any user-chosen value cannot exceed 64 bytes in length. The ``timeout`` parameter is the number of seconds that this transaction can stay suspended when :meth:`suspend_sessionless_transaction()` is later called, or if the transaction is automatically suspended when the ``suspend_on_success`` parameter is set to to *True* in :meth:`Cursor.execute()` or :meth:`Cursor.executemany()`. The default value is *60* seconds. If a transaction is not resumed within this specified duration, the transaction will be rolled back. The ``defer_round_trip`` parameter is a boolean that determines whether the request to start a transaction is to be sent immediately or with the next database operation. If set to *False*, the request is sent immediately. If set to *True*, the request is included with the next database operation on the connection. The default value is *False*. r"timeout must be a positive integerrCr%rFintrGr:begin_sessionless_transactionr0rYrZr[normalized_txnids r1r`z,BaseConnection.begin_sessionless_transaction|syF    ?OO'3'' B7a<<@AA A 00 g'7    r3c\||jS)aq This read-write attribute specifies the amount of time (in milliseconds) that a single round-trip to the database may take before a timeout will occur. A value of *0* means that no timeout will take place. In python-oracledb Thick mode, this attribute is only available in Oracle Client 18c or later. If a timeout occurs, the error ``DPI-1067`` will be returned if the connection is still usable. Alternatively the error ``DPI-1080`` will be returned if the connection has become invalid and can no longer be used. For consistency and compliance with the PEP 8 naming style, the attribute ``callTimeout`` was renamed to ``call_timeout``. The old name will continue to work for a period of time. The error ``DPI-1080`` was also introduced in this release. )rCr:get_call_timeoutr/s r1 call_timeoutzBaseConnection.call_timeouts**    z**,,,r3cb||j|dSr-rCr:set_call_timeoutrRs r1rezBaseConnection.call_timeout0     ##E*****r3c`||jdS)z2 Breaks a long-running statement. N)rCr:cancelr/s r1rkzBaseConnection.cancel0     r3c td)zl This write-only attribute sets the CLIENT_IDENTIFIER column in the V$SESSION view. z!client_identifier is not readablerKr/s r1client_identifierz BaseConnection.client_identifiers @AAAr3cb||j|dSr-)rCr:set_client_identifierrRs r1rnz BaseConnection.client_identifiers0     ((/////r3c td)zf This write-only attribute sets the CLIENT_INFO column in the V$SESSION view. zclientinfo is not readablerKr/s r1 clientinfozBaseConnection.clientinfos 9:::r3cb||j|dS)zJ Specifies the client_info column in the v$session table. N)rCr:set_client_inforRs r1rrzBaseConnection.clientinfos2     ""5)))))r3c\||jS)a This read-write attribute sets the current schema attribute for the session. Setting this value is the same as executing the SQL statement ``ALTER SESSION SET CURRENT_SCHEMA``. The attribute is set (and verified) on the next call that does a round trip to the server. The value is placed before unqualified database objects in SQL statements you then execute. )rCr:get_current_schemar/s r1current_schemazBaseConnection.current_schemas*    z,,...r3cb||j|dSr-)rCr:set_current_schemarRs r1rwzBaseConnection.current_schemas0     %%e,,,,,r3c\||jS)z This read-only attribute specifies the Oracle Database domain name associated with the connection. It is the same value returned by the SQL ``SELECT value FROM V$PARAMETER WHERE NAME = 'db_domain'``. )rCr: get_db_domainr/s r1 db_domainzBaseConnection.db_domains*    z'')))r3c\||jS)z This read-only attribute specifies the Oracle Database name associated with the connection. It is the same value returned by the SQL ``SELECT NAME FROM V$DATABASE``. )rCr: get_db_namer/s r1db_namezBaseConnection.db_names*    z%%'''r3c td)z This write-only attribute sets the database operation that is to be monitored. This can be viewed in the DBOP_NAME column of the V$SQL_MONITOR view. zdbop is not readablerKr/s r1dbopzBaseConnection.dbops3444r3cb||j|dSr-)rCr:set_dboprRs r1rzBaseConnection.dbops0     E"""""r3datac^||j|S)aJ Decodes `OSON-encoded `__ bytes and returns the object encoded in those bytes. This is useful for fetching columns which have the check constraint ``IS JSON FORMAT OSON`` enabled. )rCr: decode_oson)r0rs r1rzBaseConnection.decode_osons,    z%%d+++r3cB||jjS)z This read-only attribute returns the TNS entry of the database to which a connection has been established. )rCr:r<r/s r1r<zBaseConnection.dsn*s    z~r3c td)z This write-only attribute specifies the execution context id. This value can be found as the ECID column in the V$SESSION view and ECONTEXT_ID in the auditing tables. The maximum length is 64 bytes. zecontext_id is not readablerKr/s r1 econtext_idzBaseConnection.econtext_id3s:;;;r3cb||j|dSr-)rCr:set_econtext_idrRs r1rzBaseConnection.econtext_id<s0     ""5)))))r3c\||jS)z This read-only attribute gets the session edition and is only available with Oracle Database 11.2, or later. )rCr: get_editionr/s r1editionzBaseConnection.editionAs*    z%%'''r3c^||j|S)aF Encodes a Python value into `OSON-encoded `__ bytes and returns them. This is useful for inserting into columns which have the check constraint ``IS JSON FORMAT OSON`` enabled. )rCr: encode_osonrRs r1rzBaseConnection.encode_osonJs,    z%%e,,,r3c\||jS)z This read-write attribute specifies the external name that is used by the connection when logging distributed transactions. )rCr:get_external_namer/s r1 external_namezBaseConnection.external_nameU*    z++---r3cb||j|dSr-)rCr:set_external_namerRs r1rzBaseConnection.external_name^0     $$U+++++r3cB||jjS)a This read-write attribute specifies a method called for each value that is bound to a statement executed on any cursor associated with this connection. The method signature is handler(cursor, value, arraysize) and the return value is expected to be a variable object or *None* in which case a default variable object will be created. If this attribute is *None*, the default behavior will take place for all values bound to statements. rCr:inputtypehandlerr/s r1rzBaseConnection.inputtypehandlercs!    z**r3cF|||j_dSr-rrRs r1rzBaseConnection.inputtypehandlerqs$    &+ ###r3c\||jS)z This read-only attribute specifies the Oracle Database instance name associated with the connection. It is the same value as the SQL expression ``sys_context('userenv', 'instance_name')``. )rCr:get_instance_namer/s r1 instance_namezBaseConnection.instance_namevs*    z++---r3c\||jS)z This read-write attribute specifies the internal name that is used by the connection when logging distributed transactions. )rCr:get_internal_namer/s r1 internal_namezBaseConnection.internal_namerr3cb||j|dSr-)rCr:set_internal_namerRs r1rzBaseConnection.internal_namerr3cF|jduo|jS)a This function returns a boolean indicating the health status of a connection. Connections may become unusable in several cases, such as, if the network socket is broken, if an Oracle error indicates the connection is unusable, or, after receiving a planned down notification from the database. This function is best used before starting a new database request on an existing :ref:`standalone connections `. For pooled connections, the :meth:`ConnectionPool.acquire()` method internally performs this check before returning a connection to the application, see :ref:`poolhealth`. If this function returns *False*, the connection should be not be used by the application and a new connection should be established instead. This function performs a local check. To fully check a connection's health, use :meth:`ping()` which performs a round-trip to the database. N)r:get_is_healthyr/s r1 is_healthyzBaseConnection.is_healthys$.z%E$**C*C*E*EEr3c\||jS)a This read-only attribute returns the logical transaction id for the connection. It is used within Oracle Transaction Guard as a means of ensuring that transactions are not duplicated. See :ref:`tg` for more information. This is only available with Oracle Database 12.1 or later. In python-oracledb Thick mode, it also requires Oracle Client libraries 12.1 or later. )rCr: get_ltxidr/s r1ltxidzBaseConnection.ltxids*    z##%%%r3c\||jS)au This read-only attribute specifies the maximum database identifier length in bytes supported by the database to which the connection has been established. See `Database Object Naming Rules `__. The value may be *None*, *30*, or *128*. The value *None* indicates the size cannot be reliably determined by python-oracledb, which occurs when using Thick mode with Oracle Client libraries 12.1 (or older) to connect to Oracle Database 12.2, or later. )rCr:get_max_identifier_lengthr/s r1max_identifier_lengthz$BaseConnection.max_identifier_lengths*    z33555r3c\||jS)ae This read-only attribute specifies the maximum number of cursors that the database can have open concurrently. It is the same value returned by the SQL ``SELECT VALUE FROM V$PARAMETER WHERE NAME = 'open_cursors'``. When using python-oracledb Thick mode, Oracle Client libraries 12.1 (or later) are required. )rCr:get_max_open_cursorsr/s r1max_open_cursorszBaseConnection.max_open_cursorss*    z..000r3c td)z This write-only attribute sets the MODULE column in the V$SESSION view. The maximum length for this string is 48 and if you exceed this length you will get ``ORA-24960``. zmodule is not readablerKr/s r1modulezBaseConnection.modulerNr3cb||j|dSr-)rCr: set_modulerRs r1rzBaseConnection.modulerSr3payload correlationdelay exceptionq expirationpriority recipientsc|j}tj|} ||| _||| _||| _||| _||| _||| _ ||| _ | S)z Returns an object specifying the properties of messages used in advanced queuing. Each of the parameters are optional. If specified, they act as a shortcut for setting each of the equivalently named properties. ) r:create_msg_props_implr _from_implrrrrrrr) r0rrrrrrrimplpropss r1 msgpropertieszBaseConnection.msgpropertiess"z//11!,T22  #EM  " +E   EK  !)E   !)E   %EN  !)E  r3) payloadTypename payload_typerc|d}d}|%|!tjtjdd|}|4|dkrd}n+t |t st d|j}|j}| |j|||| |S) a Creates a queue which is used to enqueue and dequeue messages in Advanced Queuing. The ``name`` parameter is expected to be a string identifying the queue in which messages are to be enqueued or dequeued. The ``payload_type`` parameter, if specified, is expected to be an :ref:`object type ` that identifies the type of payload the queue expects. If the string "JSON" is specified, JSON data is enqueued and dequeued. If not specified, RAW data is enqueued and dequeued. For consistency and compliance with the PEP 8 naming style, the parameter ``payloadType`` was renamed to ``payload_type``. The old name will continue to work as a keyword parameter for a period of time. NFrrdeprecated_namenew_nameJSONTzexpecting DbObjectType) rCr rAERR_DUPLICATED_PARAMETERrFrrGr:create_queue_impl initialize _create_queue)r0rrrpayload_type_implis_jsonrs r1queuezBaseConnection.queues0       "'!3$1+ 'L  #v%% l;; 7 8999$0$6!z++--  D*;WEEE!!$'''r3cB||jjS)a This read-write attribute specifies a method called for each column that is going to be fetched from any cursor associated with this connection. The method signature is ``handler(cursor, metadata)`` and the return value is expected to be a :ref:`variable object` or *None* in which case a default variable object will be created. If this attribute is *None*, the default behavior will take place for all columns fetched from cursors. rCr:outputtypehandlerr/s r1rz BaseConnection.outputtypehandler1s!    z++r3cF|||j_dSr-rrRs r1rz BaseConnection.outputtypehandler?s$    ', $$$r3cB||jjS)z This read-only attribute returns the name of the user which was used as a proxy when creating the connection to the database. )rCr: proxy_userr/s r1rzBaseConnection.proxy_userDs!    z$$r3c||tdt|}t|tr|dkst d|j||||Sa Resumes an existing sessionless transaction using the specified transaction identifier. This method returns the transaction identifier used to resume the sessionless transaction. The ``transaction_id`` parameter should be a string or bytes value that uniquely identifies an existing sessionless transaction that is to be resumed. The ``timeout`` parameter is the number of seconds that the current connection waits to resume a transaction if another connection is using it. When ``defer_round_trip`` is set to *False*, the wait happens in the ``resume_sessionless_transaction()`` call itself, and the function blocks until the transaction becomes available or the timeout expires. When ``defer_round_trip`` is set to *True*, the resume is deferred and the wait occurs at the time of the next database operation instead. At the start of the wait period, if the transaction is not in use by any other connection, the resume happens immediately. If the transaction remains in use by the other connection after the timeout period, the error `ORA-25351 `__ is raised. If another connection completes the transaction, the error `ORA-24756 `__ is raised. These error messages are only thrown for non-RAC instances. For information on using Oracle RAC, see :ref:`Sessionless Transactions with Oracle RAC `. The default value is *60* seconds. The ``defer_round_trip`` parameter is a boolean that determines whether the request to resume a transaction is to be sent immediately or with the next database operation. If set to *False*, the request is sent immediately. If set to *True*, the request is included with the next database operation on the connection. The default value is *False*. Nz'transaction_id is required for resumingrz&timeout must be a non-negative integerrC ValueErrorr%rFr_rGr:resume_sessionless_transactionras r1rz-BaseConnection.resume_sessionless_transactionMsP     !FGG G?OO7C(( FW\\DEE E 11 g'7    r3c\||jS)a This read-only attribute specifies the size of the Session Data Unit (SDU) that is being used by the connection. The value will be the lesser of the requested python-oracledb size and the maximum size allowed by the database network configuration. It is available only in python-oracledb Thin mode. To set the SDU in Thick mode, use a connection string SDU parameter or set a value for DEFAULT_SDU_SIZE in a sqlnet.ora configuration file. )rCr:get_sdur/s r1sduzBaseConnection.sdus*    z!!###r3c\||jS)au This read-only attribute specifies the session serial number associated with the connection. It is the same value returned by the SQL ``SELECT SERIAL# FROM V$SESSION WHERE SID=SYS_CONTEXT('USERENV', 'SID')``. It is available only in python-oracledb Thin mode. For applications using :ref:`drcp`, the ``serial_num`` attribute may not contain the current session state until a round-trip is made to the database after acquiring a session. It is recommended to not use this attribute if your application uses DRCP but may not perform a round-trip. )rCr:get_serial_numr/s r1 serial_numzBaseConnection.serial_num*    z((***r3c\||jS)z This read-only attribute specifies the Oracle Database service name associated with the connection. This is the same value returned by the SQL ``SELECT SYS_CONTEXT('USERENV', 'SERVICE_NAME') FROM DUAL``. )rCr:get_service_namer/s r1 service_namezBaseConnection.service_names*    z**,,,r3c\||jS)aZ This read-only attribute specifies the session identifier associated with the connection. It is the same value returned by the SQL ``SELECT SYS_CONTEXT('USERENV', 'SID') FROM DUAL``. It is available only in python-oracledb Thin mode. For applications using :ref:`drcp`, the ``session_id`` attribute may not contain the current session state until a round-trip is made to the database after acquiring a session. It is recommended to not use this attribute if your application uses DRCP but may not perform a round-trip. )rCr:get_session_idr/s r1 session_idzBaseConnection.session_idrr3c\||jS)a  This read-write attribute specifies the size of the statement cache. This value can make a significant difference in performance if you have a small number of statements that you execute repeatedly. The default value is *20*. )rCr:get_stmt_cache_sizer/s r1 stmtcachesizezBaseConnection.stmtcachesizes*    z--///r3cb||j|dSr-)rCr:set_stmt_cache_sizerRs r1rzBaseConnection.stmtcachesizes0     &&u-----r3cB||jjS)a This read-write attribute initially contains the actual tag of the session that was acquired from a pool by :meth:`ConnectionPool.acquire()`. If the connection was not acquired from a pool or no tagging parameters were specified (``tag`` and ``matchanytag``) when the connection was acquired from the pool, this value will be None. If the value is changed, it must be a string containing name=value pairs like "k1=v1;k2=v2". If this value is not *None* when the connection is released back to the pool it will be used to retag the session. This value can be overridden in the call to :meth:`ConnectionPool.release()`. rCr:tagr/s r1rzBaseConnection.tags     z~r3cF|||j_dSr-rrRs r1rzBaseConnection.tags!     r3cB||jjS)z This read-only attribute returns a boolean indicating if python-oracledb is in Thin mode (*True*) or Thick mode (*False*). )rCr:thinr/s r1rzBaseConnection.thins    zr3c\||jS)z This read-only attribute specifies whether a transaction is currently in progress on the database associated with the connection. )rCr:get_transaction_in_progressr/s r1transaction_in_progressz&BaseConnection.transaction_in_progresss*    z55777r3cB||jjS)z This read-only attribute returns the name of the user which established the connection to the database. )rCr:r;r/s r1r;zBaseConnection.usernames!    z""r3c|jB|dd|jjD|_|jS)z This read-only attribute returns the version of the database to which a connection has been established. N.c34K|]}t|VdSr-)str).0cs r1 z)BaseConnection.version..s($O$OSVV$O$O$O$O$O$Or3)r.rCjoinr:server_versionr/s r1versionzBaseConnection.versionsM =  " " $ $ $HH$O$OTZ5N$O$O$OOODM}r3cB||jjS)aB This read-only attribute provides an :ref:`oracledb._Error` object giving information about any database warnings (such as the password being in the grace period, or the pool being created with a smaller than requested size due to database resource restrictions) that were generated during connection establishment or by :meth:`oracledb.create_pool()`. The attribute will be present if there was a warning, but creation otherwise completed successfully. The connection will be usable despite the warning. For :ref:`standalone connections `, ``Connection.warning`` will be present for the lifetime of the connection. For :ref:`pooled connections `, ``Connection.warning`` will be cleared when a connection is released to the pool such as with :meth:`ConnectionPool.release()`. In python-oracledb Thick mode, warnings may be generated during pool creation itself. These warnings will be placed on new connections created by the pool, provided no warnings were generated by the individual connection creations, in which case those connection warnings will be returned. If no warning was generated the value *None* is returned. )rCr:warningr/s r1rzBaseConnection.warning s!8    z!!r3r'r(r)c$t|||S)a6 Returns a global transaction identifier (xid) that can be used with the Two-Phase Commit (TPC) functions. The ``xid`` contains a format identifier, a global transaction identifier, and a branch identifier. There are no checks performed at the Python level. The values are checked by ODPI-C when they are passed to the relevant functions. .. When this functionality is also supported in the thin driver the checks will be performed at the Python level as well. The ``format_id`` parameter should be a positive 32-bit integer. This value identifies the format of the ``global_transaction_id`` and ``branch_qualifier`` parameters and the value is determined by the Transaction Manager (TM), if one is in use. The ``global_transaction_id`` and ``branch_qualifier`` parameters should be of type bytes or string. If a value of type string is passed, then this value will be UTF-8 encoded to bytes. The values cannot exceed 64 bytes in length. )r&)r0r'r(r)s r1rDzBaseConnection.xid*s6935EFFFr3r?NNrXF)NNNNNNNr-rXF)E__name__ __module__ __qualname__r:r2r>rCr&rIpropertyrrMsetterboolrVrrbytesr_r`rerkrnrrrwr|rrrrr<rrrrrrrrrrrrrrlistrrrrrrrrrrrrrrrrrr;rr _ErrorrrDr3r1r+r+As E===8888%s%t%%%%7777X7 ]%C%D%%%]%%D%%%X%&&&&&& 7;!& , ,  sEz!23, ,  ,  , , , , \-c---X-.+#+$++++B3BBBXB0s0t0000;C;;;X;****** / / / /X /-C-D----*3***X*((((X(5c555X5 [###$###[# , ,# , , , ,SX%)#$($("&%)!!%sH 456!c]!} ! SM ! SM !3-!TN! !!!!L<@,( /3 ,(,(,(,(u\3%678,( l+ ,( uj ! ,(,(,(,(\ ,8 , , ,X ,-x-D----%E#t),%%%X%!& 4 4 c5j)4 4  4  4 4 4 4 l $S $ $ $X $+C+++X+ -c---X-+C+++X+  0s 0 0 0X 0.3.4....SX" ZZdX8888X8#####X#X"v}d23"""X"<GG %UCZ0G s + G GGGGGGr3r+) metaclassc(:eZdZ dfddddeededdeeddffdZd Zd Zd Z dgd Z dZ de de de de fdZde de de de ddf dZ dhde dededdfdZede fdZejde ddfdZdededdfdZdid Zdid!Z dfd"ed#eeeefdefd$Zdgd%edefd&Zd'd(d)ed*ed+eed#e d,e ddf d-Z djddd.d/ed0eeee!e"fd1ee d2eed3ee de#f d4Z$ djddd.d/ed0eeee!e"fd5ee d2eed3ee de%e#f d6Z&de'fd7Z(d8ede)fd9Z*ede fd:Z+ede fd;Z,did<Z-defd=Z.did>Z/dkd@e ddfdAZ0 dldBedCedDeeddfdEZ1e2j3e2j4dd?e2j5d?e2j6de2j7d?e2j8dd f de2j7d?e2j8d dFdGe dHe dIee9dJe dKe dLe dMe dNeedOe dPe dQe d8eedRedSeedTe dUe dVe dWede:f&dXZ;didYZd[e dJe ddfd\Z? dmdZee>d]eddfd^Z@de2jAfdZee>d[e ddfd_ZBdZe>ddfd`ZCdfdZee>defdaZDdefdbZEdfdZee>ddfdcZFdde:ddfdeZGxZHS)n ConnectionN)rparamsr<rpool_module.ConnectionPoolrr?c t||_tj5}|j}|t j}nMt|tstj tj n|j }||||}|d}n||j }|rr|j|j!tj tjdd|||} nVt+j||} | |n+t1j||} | ||| |_ | jr?|=|j6t9|jr"|||jd| _ddddS#1swxYwYdS)zH Constructor for creating a connection to the database. Nshardingthick)feature driver_typeF)superr2_poolr get_managerrr ConnectParamsImplrFrr rAERR_INVALID_CONNECT_PARAMSr:copy process_args _verify_open shardingkeysupershardingkeyERR_FEATURE_NOT_SUPPORTEDacquirer ThinConnImplconnectr ThickConnImplinvoke_session_callbacksession_callbackcallabler) r0r<rrkwargsmode_mgrr params_impl pool_implrr8s r1r2zConnection.__init__Js1   $ & &0 5(=D~'9;;  66 2!&"CDDDD$l//11 **3==C| !!### J  5+7"3?%8 *$+ #$,,[99DD$1#{CCDLL----!/[AA [)444DJ, 5$)5T2336%%dKO<<>>>>r3cV||dS)a Closes the connection now and makes it unusable for further operations. An Error exception will be raised if any operation is attempted with this connection after this method is completed successfully. All open cursors and LOBs created by the connection will be closed and will also no longer be usable. Internally, references to the connection are held by cursor objects, LOB objects, subscription objects, etc. Once all of these references are released, the connection itself will be closed automatically. Either control references to these related objects carefully or explicitly close connections in order to ensure sufficient resources are available. NrCr4r/s r1rAzConnection.closes'     r3c`||jdS)zC Commits any pending transactions to the database. NrCr:commitr/s r1rbzConnection.commitrlr3lob_typerc||tttfvrd}t ||j|}tj|}|r| ||S)aa Creates and returns a new temporary LOB object of the specified type. The ``lob_type`` parameter should be one of :data:`oracledb.DB_TYPE_CLOB`, :data:`oracledb.DB_TYPE_BLOB`, or :data:`oracledb.DB_TYPE_NCLOB`. If data is supplied, it will be written to the temporary LOB before it is returned. aparameter should be one of oracledb.DB_TYPE_CLOB, oracledb.DB_TYPE_BLOB or oracledb.DB_TYPE_NCLOB) rCrrrrGr:create_temp_lob_implr rwriter0rcrrHrlobs r1 createlobzConnection.createlob s    L-F F FB G$$ $z..x88nT""   IIdOOO r3 scrollablecJ|t||S)zV Returns a new :ref:`cursor object ` using the connection. )rCrr0rks r1cursorzConnection.cursor$s&    dJ'''r3 batch_size schema_name table_name column_namesrqcj||j|||||dSa% Load data into Oracle Database using the Direct Path Load interface. It is available only in python-oracledb Thin mode. The ``data`` parameter can be a list of sequences, a DataFrame, or a third-party DataFrame instance that supports the Apache Arrow PyCapsule Interface. The ``batch_size`` parameter is used to split large data sets into smaller pieces for sending to the database. It is the number of records in each batch. This parameter can be used to tune performance. NrCr:direct_path_loadr0rrrsrtrrqs r1rxzConnection.direct_path_load+sE*     ## \4     r3fetch_decimalsrequested_schema statement parameters arraysizer{r|c|}d|j_|tj||j_|||_|j|_|||||j |S)a Fetches all rows of the SQL query ``statement``, returning them in a :ref:`DataFrame ` object. An empty DataFrame is returned if there are no rows available. The ``parameters`` parameter can be a list of tuples, where each tuple item maps to one :ref:`bind variable placeholder ` in ``statement``. It can also be a list of dictionaries, where the keys match the bind variable placeholder names in ``statement``. The ``arraysize`` parameter can be specified to tune performance of fetching data across the network. It defaults to :attr:`oracledb.defaults.arraysize `. Internally, the ``fetch_df_all()``'s :attr:`Cursor.prefetchrows` size is always set to the value of the explicit or default ``arraysize`` parameter value. The ``fetch_decimals`` parameter specifies whether to return decimal values when fetching columns of type ``NUMBER`` that are capable of being represented in Apache Arrow Decimal128 format. The default value is :data:`oracledb.defaults.fetch_decimals `. The ``requested_schema`` parameter specifies an object that implements the Apache Arrow PyCapsule schema interface. The DataFrame returned by ``fetch_df_all()`` will have the data types and names of the schema. Any LOB fetched must be less than 1 GB. TNr{ rnr:fetching_arrowrfrom_arrow_schema schema_implr prefetchrowsexecute fetch_df_allr0r}r~rr{r|rns r1rzConnection.fetch_df_allEsH&* #  ''6'H ((FL $  (F $.  )    |((000r3sizec#hK|}d|j_|tj||j_|||_|j|_||||||j |VdS|j ||Ed{VdS)a This returns an iterator yielding the next ``size`` rows of the SQL query ``statement`` in each iteration as a :ref:`DataFrame ` object. An empty DataFrame is returned if there are no rows available. The ``parameters`` parameter can be a list of tuples, where each tuple item maps to one :ref:`bind variable placeholder ` in ``statement``. It can also be a list of dictionaries, where the keys match the bind variable placeholder names in ``statement``. The ``size`` parameter controls the number of records fetched in each batch. It defaults to :attr:`oracledb.defaults.arraysize `. Internally, the ``fetch_df_batches()``'s :attr:`Cursor.arraysize` and :attr:`Cursor.prefetchrows` sizes are always set to the value of the explicit or default ``size`` parameter value. The ``fetch_decimals`` parameter specifies whether to return decimal values when fetching columns of type ``NUMBER`` that are capable of being represented in Apache Arrow Decimal128 format. The default value is :data:`oracledb.defaults.fetch_decimals `. The ``requested_schema`` parameter specifies an object that implements the Apache Arrow PyCapsule schema interface. The DataFrame returned by ``fetch_df_all()`` will have the data types and names of the schema. Any LOB fetched must be less than 1 GB. TNrrp rnr:rrrrrrrrfetch_df_batches)r0r}r~rr{r|rns r1rzConnection.fetch_df_batchesysL&* #  ''6'H ((FL $  #F $.  )    <,++F33 3 3 3 3 3|44V4MM M M M M M M M M Mr3c||j|}tj||S)a Returns a SodaDatabase object for Simple Oracle Document Access (SODA). All SODA operations are performed either on the returned SodaDatabase object or from objects created by the returned SodaDatabase object. See `here `__ for additional information on SODA. )rCr:create_soda_database_implr#r)r0db_impls r1getSodaDatabasezConnection.getSodaDatabases>    *66t<<&tW555r3rc||j||}tj|S) Returns a type object given its name. This can then be used to create objects which can be bound to cursors created by this connection. rCr:get_typerrr0r obj_type_impls r1gettypezConnection.gettypes>     ++D$77 &}555r3c\||jS)aP This read-only attribute returns the Oracle Call Interface (OCI) service context handle for the connection. It is primarily provided to facilitate testing the creation of a connection using the OCI service context handle. This property is only relevant to python-oracledb's thick mode. )rCr: get_handler/s r1handlezConnection.handles*    z$$&&&r3cdS)z? Deprecated. Use the constant value 4 instead. rr/s r1maxBytesPerCharacterzConnection.maxBytesPerCharacters qr3c`||jdS)aP Pings the database to verify if the connection is valid. An exception is thrown if it is not, in which case the connection should not be used by the application and a new connection should be established instead. This function performs a :ref:`round-trip ` to the database, so it should not be used unnecessarily. Note connection pools will perform the same health check automatically, based on configuration settings. See :ref:`poolhealth`. Also, see :meth:`is_healthy()` for a lightweight alternative. NrCr:pingr/s r1rzConnection.pings.     r3c*|S)z Prepares the distributed (global) transaction for commit. Returns a boolean indicating if a transaction was actually prepared in order to avoid the error ``ORA-24756 (transaction does not exist)``. ) tpc_preparer/s r1preparezConnection.prepares !!!r3c`||jdS)z6 Rolls back any pending transactions. NrCr:rollbackr/s r1rzConnection.rollbacks0     r3rmodecb||j|dS)a  Shuts down the database. In order to do this the connection must be connected as :data:`~oracledb.SYSDBA` or :data:`~oracledb.SYSOPER`. Two calls must be made unless the mode specified is :data:`~oracledb.DBSHUTDOWN_ABORT`. N)rCr:shutdown)r0rs r1rzConnection.shutdowns2     D!!!!!r3forcerestrictpfilecf||j|||dS)a Starts up the database. This is equivalent to the SQL*Plus command ``startup nomount``. The connection must be connected as :data:`~oracledb.SYSDBA` or :data:`~oracledb.SYSOPER` with the :data:`~oracledb.PRELIM_AUTH` option specified for this to work. The ``pfile`` parameter, if specified, is expected to be a string identifying the location of the parameter file (PFILE) which will be used instead of the stored parameter file (SPFILE). N)rCr:startup)r0rrrs r1rzConnection.startups6     5(E22222r3) ipAddress groupingClass groupingValue groupingTypeclientInitiated namespaceprotocolcallbackrZ operationsportqos ip_addressgrouping_classgrouping_value grouping_typeclient_initiatedrrrrrc||%|!tjtjdd|}|tjkr3| tjkr!tjtjdd|} |dkr)| dkr!tjtjdd |} |tjkr3| tjkr!tjtjd d |} |r%| r!tjtjd d |} |j|||| ||||||| | | | }tj |}| ||j|S)a Returns a new subscription object that receives notifications for events that take place in the database that match the given parameters. The ``namespace`` parameter specifies the namespace the subscription uses. It can be one of :data:`oracledb.SUBSCR_NAMESPACE_DBCHANGE` or :data:`oracledb.SUBSCR_NAMESPACE_AQ`. The ``protocol`` parameter specifies the protocol to use when notifications are sent. Currently the only valid value is :data:`oracledb.SUBSCR_PROTO_OCI`. The ``callback`` is expected to be a callable that accepts a single parameter. A :ref:`message object ` is passed to this callback whenever a notification is received. The ``timeout`` value specifies that the subscription expires after the given time in seconds. The default value of *0* indicates that the subscription never expires. The ``operations`` parameter enables filtering of the messages that are sent (insert, update, delete). The default value will send notifications for all operations. This parameter is only used when the namespace is set to :data:`oracledb.SUBSCR_NAMESPACE_DBCHANGE`. The ``port`` parameter specifies the listening port for callback notifications from the database server. If not specified, an unused port will be selected by the Oracle Client libraries. The ``qos`` parameter specifies quality of service options. It should be one or more of the following flags, OR'ed together: :data:`oracledb.SUBSCR_QOS_RELIABLE`, :data:`oracledb.SUBSCR_QOS_DEREG_NFY`, :data:`oracledb.SUBSCR_QOS_ROWIDS`, :data:`oracledb.SUBSCR_QOS_QUERY`, :data:`oracledb.SUBSCR_QOS_BEST_EFFORT`. The ``ip_address`` parameter specifies the IP address (*IPv4* or *IPv6*) in standard string notation to bind for callback notifications from the database server. If not specified, the client IP address will be determined by the Oracle Client libraries. The ``grouping_class`` parameter specifies what type of grouping of notifications should take place. Currently, if set, this value can only be set to the value :data:`oracledb.SUBSCR_GROUPING_CLASS_TIME`, which will group notifications by the number of seconds specified in the ``grouping_value`` parameter. The ``grouping_type`` parameter should be one of the values :data:`oracledb.SUBSCR_GROUPING_TYPE_SUMMARY` (the default) or :data:`oracledb.SUBSCR_GROUPING_TYPE_LAST`. The ``name`` parameter is used to identify the subscription and is specific to the selected namespace. If the namespace parameter is :data:`oracledb.SUBSCR_NAMESPACE_DBCHANGE` then the name is optional and can be any value. If the namespace parameter is :data:`oracledb.SUBSCR_NAMESPACE_AQ`, however, the name must be in the format '' for single consumer queues and ':' for multiple consumer queues, and identifies the queue that will be monitored for messages. The queue name may include the schema, if needed. The ``client_initiated`` parameter is used to determine if client initiated connections or server initiated connections (the default) will be established. Client initiated connections are only available in Oracle Client 19.4 and Oracle Database 19.4 and higher. For consistency and compliance with the PEP 8 naming style, the parameter ``ipAddress`` was renamed to ``ip_address``, the parameter ``groupingClass`` was renamed to ``grouping_class``, the parameter ``groupingValue`` was renamed to ``grouping_value``, the parameter ``groupingType`` was renamed to ``grouping_type`` and the parameter ``clientInitiated`` was renamed to ``client_initiated``. The old names will continue to work as keyword parameters for a period of time. Nrrrrrrrrrrrr) rCr rAroracledbSUBSCR_GROUPING_CLASS_NONESUBSCR_GROUPING_TYPE_SUMMARYr:create_subscr_implr$r subscribe)r0rrrrZrrrrrrrrrrrrrrrsubscrs r1rzConnection.subscribes|     %!3$/) #J H? ? ?!DDD!3$3- +N A  ""!3$3- +N 8@ @ @ EEE!3$2, )M  / !3$5/ / z,,                 (.. vtz*** r3c`||jdS)a Suspends the currently active sessionless transaction immediately. This detaches the transaction from the connection, allowing it to be resumed later with the transaction identifier that was specified during creation of the sessionless transaction. The ``timeout`` previously passed to :meth:`begin_sessionless_transaction()` determines how long the transaction can stay suspended before it is automatically rolled back. NrCr:suspend_sessionless_transactionr/s r1rz*Connection.suspend_sessionless_transactions0     2244444r3rDflagsc,||||tjtjtjtjfvrtjtj |j |||dS)a Begins a Two-Phase Commit (TPC) on a global transaction using the specified transaction identifier (xid). The ``xid`` parameter should be an object returned by the :meth:`xid()` method. The ``flags`` parameter is one of the constants :data:`oracledb.TPC_BEGIN_JOIN`, :data:`oracledb.TPC_BEGIN_NEW`, :data:`oracledb.TPC_BEGIN_PROMOTE`, or :data:`oracledb.TPC_BEGIN_RESUME`. The default is :data:`oracledb.TPC_BEGIN_NEW`. The ``timeout`` parameter is the number of seconds to wait for a transaction to become available for resumption when :data:`~oracledb.TPC_BEGIN_RESUME` is specified in the ``flags`` parameter. When :data:`~oracledb.TPC_BEGIN_NEW` is specified in the ``flags`` parameter, the ``timeout`` parameter indicates the number of seconds the transaction can be inactive before it is automatically terminated by the system. A transaction is inactive between the time it is detached with :meth:`tpc_end()` and the time it is resumed with :meth:`tpc_begin()`.The default is *0* seconds. N rCrIr TPC_BEGIN_NEWTPC_BEGIN_JOINTPC_BEGIN_RESUMETPC_BEGIN_PROMOTEr rAERR_INVALID_TPC_BEGIN_FLAGSr:rQr0rDrrZs r1rQzConnection.tpc_begins4        "  #  %  &     f@ A A A S%11111r3 one_phasec|||||j||dS)a Commits a global transaction. When called with no arguments, this method commits a transaction previously prepared with :meth:`tpc_begin()` and optionally prepared with :meth:`tpc_prepare()`. If :meth:`tpc_prepare()` is not called, a single phase commit is performed. A transaction manager may choose to do this if only a single resource is participating in the global transaction. If an ``xid`` parameter is passed, then an object should be returned by the :meth:`xid()` function. This form should be called outside of a transaction and is intended for use in recovery. The ``one_phase`` parameter is a boolean identifying whether to perform a one-phase or two-phase commit. If ``one_phase`` parameter is *True*, a single-phase commit is performed. The default value is *False*. This parameter is only examined if a value is provided for the ``xid`` parameter. Otherwise, the driver already knows whether :meth:`tpc_prepare()` was called for the transaction and whether a one-phase or two-phase commit is required. NrCrIr: tpc_commitr0rDrs r1rzConnection.tpc_commitsM.    ?   S ! ! ! c9-----r3c|||||tjtjfvrt jt j|j ||dS)a Ends or suspends work on a global transaction. This function is only intended for use by transaction managers. If an ``xid`` parameter is passed, then an object should be returned by the :meth:`xid()` function. If no xid parameter is passed, then the transaction identifier used by the previous :meth:`tpc_begin()` is used. The ``flags`` parameter is one of the constants :data:`oracledb.TPC_END_NORMAL` or :data:`oracledb.TPC_END_SUSPEND`. The default is :data:`oracledb.TPC_END_NORMAL`. If the flag is :data:`oracledb.TPC_END_SUSPEND` then the transaction may be resumed later by calling :meth:`tpc_begin()` with the flag :data:`oracledb.TPC_BEGIN_RESUME`. N rCrIrTPC_END_NORMALTPC_END_SUSPENDr rAERR_INVALID_TPC_END_FLAGSr:tpc_endr0rDrs r1rzConnection.tpc_endsw(    ?   S ! ! ! 0(2JK K K  f> ? ? ? 3&&&&&r3c||||j|dSa. Causes the database to forget a heuristically completed TPC transaction. This function is only intended to be called by transaction managers. The ``xid`` parameter is mandatory and should be an object should be returned by the :meth:`xid()` function. NrCrIr: tpc_forgetr0rDs r1rzConnection.tpc_forgetsF      c"""""r3c|||||j|S) Prepares a two-phase transaction for commit. After this function is called, no further activity should take place on this connection until either :meth:`tpc_commit()` or :meth:`tpc_rollback()` have been called. Returns a boolean indicating whether a commit is needed or not. If you attempt to commit when not needed, then it results in the error ``ORA-24756: transaction does not exist``. If an ``xid`` parameter is passed, then an object should be returned by the :meth:`xid()` function. If an ``xid`` parameter is not passed, then the transaction identifier used by the previous :meth:`tpc_begin()` is used. rCrIr:rrs r1rzConnection.tpc_prepare+sE    ?   S ! ! !z%%c***r3c|5}|dt|_|cdddS#1swxYwYdS)a Returns a list of pending transaction identifiers that require recovery. Objects of type ``Xid`` (as returned by the :meth:`xid()` function) are returned and these can be passed to :meth:`tpc_commit()` or :meth:`tpc_rollback()` as needed. This function queries the DBA_PENDING_TRANSACTIONS view and requires "SELECT" privilege on that view. select formatid, globalid, branchid from dba_pending_transactionsNrnrr& rowfactoryfetchallr0rns r1 tpc_recoverzConnection.tpc_recover?s[[]] %f NN5   !$F ??$$ % % % % % % % % % % % % % % % % % %s5AAAc|||||j|dS)a If an ``xid`` parameter is not passed, then it rolls back the transaction that was previously started with :meth:`tpc_begin()`. If an ``xid`` parameter is passed, then an object should be returned by :meth:`xid()` and the specified transaction is rolled back. This form should be called outside of a transaction and is intended for use in recovery. NrCrIr: tpc_rollbackrs r1rzConnection.tpc_rollbackUsK    ?   S ! ! ! $$$$$r3rc|t|tstd|j|jdS)a5 Unsubscribe from events in the database that were originally subscribed to using :meth:`subscribe()`. The connection used to unsubscribe should be the same one used to create the subscription, or should access the same database and be connected as the same user name. zexpecting subscriptionN)rCrFr$rGr: unsubscribe)r0rs r1rzConnection.unsubscribeesU    &,// 6455 5   ,,,,,r3r-F)rMrNrNrNN)r)FFNNF)Irrr rrrr2r5r7r<r4rr_rrJrLrRr rTr r]rArbrrr r rjr rrnrrxtupledictrrrrr#rrrrrrrrrrrSUBSCR_NAMESPACE_DBCHANGESUBSCR_PROTO_CALLBACK OPCODE_ALLOPSSUBSCR_QOS_DEFAULTrrrr$rrrr&rQrrrrrrrr __classcell__r8s@r1rrHs"@58<*. @5@5@5 c]@534 @5 ' @5 @5@5@5@5@5@5D%%%    ,,, J J*- J:= J  J J J J J J*- J:= JFI J  J J J J  KKKK K  KKKK&!S!!!X! ++++++?3?c?d????&EI&.uS%Z/@&A 2(((&(((($     3i          ::>#' 21 *.*.21212121U4#45621C= 21 ! 21#3-21 21212121n:>" 7N *.*.7N7N7N7NU4#4567Nsm 7N ! 7N#3-7N ) 7N7N7N7Nr 6 6 6 6 66C6L6666 ' ' ' 'X 'cX """"""""S"""""# 3333} 3  3333*"; 6'+"0.$(&A%B"!&Y $(%@$A %)YYYYY8$ Y  Y  YYYSMYYYYsmYY C=!Y"#Y$%Y&'Y()Y* +YYYYv 5 5 5 5&.%;A#2#2#2"#2FI#2 #2#2#2#2L.connect}s1  !!       *j11 =  f; < < <   6  / &%      !*044Z@@D|!1  J +,% % LGG$$ $zFcVFFvFFFr3r-) functoolswrapsrrrrr)rr(s` r1_connection_factoryrrs_Q!$G8<$('1*. $G$G$G c]$G34$GSM $G $ $G ' $G $G$G$G$G$G$GL Nr3)9rrrruserrpassword newpasswordwallet_password access_tokenhostrr https_proxyhttps_proxy_portrrsid server_typecclasspurity expire_time retry_count retry_delaytcp_connect_timeoutssl_server_dn_matchssl_server_cert_dnwallet_locationevents externalauthr disable_oobrrr matchanytag config_dir appcontextr#r$ debug_jdwpconnection_id_prefix ssl_contextr pool_boundaryuse_tcp_fast_open ssl_versionprogrammachineterminalosuser driver_nameuse_snithick_mode_dsn_passthroughextra_auth_params pool_namerr<rrrrrrrrrrrrrrrrrrrrrrrr r!r"r#r$r%r&r'rr(rrrr)r*r+r#r$r,r-r.rr/r0r1r2r3r4r5r6r7r8r9r:rc9dS)a84 Factory function which creates a connection to the database and returns it. The ``dsn`` parameter (data source name) can be a string in the format user/password@connect_string or can simply be the connect string (in which case authentication credentials such as the username and password need to be specified separately). See the documentation on connection strings for more information. The ``pool`` parameter is expected to be a pool object. This parameter was deprecated in python-oracledb 3.0.0. Use :meth:`ConnectionPool.acquire()` instead since the use of this parameter is the equivalent of calling this method. The ``conn_class`` parameter is expected to be Connection or a subclass of Connection. The ``params`` parameter is expected to be of type ConnectParams and contains connection parameters that will be used when establishing the connection. See the documentation on ConnectParams for more information. If this parameter is not specified, the additional keyword parameters will be used to create an instance of ConnectParams. If both the ``params`` parameter and additional keyword parameters are specified, the values in the keyword parameters have precedence. Note that if a ``dsn`` is also supplied, then in python-oracledb Thin mode, the values of the parameters specified (if any) within the ``dsn`` will override the values passed as additional keyword parameters, which themselves override the values set in the ``params`` parameter object. The following parameters are all optional. A brief description of each parameter follows: - ``user``: the name of the database user to connect to (default: None) - ``proxy_user``: the name of the proxy user to connect to. If this value is not specified, it will be parsed out of user if user is in the form "user[proxy_user]" (default: None) - ``password``: the password for the database user (default: None) - ``newpassword``: a new password for the database user. The new password will take effect immediately upon a successful connection to the database (default: None) - ``wallet_password``: the password to use to decrypt the wallet, if it is encrypted. This is not the database password. For Oracle Autonomous Database this is the password created when downloading the wallet. This value is only used in python-oracledb Thin mode. (default: None) - ``access_token``: a string, or a 2-tuple, or a callable. If it is a string, it specifies an Entra ID OAuth2 token used for Open Authorization (OAuth 2.0) token based authentication. If it is a 2-tuple, it specifies the token and private key strings used for Oracle Cloud Infrastructure (OCI) Identity and Access Management (IAM) token based authentication. If it is a callable, it returns either a string or a 2-tuple used for OAuth 2.0 or OCI IAM token based authentication and is useful when the pool needs to expand and create new connections but the current authentication token has expired (default: None) - ``host``: the hostname or IP address of the machine hosting the database or the database listener (default: None) - ``port``: the port number on which the database listener is listening (default: 1521) - ``protocol``: one of the strings "tcp" or "tcps" indicating whether to use unencrypted network traffic or encrypted network traffic (TLS) (default: "tcp") - ``https_proxy``: the hostname or IP address of a proxy host to use for tunneling secure connections (default: None) - ``https_proxy_port``: the port on which to communicate with the proxy host (default: 0) - ``service_name``: the service name of the database (default: None) - ``instance_name``: the instance name of the database (default: None) - ``sid``: the system identifier (SID) of the database. Note using a service_name instead is recommended (default: None) - ``server_type``: the type of server connection that should be established. If specified, it should be one of strings "dedicated", "shared" or "pooled" (default: None) - ``cclass``: the connection class to use for Database Resident Connection Pooling (DRCP) (default: None) - ``purity``: the connection purity to use for Database Resident Connection Pooling (DRCP) (default: :attr:`oracledb.PURITY_DEFAULT`) - ``expire_time``: the number of minutes between the sending of keepalive probes. If this parameter is set to a value greater than zero it enables keepalive (default: 0) - ``retry_count``: the number of times that initial connection establishment should be retried before the connection attempt is terminated (default: 0) - ``retry_delay``: the number of seconds to wait before retrying to establish a connection (default: 1) - ``tcp_connect_timeout``: a float indicating the maximum number of seconds to wait when establishing a connection to the database host (default: 20.0) - ``ssl_server_dn_match``: a boolean indicating whether the server certificate distinguished name (DN) should be matched in addition to the regular certificate verification that is performed. Note that if the ssl_server_cert_dn parameter is not privided, host name matching is performed instead (default: True) - ``ssl_server_cert_dn``: the distinguished name (DN) which should be matched with the server. This value is ignored if the ssl_server_dn_match parameter is not set to the value True. If specified this value is used for any verfication. Otherwise the hostname will be used (default: None) - ``wallet_location``: the directory where the wallet can be found. In python-oracledb Thin mode this must be the directory containing the PEM- encoded wallet file ewallet.pem. In python-oracledb Thick mode this must be the directory containing the file cwallet.sso (default: None) - ``events``: a boolean specifying whether events mode should be enabled. This value is only used in python-oracledb Thick mode and is needed for continuous query notification and high availability event notifications (default: False) - ``externalauth``: a boolean indicating whether to use external authentication (default: False) - ``mode``: the authorization mode to use. One of the constants :data:`oracledb.AUTH_MODE_DEFAULT`, :data:`oracledb.AUTH_MODE_PRELIM`, :data:`oracledb.AUTH_MODE_SYSASM`, :data:`oracledb.AUTH_MODE_SYSBKP`, :data:`oracledb.AUTH_MODE_SYSDBA`, :data:`oracledb.AUTH_MODE_SYSDGD`, :data:`oracledb.AUTH_MODE_SYSKMT`, :data:`oracledb.AUTH_MODE_SYSOPER`, or :data:`oracledb.AUTH_MODE_SYSRAC` (default: :attr:`oracledb.AUTH_MODE_DEFAULT`) - ``disable_oob``: a boolean indicating whether out-of-band breaks should be disabled. This value is only used in python-oracledb Thin mode. It has no effect on Windows which does not support this functionality (default: False) - ``stmtcachesize``: the size of the statement cache (default: :attr:`oracledb.defaults.stmtcachesize `) - ``edition``: edition to use for the connection. This parameter cannot be used simultaneously with the cclass parameter (default: None) - ``tag``: identifies the type of connection that should be returned from a pool. This value is only used in python-oracledb Thick mode (default: None) - ``matchanytag``: a boolean specifying whether any tag can be used when acquiring a connection from the pool. This value is only used in python- oracledb Thick mode (default: False) - ``config_dir``: a directory in which the optional tnsnames.ora configuration file is located. This value is only used in python-oracledb Thin mode. For python-oracledb Thick mode, it is used if :attr:`oracledb.defaults.thick_mode_dsn_passthrough ` is *False*. Otherwise in Thick mode use the ``config_dir`` parameter of :meth:`oracledb.init_oracle_client()` (default: :attr:`oracledb.defaults.config_dir `) - ``appcontext``: application context used by the connection. It should be a list of 3-tuples (namespace, name, value) and each entry in the tuple should be a string (default: None) - ``shardingkey``: a list of strings, numbers, bytes or dates that identify the database shard to connect to. This value is only used in python- oracledb Thick mode (default: None) - ``supershardingkey``: a list of strings, numbers, bytes or dates that identify the database shard to connect to. This value is only used in python-oracledb Thick mode (default: None) - ``debug_jdwp``: a string with the format "host=;port=" that specifies the host and port of the PL/SQL debugger. This value is only used in python-oracledb Thin mode. For python-oracledb Thick mode set the ORA_DEBUG_JDWP environment variable (default: None) - ``connection_id_prefix``: an application specific prefix that is added to the connection identifier used for tracing (default: None) - ``ssl_context``: an SSLContext object used for connecting to the database using TLS. This SSL context will be modified to include the private key or any certificates found in a separately supplied wallet. This parameter should only be specified if the default SSLContext object cannot be used (default: None) - ``sdu``: the requested size of the Session Data Unit (SDU), in bytes. The value tunes internal buffers used for communication to the database. Bigger values can increase throughput for large queries or bulk data loads, but at the cost of higher memory use. The SDU size that will actually be used is negotiated down to the lower of this value and the database network SDU configuration value (default: 8192) - ``pool_boundary``: one of the values "statement" or "transaction" indicating when pooled DRCP connections can be returned to the pool. This requires the use of DRCP with Oracle Database 23.4 or higher (default: None) - ``use_tcp_fast_open``: a boolean indicating whether to use TCP fast open. This is an Oracle Autonomous Database Serverless (ADB-S) specific property for clients connecting from within OCI Cloud network. Please refer to the ADB-S documentation for more information (default: False) - ``ssl_version``: one of the values ssl.TLSVersion.TLSv1_2 or ssl.TLSVersion.TLSv1_3 indicating which TLS version to use (default: None) - ``program``: a string recorded by Oracle Database as the program from which the connection originates (default: :attr:`oracledb.defaults.program `) - ``machine``: a string recorded by Oracle Database as the name of the machine from which the connection originates (default: :attr:`oracledb.defaults.machine `) - ``terminal``: a string recorded by Oracle Database as the terminal identifier from which the connection originates (default: :attr:`oracledb.defaults.terminal `) - ``osuser``: a string recorded by Oracle Database as the operating system user who originated the connection (default: :attr:`oracledb.defaults.osuser `) - ``driver_name``: a string recorded by Oracle Database as the name of the driver which originated the connection (default: :attr:`oracledb.defaults.driver_name `) - ``use_sni``: a boolean indicating whether to use the TLS SNI extension to bypass the second TLS neogiation that would otherwise be required (default: False) - ``thick_mode_dsn_passthrough``: a boolean indicating whether to pass the connect string to the Oracle Client libraries unchanged without parsing by the driver. Setting this to False makes python-oracledb Thick and Thin mode applications behave similarly regarding connection string parameter handling and locating any optional tnsnames.ora configuration file (default: :attr:`oracledb.defaults.thick_mode_dsn_passthrough `) - ``extra_auth_params``: a dictionary containing configuration parameters necessary for Oracle Database authentication using plugins, such as the Azure and OCI cloud-native authentication plugins (default: None) - ``pool_name``: the name of the DRCP pool when using multi-pool DRCP with Oracle Database 23.4, or higher (default: None) - ``handle``: an integer representing a pointer to a valid service context handle. This value is only used in python-oracledb Thick mode. It should be used with extreme caution (default: 0) Nr:r<rrrrrrrrrrrrrrrrrrrrrrr r!r"r#r$r%r&r'rr(rrrr)r*r+r#r$r,r-r.rr/r0r1r2r3r4r5r6r7r8r9r:rs: r1r(r( N  Dr3ceZdZdedejdededdf fd ZdZ d Z d Z dPd Z d Z dZdededefdZ dQdeeeefdededefdZ dRdededeeeefdeedef dZ dRdedeeeefdeedefdZdededdfdZdSdZdSdZ dTd ed!eeeefdefd"Z dPd#ede!fd$Z" dTd%edeeeeefddfd&Z#d%eedfdeddfd'Z$ dUddd(d%edeeeeefd)eed*ee%d+eed,eedefd-Z&d.d/d0ed1ed2eed!ed3eddf d4Z' dRddd5d%edeeeeefd)eed,eed6eede(f d7Z) dRddd5d%edeeeeefd8eed,eed6eede*e(f d9Z+ dUddd(d%edeeeeefd:eed*ee%d+eed,eedefd;Z, dRddd(d%edeeeeefd*ee%d+eed,eedef d<Z-dede.fd=Z/dSd>Z0 dVdeeefdededefd?Z1dSd@Z2 dPdAe3dBedee4fdCZ5dSdDZ6e7j8dEfdFe9dGededdfdHZ: dWdFee9dIeddfdJZ;de7j<fdFee9dGeddfdKZ=dFe9ddfdLZ>dTdFee9defdMZ?defdNZ@dTdFee9ddfdOZAxZBS)XAsyncConnectionr<rrr-r?Nct||_||||||_dS)zV Constructor for creating an asynchronous connection to the database. N)rr2r_connect_connect_coroutine)r0r<rrr-r8s r1r2zAsyncConnection.__init__sB  "&--T66"J"Jr3cF|j}d|_|Sr-)rB __await__)r0 coroutines r1rDzAsyncConnection.__await__!s$+ "&""$$$r3c\K|j|jd{Vn||S)zr The entry point for the asynchronous connection as a context manager. It returns itself. N)rBrCr/s r1 __aenter__zAsyncConnection.__aenter__&sF  " .) ) ) ) ) ) ) ) )  " " $ $ $ r3cPK|j|d{VdSdS)z The exit point for the asynchronous connection as a context manager. This will close the connection and roll back any uncommitted transaction. Nr3)r0exc_infos r1 __aexit__zAsyncConnection.__aexit__1s> : !++--          " !r3FcK|j0|jj}|!||j|d{Vn |j|d{Vd|_dSr>r?rBs r1r4zAsyncConnection._close:s~ : ! (I$11$*fEEEEEEEEE*""6** * * * * * * * r3cKdtj_|tj}nMt |t stjtj n|j }| ||d}|d}nFt |tjsd}t|||j }|||d{V}n0t%j||}||d{V||_ |jrE|C|j#577KKFM22 .  f? @ @ @ @ ,++--K&&sF&>> <IID+"ABB #J G$$ $       I  "**;77777777DD.sK@@D,,{++ + + + + + + +   ( 1 %1.//2''ko>> > > > > > > >+0D ( r3c,tj||SrD)rrrEs r1rzAsyncConnection._create_queue|s $T4000r3r~keyword_parametersc||r"|rtjtj|S|@t |t t tfstjtj|S)z Verifies that the connection can be used to execute Verifies that the connection is connected to the database. If it is not, an exception is raised. ) rCr rAERR_ARGS_AND_KEYWORD_ARGSrFrrr!ERR_WRONG_EXECUTE_PARAMETERS_TYPE)r0r~rSs r1_verify_can_executez#AsyncConnection._verify_can_executes     H D!&"BCCC% %  #J ud+- - #  fF G G Gr3rXrYrZr[cK|t|}t|tr|dkrt d|j|||d{V|S)a Begins a new sessionless transaction. This method returns the transaction identifier specified by the user or generated by python-oracledb. The ``transaction_id`` parameter should be of type string or bytes. If specified, it represents a unique identifier for the transaction. If a string is passed, then it will be UTF-8 encoded to bytes. If this value is not specified, then python-oracledb generates a a random `universally-unique identifier (UUID) `__ value when this function is called. An example is "36b8f84d-df4e-4d49-b662-bcde71a8764f". The user-chosen value cannot exceed 64 bytes in length. The ``timeout`` parameter is the number of seconds that this transaction can stay suspended when :meth:`suspend_sessionless_transaction()` is later called, or if the transaction is automatically suspended when the ``suspend_on_success`` parameter is set to to *True* in :meth:`AsyncCursor.execute()` or :meth:`AsyncCursor.executemany()`. The default value is *60* seconds. If a transaction is not resumed within this specified duration, the transaction will be rolled back. The ``defer_round_trip`` parameter is a boolean that determines whether the request to start a transaction is to be sent immediately or with the next database operation. If set to *False*, the request is sent immediately. If set to *True*, the request is included with the next database operation on the connection. The default value is *False*. rr]Nr^ras r1r`z-AsyncConnection.begin_sessionless_transactionsF    ?OO'3'' B7a<<@AA Aj66 g'7          r3r return_typecK|5}|||||d{VcdddS#1swxYwYdS)z Calls a PL/SQL function with the given name. This is a shortcut for calling :meth:`cursor()`, :meth:`AsyncCursor.callfunc()`, and then :meth:`AsyncCursor.close()`. N)rncallfunc)r0rrYr~rSrns r1r[zAsyncConnection.callfuncs[[]] fk:/A                  sAA AcK|5}||||d{VcdddS#1swxYwYdS)z Calls a PL/SQL procedure with the given name. This is a shortcut for calling :meth:`cursor()`, :meth:`AsyncCursor.callproc()`, and then :meth:`AsyncCursor.close()`. N)rncallproc)r0rr~rSrns r1r]zAsyncConnection.callprocs[[]] Ofz;MNNNNNNNN O O O O O O O O O O O O O O O O O OAAArVrWctK||j||d{VdSrYrZr\s r1r]zAsyncConnection.changepasswordsJ    j((|DDDDDDDDDDDr3cfK||d{VdS)z( Closes the connection. Nr_r/s r1rAzAsyncConnection.closes@    kkmmr3cpK||jd{VdS)zB Commits any pending transaction to the database. Nrar/s r1rbzAsyncConnection.commitsF    j!!!!!!!!!!!r3rcrc"K||tttfvrd}t ||j|d{V}tj|}|r| |d{V|S)zP Creates and returns a new temporary LOB of the specified type. reN) rCrrrrGr:rfrrrgrhs r1rjzAsyncConnection.createlobs    L-F F FB G$$ $Z44X>>>>>>>>!$''  "))D// ! ! ! ! ! ! ! r3rkcJ|t||S)zo Returns an :ref:`AsyncCursor object ` associated with the connection. )rCrrms r1rnzAsyncConnection.cursor s&    4,,,r3r}cK|5}|||d{VddddS#1swxYwYdS)z Executes a statement against the database. This is a shortcut for calling :meth:`cursor()`, :meth:`AsyncCursor.execute()`, and then :meth:`AsyncCursor.close()` N)rnrr0r}r~rns r1rzAsyncConnection.execute s[[]] 8f..J77 7 7 7 7 7 7 7 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8r^cK|5}|||d{VddddS#1swxYwYdS)a Executes a SQL statement once using all bind value mappings or sequences found in the sequence parameters. This can be used to insert, update, or delete multiple rows in a table with a single python-oracledb call. It can also invoke a PL/SQL procedure multiple times. The ``parameters`` parameter can be a list of tuples, where each tuple item maps to one bind variable placeholder in ``statement``. It can also be a list of dictionaries, where the keys match the bind variable placeholder names in ``statement``. If there are no bind values, or values have previously been bound, the ``parameters`` value can be an integer specifying the number of iterations. This is a shortcut for calling :meth:`cursor()`, :meth:`AsyncCursor.executemany()`, and then :meth:`AsyncCursor.close()`. N)rn executemanyres r1rgzAsyncConnection.executemany% s*[[]] `. Internally, this method's :attr:`AsyncCursor.prefetchrows` size is set to the value of the explicit or default ``arraysize`` parameter value. This is a shortcut for calling :meth:`cursor()`, :meth:`AsyncCursor.fetchall()`, and then :meth:`AsyncCursor.close()`. Nrh)rnrrrrr)r0r}r~rrrir{rns r1rzAsyncConnection.fetchall= s,[[]] +f$#, "("2F ..%- !        !+F ******** + + + + + + + + + + + + + + + + + +sAA99A=A=rorprrrsrtrqczK||j|||||d{VdSrvrwrys r1rxz AsyncConnection.direct_path_load` sg*    j)) \4           r3rzr|c,K|}d|j_|tj||j_|||_|j|_||||d{V|j |d{VS)a Fetches all rows of the SQL query ``statement``, returning them in a :ref:`DataFrame ` object. An empty DataFrame is returned if there are no rows available. The ``parameters`` parameter can be a list of tuples, where each tuple item maps to one :ref:`bind variable placeholder ` in ``statement``. It can also be a list of dictionaries, where the keys match the bind variable placeholder names in ``statement``. The ``arraysize`` parameter can be specified to tune performance of fetching data across the network. It defaults to :attr:`oracledb.defaults.arraysize `. Internally, the ``fetch_df_all()``'s :attr:`Cursor.prefetchrows` size is always set to the value of the explicit or default ``arraysize`` parameter value. The ``fetch_decimals`` parameter specifies whether to return decimal values when fetching columns of type ``NUMBER`` that are capable of being represented in Apache Arrow Decimal128 format. The default value is :data:`oracledb.defaults.fetch_decimals `. The ``requested_schema`` parameter specifies an object that implements the Apache Arrow PyCapsule schema interface. The DataFrame returned by ``fetch_df_all()`` will have the data types and names of the schema. TNrrrs r1rzAsyncConnection.fetch_df_allz sD&* #  ''6'H ((FL $  (F $.nn  )         \..v666666666r3rcK|}d|j_|tj||j_|||_|j|_||||d{V|%|j |d{VWVdS|j ||23d{V}|WV 6dS)a This returns an iterator yielding the next ``size`` rows of the SQL query ``statement`` in each iteration as a :ref:`DataFrame ` object. An empty DataFrame is returned if there are no rows available. The ``parameters`` parameter can be a list of tuples, where each tuple item maps to one :ref:`bind variable placeholder ` in ``statement``. It can also be a list of dictionaries, where the keys match the bind variable placeholder names in ``statement``. The ``size`` parameter controls the number of records fetched in each batch. It defaults to :attr:`oracledb.defaults.arraysize `. Internally, the ``fetch_df_batches()``'s :attr:`Cursor.arraysize` and :attr:`Cursor.prefetchrows` sizes are always set to the value of the explicit or default ``size`` parameter value. The ``fetch_decimals`` parameter specifies whether to return decimal values when fetching columns of type ``NUMBER`` that are capable of being represented in Arrow Decimal128 format. The default value is :data:`oracledb.defaults.fetch_decimals `. The ``requested_schema`` parameter specifies an object that implements the Apache Arrow PyCapsule schema interface. The DataFrame returned by ``fetch_df_all()`` will have the data types and names of the schema. TNrr)r0r}r~rr{r|rndfs r1rz AsyncConnection.fetch_df_batches s.J&* #  ''6'H ((FL $  #F $.nn  )         < 11&99999999 9 9 9 9 9 9"L99&$GG       bHGGs8Cnum_rowsc<K|5}||j}n|dkrgcdddS|x|_|_|||||d{V||_||d{VcdddS#1swxYwYdS)a Executes a query and returns up to the specified number of rows. The default value for ``num_rows`` is the value of :attr:`oracledb.defaults.arraysize `. Internally, this method's :attr:`AsyncCursor.prefetchrows` size is set to the value of the explicit or default ``num_rows`` parameter, allowing all rows to be fetched in one :ref:`round-trip ` Since only one fetch is performed for a query, consider adding a ``FETCH NEXT`` clause to the statement to prevent the database processing rows that will never be fetched, see :ref:`rowlimit`. This a shortcut for calling :meth:`cursor()`, :meth:`AsyncCursor.fetchmany()`, and then :meth:`AsyncCursor.close()`. Nrrh)rnrrrr fetchmany)r0r}r~rorrir{rns r1rqzAsyncConnection.fetchmany s?6[[]] 4f!+Q 4 4 4 4 4 4 4 4 6> =F v2..%- !        !+F ))(33333333 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4sBABBBcK|5}dx|_|_|||||d{V||_|d{VcdddS#1swxYwYdS)a Executes a query and returns the first row of the result set if one exists (or *None* if no rows exist). Internally, this method's :attr:`Cursor.prefetchrows` and :attr:`Cursor.arraysize` sizes will be set to *1*. Since only one fetch is performed for a query, consider adding a ``WHERE`` condition or using a ``FETCH NEXT`` clause in the statement to prevent the database processing rows that will never be fetched, see :ref:`rowlimit`. This a shortcut for calling :meth:`cursor()`, :meth:`AsyncCursor.fetchone()`, and then :meth:`AsyncCursor.close()`. r rhN)rnrrrrfetchone)r0r}r~rrir{rns r1rszAsyncConnection.fetchone s0[[]] +f56 6F &"2..%- !        !+F ******** + + + + + + + + + + + + + + + + + +sAA22A69A6cK||j||d{V}tj|S)rNrrs r1rzAsyncConnection.gettype2 sT    "j11$======== &}555r3cpK||jd{VdS)zJ Pings the database to verify if the connection is valid. Nrr/s r1rzAsyncConnection.ping; sD    joor3c K||tdt|}t|tr|dkst d|j|||d{V|Srrras r1rz.AsyncConnection.resume_sessionless_transactionB sP     !FGG G?OO7C(( FW\\DEE Ej77 g'7          r3cpK||jd{VdS)z5 Rolls back any pending transaction. Nrr/s r1rzAsyncConnection.rollbackx sF    j!!###########r3pipelinecontinue_on_errorc6K|d|jD}|jr6t |dkr#|j|||d{Vn"|j|||d{V|S)a Runs all of the operations in the pipeline and returns a list of PipelineOpResult, each entry corresponding to an operation executed in the pipeline. The ``continue_on_error`` parameter determines whether operations should continue to run after an error has occurred. If this parameter is set to *True*, then the :attr:`PipelineOpResult.error` attribute will be populated with an :ref:`_Error ` instance which identifies the error that occurred. If this parameter is set to *False*, then an exception will be raised as soon as an error is detected and all subsequent operations will be terminated. The default value is *False*. c6g|]}|Sr)_create_result)rops r1 z0AsyncConnection.run_pipeline.. s$EEE22$$&&EEEr3r N)rCrr:supports_pipelininglenrun_pipeline_with_pipeliningrun_pipeline_without_pipelining)r0rxryresultss r1 run_pipelinezAsyncConnection.run_pipeline s&    EE1DEEE : ) ) + + G q0@0@*99g0        *<<g0       r3cpK||jd{VdS)a Suspends the currently active sessionless transaction immediately. This detaches the transaction from the connection, allowing it to be resumed later with the transaction identifier that was specified during creation of the sessionless transaction. The ``timeout`` previously passed to :meth:`AsyncConnection.begin_sessionless_transaction()` determines how long the transaction can stay suspended before it is automatically rolled back. Nrr/s r1rz/AsyncConnection.suspend_sessionless_transaction sF    j88:::::::::::r3rrDrc<K||||tjtjtjtjfvrtjtj |j |||d{VdS)a Begins a Two-Phase Commit (TPC) on a global transaction using the specified transaction identifier (xid). The ``xid`` parameter should be an object returned by the :meth:`xid()` method. The ``flags`` parameter is one of the constants :data:`oracledb.TPC_BEGIN_JOIN`, :data:`oracledb.TPC_BEGIN_NEW`, :data:`oracledb.TPC_BEGIN_PROMOTE`, or :data:`oracledb.TPC_BEGIN_RESUME`. The default is :data:`oracledb.TPC_BEGIN_NEW`. The ``timeout`` parameter is the number of seconds to wait for a transaction to become available for resumption when :data:`~oracledb.TPC_BEGIN_RESUME` is specified in the ``flags`` parameter. When :data:`~oracledb.TPC_BEGIN_NEW` is specified in the ``flags`` parameter, the ``timeout`` parameter indicates the number of seconds the transaction can be inactive before it is automatically terminated by the system. A transaction is inactive between the time it is detached with :meth:`AsyncConnection.tpc_end()` and the time it is resumed with :meth:`AsyncConnection.tpc_begin()`.The default is *0* seconds. Nrrs r1rQzAsyncConnection.tpc_begin s6        "  #  %  &     f@ A A Aj""3w77777777777r3rcK|||||j||d{VdS)a Commits a global transaction. When called with no arguments, this method commits a transaction previously prepared with :meth:`~AsyncConnection.tpc_begin()` and optionally prepared with :meth:`~AsyncConnection.tpc_prepare()`. If :meth:`~AsyncConnection.tpc_prepare()` is not called, a single phase commit is performed. A transaction manager may choose to do this if only a single resource is participating in the global transaction. If an ``xid`` parameter is passed, then an object should be returned by the :meth:`~Connection.xid()` function. This form should be called outside of a transaction and is intended for use in recovery. The ``one_phase`` parameter is a boolean identifying whether to perform a one-phase or two-phase commit. If ``one_phase`` parameter is *True*, a single-phase commit is performed. The default value is *False*. This parameter is only examined if a value is provided for the ``xid`` parameter. Otherwise, the driver already knows whether :meth:`tpc_prepare()` was called for the transaction and whether a one-phase or two-phase commit is required. Nrrs r1rzAsyncConnection.tpc_commit sc0    ?   S ! ! !j##C33333333333r3cK|||||tjtjfvrt jt j|j ||d{VdS)a' Ends or suspends work on a global transaction. This function is only intended for use by transaction managers. If an ``xid`` parameter is passed, then an object should be returned by the :meth:`~Connection.xid()` function. If no xid parameter is passed, then the transaction identifier used by the previous :meth:`~Connection.tpc_begin()` is used. The ``flags`` parameter is one of the constants :data:`oracledb.TPC_END_NORMAL` or :data:`oracledb.TPC_END_SUSPEND`. The default is :data:`oracledb.TPC_END_NORMAL`. If the flag is :data:`oracledb.TPC_END_SUSPEND` then the transaction may be resumed later by calling :meth:`AsyncConnection.tpc_begin()` with the flag :data:`oracledb.TPC_BEGIN_RESUME`. Nrrs r1rzAsyncConnection.tpc_end s(    ?   S ! ! ! 0(2JK K K  f> ? ? ?j  e,,,,,,,,,,,r3cK||||j|d{VdSrrrs r1rzAsyncConnection.tpc_forget s\     j##C(((((((((((r3cK|||||j|d{VS)rNrrs r1rzAsyncConnection.tpc_prepare s[    ?   S ! ! !Z++C000000000r3cK|5}|dd{Vt|_|d{VcdddS#1swxYwYdS)a Returns a list of pending transaction identifiers that require recovery. Objects of type ``Xid`` (as returned by the :meth:`~Connection.xid()` function) are returned and these can be passed to :meth:`tpc_commit()` or :meth:`tpc_rollback()` as needed. This function queries the view ``DBA_PENDING_TRANSACTIONS`` and requires ``SELECT`` privilege on that view. rNrrs r1rzAsyncConnection.tpc_recover+ s[[]] +f..5       !$F ******** + + + + + + + + + + + + + + + + + +sAA%%A),A)cK|||||j|d{VdS)a Rolls back a global transaction. If an ``xid`` parameter is not passed, then it rolls back the transaction that was previously started with :meth:`~AsyncConnection.tpc_begin()`. If an ``xid`` parameter is passed, then an object should be returned by :meth:`~Connection.xid()` and the specified transaction is rolled back. This form should be called outside of a transaction and is intended for use in recovery. Nrrs r1rzAsyncConnection.tpc_rollbackA sa    ?   S ! ! !j%%c***********r3rrrrr-)NNNrr)Crrr rr rPrrr2rDrGrJr4rArrrWrrr r_r r`rrr[r]r]rArbrrrjrrnrrgrrrxrrrrrqrsrrrrrr!r"rrrrr&rQrrrrrrrrrs@r1r?r?s K  K- K K  K  K K K K K K%%%          222h11136 *7;!& , ,  sEz!23, ,  ,  , , , , d48-1 U4;/0  %TN  *48-1 O O OU4;/0 O%TN O  O O O OEE/2E EEEE""""EI&.uS%Z/@&A &---+----:> 8 8 8U4#456 8  8 8 8 8<sDy)<7:< <<<<6:>#')- !+&*)-!+!+!+!+U4#456!+C= !+ X& !+TN!+!!+ !+!+!+!+T$     3i          ::>#' 07 *.*.07070707U4#45607C= 07 ! 07#3-07 07070707j:>" 7 *.*.7777U4#4567sm 7 ! 7#3-7 ) 7777x:>"&)- (4&*)-(4(4(4(4U4#456(43- (4 X& (4TN(4!(4 (4(4(4(4Z:>)- !+ &*)-!+!+!+!+U4#456!+X& !+ TN !+!!+ !+!+!+!+F6#6,6666    !& 4 4 c5j)4 4  4  4 4 4 4 l$$$$#(    > ; ; ; ;&.%;A$8$8$8"$8FI$8 $8$8$8$8N.connect_async] sg  !!       *o66 =  f; < < <   6  / &%      !*044Z@@D|!1  J +1% % K G$$ $  j&G&G   f? @ @ @ !###z#tVV444r3r-)rrr?rrrr)rrs` r1_async_connection_factoryrT s_Q!.5=A$(,;*. .5.5.5 c].589.5SM .5 ) .5 ' .5 .5.5.5.5.5.5` r3rc9dS)a>4 Factory function which creates a connection to the database and returns it. The ``dsn`` parameter (data source name) can be a string in the format user/password@connect_string or can simply be the connect string (in which case authentication credentials such as the username and password need to be specified separately). See the documentation on connection strings for more information. The ``pool`` parameter is expected to be a pool object. This parameter was deprecated in python-oracledb 3.0.0. Use :meth:`ConnectionPool.acquire()` instead since the use of this parameter is the equivalent of calling this method. The ``conn_class`` parameter is expected to be AsyncConnection or a subclass of AsyncConnection. The ``params`` parameter is expected to be of type ConnectParams and contains connection parameters that will be used when establishing the connection. See the documentation on ConnectParams for more information. If this parameter is not specified, the additional keyword parameters will be used to create an instance of ConnectParams. If both the ``params`` parameter and additional keyword parameters are specified, the values in the keyword parameters have precedence. Note that if a ``dsn`` is also supplied, then in python-oracledb Thin mode, the values of the parameters specified (if any) within the dsn will override the values passed as additional keyword parameters, which themselves override the values set in the ``params`` parameter object. The following parameters are all optional. A brief description of each parameter follows: - ``user``: the name of the database user to connect to (default: None) - ``proxy_user``: the name of the proxy user to connect to. If this value is not specified, it will be parsed out of user if user is in the form "user[proxy_user]" (default: None) - ``password``: the password for the database user (default: None) - ``newpassword``: a new password for the database user. The new password will take effect immediately upon a successful connection to the database (default: None) - ``wallet_password``: the password to use to decrypt the wallet, if it is encrypted. This is not the database password. For Oracle Autonomous Database this is the password created when downloading the wallet. This value is only used in python-oracledb Thin mode. (default: None) - ``access_token``: a string, or a 2-tuple, or a callable. If it is a string, it specifies an Entra ID OAuth2 token used for Open Authorization (OAuth 2.0) token based authentication. If it is a 2-tuple, it specifies the token and private key strings used for Oracle Cloud Infrastructure (OCI) Identity and Access Management (IAM) token based authentication. If it is a callable, it returns either a string or a 2-tuple used for OAuth 2.0 or OCI IAM token based authentication and is useful when the pool needs to expand and create new connections but the current authentication token has expired (default: None) - ``host``: the hostname or IP address of the machine hosting the database or the database listener (default: None) - ``port``: the port number on which the database listener is listening (default: 1521) - ``protocol``: one of the strings "tcp" or "tcps" indicating whether to use unencrypted network traffic or encrypted network traffic (TLS) (default: "tcp") - ``https_proxy``: the hostname or IP address of a proxy host to use for tunneling secure connections (default: None) - ``https_proxy_port``: the port on which to communicate with the proxy host (default: 0) - ``service_name``: the service name of the database (default: None) - ``instance_name``: the instance name of the database (default: None) - ``sid``: the system identifier (SID) of the database. Note using a service_name instead is recommended (default: None) - ``server_type``: the type of server connection that should be established. If specified, it should be one of strings "dedicated", "shared" or "pooled" (default: None) - ``cclass``: the connection class to use for Database Resident Connection Pooling (DRCP) (default: None) - ``purity``: the connection purity to use for Database Resident Connection Pooling (DRCP) (default: :attr:`oracledb.PURITY_DEFAULT`) - ``expire_time``: the number of minutes between the sending of keepalive probes. If this parameter is set to a value greater than zero it enables keepalive (default: 0) - ``retry_count``: the number of times that initial connection establishment should be retried before the connection attempt is terminated (default: 0) - ``retry_delay``: the number of seconds to wait before retrying to establish a connection (default: 1) - ``tcp_connect_timeout``: a float indicating the maximum number of seconds to wait when establishing a connection to the database host (default: 20.0) - ``ssl_server_dn_match``: a boolean indicating whether the server certificate distinguished name (DN) should be matched in addition to the regular certificate verification that is performed. Note that if the ssl_server_cert_dn parameter is not privided, host name matching is performed instead (default: True) - ``ssl_server_cert_dn``: the distinguished name (DN) which should be matched with the server. This value is ignored if the ssl_server_dn_match parameter is not set to the value True. If specified this value is used for any verfication. Otherwise the hostname will be used (default: None) - ``wallet_location``: the directory where the wallet can be found. In python-oracledb Thin mode this must be the directory containing the PEM- encoded wallet file ewallet.pem. In python-oracledb Thick mode this must be the directory containing the file cwallet.sso (default: None) - ``events``: a boolean specifying whether events mode should be enabled. This value is only used in python-oracledb Thick mode and is needed for continuous query notification and high availability event notifications (default: False) - ``externalauth``: a boolean indicating whether to use external authentication (default: False) - ``mode``: the authorization mode to use. One of the constants :data:`oracledb.AUTH_MODE_DEFAULT`, :data:`oracledb.AUTH_MODE_PRELIM`, :data:`oracledb.AUTH_MODE_SYSASM`, :data:`oracledb.AUTH_MODE_SYSBKP`, :data:`oracledb.AUTH_MODE_SYSDBA`, :data:`oracledb.AUTH_MODE_SYSDGD`, :data:`oracledb.AUTH_MODE_SYSKMT`, :data:`oracledb.AUTH_MODE_SYSOPER`, or :data:`oracledb.AUTH_MODE_SYSRAC` (default: :attr:`oracledb.AUTH_MODE_DEFAULT`) - ``disable_oob``: a boolean indicating whether out-of-band breaks should be disabled. This value is only used in python-oracledb Thin mode. It has no effect on Windows which does not support this functionality (default: False) - ``stmtcachesize``: the size of the statement cache (default: :attr:`oracledb.defaults.stmtcachesize `) - ``edition``: edition to use for the connection. This parameter cannot be used simultaneously with the cclass parameter (default: None) - ``tag``: identifies the type of connection that should be returned from a pool. This value is only used in python-oracledb Thick mode (default: None) - ``matchanytag``: a boolean specifying whether any tag can be used when acquiring a connection from the pool. This value is only used in python- oracledb Thick mode (default: False) - ``config_dir``: a directory in which the optional tnsnames.ora configuration file is located. This value is only used in python-oracledb Thin mode. For python-oracledb Thick mode, it is used if :attr:`oracledb.defaults.thick_mode_dsn_passthrough ` is *False*. Otherwise in Thick mode use the ``config_dir`` parameter of :meth:`oracledb.init_oracle_client()` (default: :attr:`oracledb.defaults.config_dir `) - ``appcontext``: application context used by the connection. It should be a list of 3-tuples (namespace, name, value) and each entry in the tuple should be a string (default: None) - ``shardingkey``: a list of strings, numbers, bytes or dates that identify the database shard to connect to. This value is only used in python- oracledb Thick mode (default: None) - ``supershardingkey``: a list of strings, numbers, bytes or dates that identify the database shard to connect to. This value is only used in python-oracledb Thick mode (default: None) - ``debug_jdwp``: a string with the format "host=;port=" that specifies the host and port of the PL/SQL debugger. This value is only used in python-oracledb Thin mode. For python-oracledb Thick mode set the ORA_DEBUG_JDWP environment variable (default: None) - ``connection_id_prefix``: an application specific prefix that is added to the connection identifier used for tracing (default: None) - ``ssl_context``: an SSLContext object used for connecting to the database using TLS. This SSL context will be modified to include the private key or any certificates found in a separately supplied wallet. This parameter should only be specified if the default SSLContext object cannot be used (default: None) - ``sdu``: the requested size of the Session Data Unit (SDU), in bytes. The value tunes internal buffers used for communication to the database. Bigger values can increase throughput for large queries or bulk data loads, but at the cost of higher memory use. The SDU size that will actually be used is negotiated down to the lower of this value and the database network SDU configuration value (default: 8192) - ``pool_boundary``: one of the values "statement" or "transaction" indicating when pooled DRCP connections can be returned to the pool. This requires the use of DRCP with Oracle Database 23.4 or higher (default: None) - ``use_tcp_fast_open``: a boolean indicating whether to use TCP fast open. This is an Oracle Autonomous Database Serverless (ADB-S) specific property for clients connecting from within OCI Cloud network. Please refer to the ADB-S documentation for more information (default: False) - ``ssl_version``: one of the values ssl.TLSVersion.TLSv1_2 or ssl.TLSVersion.TLSv1_3 indicating which TLS version to use (default: None) - ``program``: a string recorded by Oracle Database as the program from which the connection originates (default: :attr:`oracledb.defaults.program `) - ``machine``: a string recorded by Oracle Database as the name of the machine from which the connection originates (default: :attr:`oracledb.defaults.machine `) - ``terminal``: a string recorded by Oracle Database as the terminal identifier from which the connection originates (default: :attr:`oracledb.defaults.terminal `) - ``osuser``: a string recorded by Oracle Database as the operating system user who originated the connection (default: :attr:`oracledb.defaults.osuser `) - ``driver_name``: a string recorded by Oracle Database as the name of the driver which originated the connection (default: :attr:`oracledb.defaults.driver_name `) - ``use_sni``: a boolean indicating whether to use the TLS SNI extension to bypass the second TLS neogiation that would otherwise be required (default: False) - ``thick_mode_dsn_passthrough``: a boolean indicating whether to pass the connect string to the Oracle Client libraries unchanged without parsing by the driver. Setting this to False makes python-oracledb Thick and Thin mode applications behave similarly regarding connection string parameter handling and locating any optional tnsnames.ora configuration file (default: :attr:`oracledb.defaults.thick_mode_dsn_passthrough `) - ``extra_auth_params``: a dictionary containing configuration parameters necessary for Oracle Database authentication using plugins, such as the Azure and OCI cloud-native authentication plugins (default: None) - ``pool_name``: the name of the DRCP pool when using multi-pool DRCP with Oracle Database 23.4, or higher (default: None) - ``handle``: an integer representing a pointer to a valid service context handle. This value is only used in python-oracledb Thick mode. It should be used with extreme caution (default: 0) Nrr<s: r1rr r=r3r-)H collectionsrssltypingrrrrrrrrNr r r r rrr aqrrr arrow_implrbaserrrrrconnect_paramsrrnrr dataframerdbobjectrrrirr rxr!r"sodar#rr$utilsr% namedtupler&r+rrrrr_Purityfloatr AuthModer TLSVersionrr(r?rrrr3r1rs] H AAAAAAAAAAAAAAAACCCCCCCCCCCCCC!!!!!!4444444444''''''HHHHHHHHHHHH))))))'''''''' ,,,,,,,,00000000 777777k E E E D GD GD GD GD G}D GD GD GD GNg -g -g -g -g -g -g -g -T2Z 2 c:o2222jf 48 $#-&* $"!%%):>"!%&*"&#'!% (,!%!%!%+/*.(,%)!#'(,"&#'!"& $!%"&'+ $*.!%#'(,,0!!" !%"15(,# wf f f #f  / 0f  f Z f ] # f  3-f  f smf #f c]f 5eX!567f  3-f  3-f smf #!f "sm#f $3-%f &C='f ( #)f *#+f , SM-f . X_ %/f 0#1f 2#3f 4#5f 6"%7f 8"$9f :! ;f <c]=f > TN?f @4.Af B 8$ %Cf D$Ef FC=Gf Hc]If J #Kf L$Mf N Of PQf R$Sf TtnUf V Wf X#3-Yf Z#[f \ #]f ^C=_f ` ~af b#.)cf dc]ef fc]gf hsmif j SMkf l#mf nd^of p!)qf r ~sf t}uf v SMwf xyf f f f R @ +@ +@ +@ +@ +n@ +@ +@ +F:_$%: c?"#::::zf 9= $(7&* $"!%%):>"!%&*"&#'!% (,!%!%!%+/*.(,%)!#'(,"&#'!"& $!%"&'+ $*.!%#'(,,0!!" !%"15(,# wf f f #f  4 5f  f _% f ] # f  3-f  f smf #f c]f 5eX!567f  3-f  3-f smf #!f "sm#f $3-%f &C='f ( #)f *#+f , SM-f . X_ %/f 0#1f 2#3f 4#5f 6"%7f 8"$9f :! ;f <c]=f > TN?f @4.Af B 8$ %Cf D$Ef FC=Gf Hc]If J #Kf L$Mf N Of PQf R$Sf TtnUf V Wf X#3-Yf Z#[f \ #]f ^C=_f ` ~af b#.)cf dc]ef fc]gf hsmif j SMkf l#mf nd^of p!)qf r ~sf t}uf v SMwf xyf f f f f f r3