h4dZddlmZddlZddlZddlZddlmZddlm Z ddlm Z ddlm Z dd l m Z d d lmZd d lmZd d lmZd dlmZd dlmZd dlmZd dlmZdZGddej4ZGddej8ZGddej<ZGddeZ Gdde ejBZ"Gdde ejFZ$Gdd eZ%Gd!d"ejLZ'Gd#d$e ejPZ)Gd%d&Z*Gd'd(ejVZ,Gd)d*ejZZ.Gd+d,ej^Z0Gd-d.ejbZ2Gd/d0e*ejfZ4Gd1d2e*ejjZ6Gd3d4e*ejnZ8Gd5d6e*ejrZ:Gd7d8ejvZ<Gd9d:ejzZ>Gd;dejZBGd?d@ejZDGdAdBejZFGdCdDe ZGGdEdFe ZHGdGdHe ZIeIZJy)IuTJ.. dialect:: oracle+cx_oracle :name: cx-Oracle :dbapi: cx_oracle :connectstring: oracle+cx_oracle://user:pass@hostname:port[/dbname][?service_name=[&key=value&key=value...]] :url: https://oracle.github.io/python-cx_Oracle/ Description ----------- cx_Oracle was the original driver for Oracle Database. It was superseded by python-oracledb which should be used instead. DSN vs. Hostname connections ----------------------------- cx_Oracle provides several methods of indicating the target database. The dialect translates from a series of different URL forms. Hostname Connections with Easy Connect Syntax ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Given a hostname, port and service name of the target database, for example from Oracle Database's Easy Connect syntax then connect in SQLAlchemy using the ``service_name`` query string parameter:: engine = create_engine( "oracle+cx_oracle://scott:tiger@hostname:port?service_name=myservice&encoding=UTF-8&nencoding=UTF-8" ) Note that the default driver value for encoding and nencoding was changed to “UTF-8” in cx_Oracle 8.0 so these parameters can be omitted when using that version, or later. To use a full Easy Connect string, pass it as the ``dsn`` key value in a :paramref:`_sa.create_engine.connect_args` dictionary:: import cx_Oracle e = create_engine( "oracle+cx_oracle://@", connect_args={ "user": "scott", "password": "tiger", "dsn": "hostname:port/myservice?transport_connect_timeout=30&expire_time=60", }, ) Connections with tnsnames.ora or to Oracle Autonomous Database ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Alternatively, if no port, database name, or service name is provided, the dialect will use an Oracle Database DSN "connection string". This takes the "hostname" portion of the URL as the data source name. For example, if the ``tnsnames.ora`` file contains a TNS Alias of ``myalias`` as below: .. sourcecode:: text myalias = (DESCRIPTION = (ADDRESS = (PROTOCOL = TCP)(HOST = mymachine.example.com)(PORT = 1521)) (CONNECT_DATA = (SERVER = DEDICATED) (SERVICE_NAME = orclpdb1) ) ) The cx_Oracle dialect connects to this database service when ``myalias`` is the hostname portion of the URL, without specifying a port, database name or ``service_name``:: engine = create_engine("oracle+cx_oracle://scott:tiger@myalias") Users of Oracle Autonomous Database should use this syntax. If the database is configured for mutural TLS ("mTLS"), then you must also configure the cloud wallet as shown in cx_Oracle documentation `Connecting to Autononmous Databases `_. SID Connections ^^^^^^^^^^^^^^^ To use Oracle Database's obsolete System Identifier connection syntax, the SID can be passed in a "database name" portion of the URL:: engine = create_engine( "oracle+cx_oracle://scott:tiger@hostname:port/dbname" ) Above, the DSN passed to cx_Oracle is created by ``cx_Oracle.makedsn()`` as follows:: >>> import cx_Oracle >>> cx_Oracle.makedsn("hostname", 1521, sid="dbname") '(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=hostname)(PORT=1521))(CONNECT_DATA=(SID=dbname)))' Note that although the SQLAlchemy syntax ``hostname:port/dbname`` looks like Oracle's Easy Connect syntax it is different. It uses a SID in place of the service name required by Easy Connect. The Easy Connect syntax does not support SIDs. Passing cx_Oracle connect arguments ----------------------------------- Additional connection arguments can usually be passed via the URL query string; particular symbols like ``SYSDBA`` are intercepted and converted to the correct symbol:: e = create_engine( "oracle+cx_oracle://user:pass@dsn?encoding=UTF-8&nencoding=UTF-8&mode=SYSDBA&events=true" ) .. versionchanged:: 1.3 the cx_Oracle dialect now accepts all argument names within the URL string itself, to be passed to the cx_Oracle DBAPI. As was the case earlier but not correctly documented, the :paramref:`_sa.create_engine.connect_args` parameter also accepts all cx_Oracle DBAPI connect arguments. To pass arguments directly to ``.connect()`` without using the query string, use the :paramref:`_sa.create_engine.connect_args` dictionary. Any cx_Oracle parameter value and/or constant may be passed, such as:: import cx_Oracle e = create_engine( "oracle+cx_oracle://user:pass@dsn", connect_args={ "encoding": "UTF-8", "nencoding": "UTF-8", "mode": cx_Oracle.SYSDBA, "events": True, }, ) Note that the default driver value for ``encoding`` and ``nencoding`` was changed to "UTF-8" in cx_Oracle 8.0 so these parameters can be omitted when using that version, or later. Options consumed by the SQLAlchemy cx_Oracle dialect outside of the driver -------------------------------------------------------------------------- There are also options that are consumed by the SQLAlchemy cx_oracle dialect itself. These options are always passed directly to :func:`_sa.create_engine` , such as:: e = create_engine( "oracle+cx_oracle://user:pass@dsn", coerce_to_decimal=False ) The parameters accepted by the cx_oracle dialect are as follows: * ``arraysize`` - set the cx_oracle.arraysize value on cursors; defaults to ``None``, indicating that the driver default should be used (typically the value is 100). This setting controls how many rows are buffered when fetching rows, and can have a significant effect on performance when modified. .. versionchanged:: 2.0.26 - changed the default value from 50 to None, to use the default value of the driver itself. * ``auto_convert_lobs`` - defaults to True; See :ref:`cx_oracle_lob`. * ``coerce_to_decimal`` - see :ref:`cx_oracle_numeric` for detail. * ``encoding_errors`` - see :ref:`cx_oracle_unicode_encoding_errors` for detail. .. _cx_oracle_sessionpool: Using cx_Oracle SessionPool --------------------------- The cx_Oracle driver provides its own connection pool implementation that may be used in place of SQLAlchemy's pooling functionality. The driver pool supports Oracle Database features such dead connection detection, connection draining for planned database downtime, support for Oracle Application Continuity and Transparent Application Continuity, and gives support for Database Resident Connection Pooling (DRCP). Using the driver pool can be achieved by using the :paramref:`_sa.create_engine.creator` parameter to provide a function that returns a new connection, along with setting :paramref:`_sa.create_engine.pool_class` to ``NullPool`` to disable SQLAlchemy's pooling:: import cx_Oracle from sqlalchemy import create_engine from sqlalchemy.pool import NullPool pool = cx_Oracle.SessionPool( user="scott", password="tiger", dsn="orclpdb", min=1, max=4, increment=1, threaded=True, encoding="UTF-8", nencoding="UTF-8", ) engine = create_engine( "oracle+cx_oracle://", creator=pool.acquire, poolclass=NullPool ) The above engine may then be used normally where cx_Oracle's pool handles connection pooling:: with engine.connect() as conn: print(conn.scalar("select 1 from dual")) As well as providing a scalable solution for multi-user applications, the cx_Oracle session pool supports some Oracle features such as DRCP and `Application Continuity `_. Note that the pool creation parameters ``threaded``, ``encoding`` and ``nencoding`` were deprecated in later cx_Oracle releases. Using Oracle Database Resident Connection Pooling (DRCP) -------------------------------------------------------- When using Oracle Database's DRCP, the best practice is to pass a connection class and "purity" when acquiring a connection from the SessionPool. Refer to the `cx_Oracle DRCP documentation `_. This can be achieved by wrapping ``pool.acquire()``:: import cx_Oracle from sqlalchemy import create_engine from sqlalchemy.pool import NullPool pool = cx_Oracle.SessionPool( user="scott", password="tiger", dsn="orclpdb", min=2, max=5, increment=1, threaded=True, encoding="UTF-8", nencoding="UTF-8", ) def creator(): return pool.acquire( cclass="MYCLASS", purity=cx_Oracle.ATTR_PURITY_SELF ) engine = create_engine( "oracle+cx_oracle://", creator=creator, poolclass=NullPool ) The above engine may then be used normally where cx_Oracle handles session pooling and Oracle Database additionally uses DRCP:: with engine.connect() as conn: print(conn.scalar("select 1 from dual")) .. _cx_oracle_unicode: Unicode ------- As is the case for all DBAPIs under Python 3, all strings are inherently Unicode strings. In all cases however, the driver requires an explicit encoding configuration. Ensuring the Correct Client Encoding ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ The long accepted standard for establishing client encoding for nearly all Oracle Database related software is via the `NLS_LANG `_ environment variable. Older versions of cx_Oracle use this environment variable as the source of its encoding configuration. The format of this variable is Territory_Country.CharacterSet; a typical value would be ``AMERICAN_AMERICA.AL32UTF8``. cx_Oracle version 8 and later use the character set "UTF-8" by default, and ignore the character set component of NLS_LANG. The cx_Oracle driver also supported a programmatic alternative which is to pass the ``encoding`` and ``nencoding`` parameters directly to its ``.connect()`` function. These can be present in the URL as follows:: engine = create_engine( "oracle+cx_oracle://scott:tiger@tnsalias?encoding=UTF-8&nencoding=UTF-8" ) For the meaning of the ``encoding`` and ``nencoding`` parameters, please consult `Characters Sets and National Language Support (NLS) `_. .. seealso:: `Characters Sets and National Language Support (NLS) `_ - in the cx_Oracle documentation. Unicode-specific Column datatypes ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ The Core expression language handles unicode data by use of the :class:`.Unicode` and :class:`.UnicodeText` datatypes. These types correspond to the VARCHAR2 and CLOB Oracle Database datatypes by default. When using these datatypes with Unicode data, it is expected that the database is configured with a Unicode-aware character set, as well as that the ``NLS_LANG`` environment variable is set appropriately (this applies to older versions of cx_Oracle), so that the VARCHAR2 and CLOB datatypes can accommodate the data. In the case that Oracle Database is not configured with a Unicode character set, the two options are to use the :class:`_types.NCHAR` and :class:`_oracle.NCLOB` datatypes explicitly, or to pass the flag ``use_nchar_for_unicode=True`` to :func:`_sa.create_engine`, which will cause the SQLAlchemy dialect to use NCHAR/NCLOB for the :class:`.Unicode` / :class:`.UnicodeText` datatypes instead of VARCHAR/CLOB. .. versionchanged:: 1.3 The :class:`.Unicode` and :class:`.UnicodeText` datatypes now correspond to the ``VARCHAR2`` and ``CLOB`` Oracle Database datatypes unless the ``use_nchar_for_unicode=True`` is passed to the dialect when :func:`_sa.create_engine` is called. .. _cx_oracle_unicode_encoding_errors: Encoding Errors ^^^^^^^^^^^^^^^ For the unusual case that data in Oracle Database is present with a broken encoding, the dialect accepts a parameter ``encoding_errors`` which will be passed to Unicode decoding functions in order to affect how decoding errors are handled. The value is ultimately consumed by the Python `decode `_ function, and is passed both via cx_Oracle's ``encodingErrors`` parameter consumed by ``Cursor.var()``, as well as SQLAlchemy's own decoding function, as the cx_Oracle dialect makes use of both under different circumstances. .. versionadded:: 1.3.11 .. _cx_oracle_setinputsizes: Fine grained control over cx_Oracle data binding performance with setinputsizes ------------------------------------------------------------------------------- The cx_Oracle DBAPI has a deep and fundamental reliance upon the usage of the DBAPI ``setinputsizes()`` call. The purpose of this call is to establish the datatypes that are bound to a SQL statement for Python values being passed as parameters. While virtually no other DBAPI assigns any use to the ``setinputsizes()`` call, the cx_Oracle DBAPI relies upon it heavily in its interactions with the Oracle Database client interface, and in some scenarios it is not possible for SQLAlchemy to know exactly how data should be bound, as some settings can cause profoundly different performance characteristics, while altering the type coercion behavior at the same time. Users of the cx_Oracle dialect are **strongly encouraged** to read through cx_Oracle's list of built-in datatype symbols at https://cx-oracle.readthedocs.io/en/latest/api_manual/module.html#database-types. Note that in some cases, significant performance degradation can occur when using these types vs. not, in particular when specifying ``cx_Oracle.CLOB``. On the SQLAlchemy side, the :meth:`.DialectEvents.do_setinputsizes` event can be used both for runtime visibility (e.g. logging) of the setinputsizes step as well as to fully control how ``setinputsizes()`` is used on a per-statement basis. .. versionadded:: 1.2.9 Added :meth:`.DialectEvents.setinputsizes` Example 1 - logging all setinputsizes calls ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ The following example illustrates how to log the intermediary values from a SQLAlchemy perspective before they are converted to the raw ``setinputsizes()`` parameter dictionary. The keys of the dictionary are :class:`.BindParameter` objects which have a ``.key`` and a ``.type`` attribute:: from sqlalchemy import create_engine, event engine = create_engine("oracle+cx_oracle://scott:tiger@host/xe") @event.listens_for(engine, "do_setinputsizes") def _log_setinputsizes(inputsizes, cursor, statement, parameters, context): for bindparam, dbapitype in inputsizes.items(): log.info( "Bound parameter name: %s SQLAlchemy type: %r DBAPI object: %s", bindparam.key, bindparam.type, dbapitype, ) Example 2 - remove all bindings to CLOB ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ The ``CLOB`` datatype in cx_Oracle incurs a significant performance overhead, however is set by default for the ``Text`` type within the SQLAlchemy 1.2 series. This setting can be modified as follows:: from sqlalchemy import create_engine, event from cx_Oracle import CLOB engine = create_engine("oracle+cx_oracle://scott:tiger@host/xe") @event.listens_for(engine, "do_setinputsizes") def _remove_clob(inputsizes, cursor, statement, parameters, context): for bindparam, dbapitype in list(inputsizes.items()): if dbapitype is CLOB: del inputsizes[bindparam] .. _cx_oracle_lob: LOB Datatypes -------------- LOB datatypes refer to the "large object" datatypes such as CLOB, NCLOB and BLOB. Modern versions of cx_Oracle is optimized for these datatypes to be delivered as a single buffer. As such, SQLAlchemy makes use of these newer type handlers by default. To disable the use of newer type handlers and deliver LOB objects as classic buffered objects with a ``read()`` method, the parameter ``auto_convert_lobs=False`` may be passed to :func:`_sa.create_engine`, which takes place only engine-wide. .. _cx_oracle_returning: RETURNING Support ----------------- The cx_Oracle dialect implements RETURNING using OUT parameters. The dialect supports RETURNING fully. Two Phase Transactions Not Supported ------------------------------------ Two phase transactions are **not supported** under cx_Oracle due to poor driver support. The newer :ref:`oracledb` dialect however **does** support two phase transactions. .. _cx_oracle_numeric: Precision Numerics ------------------ SQLAlchemy's numeric types can handle receiving and returning values as Python ``Decimal`` objects or float objects. When a :class:`.Numeric` object, or a subclass such as :class:`.Float`, :class:`_oracle.DOUBLE_PRECISION` etc. is in use, the :paramref:`.Numeric.asdecimal` flag determines if values should be coerced to ``Decimal`` upon return, or returned as float objects. To make matters more complicated under Oracle Database, the ``NUMBER`` type can also represent integer values if the "scale" is zero, so the Oracle Database-specific :class:`_oracle.NUMBER` type takes this into account as well. The cx_Oracle dialect makes extensive use of connection- and cursor-level "outputtypehandler" callables in order to coerce numeric values as requested. These callables are specific to the specific flavor of :class:`.Numeric` in use, as well as if no SQLAlchemy typing objects are present. There are observed scenarios where Oracle Database may send incomplete or ambiguous information about the numeric types being returned, such as a query where the numeric types are buried under multiple levels of subquery. The type handlers do their best to make the right decision in all cases, deferring to the underlying cx_Oracle DBAPI for all those cases where the driver can make the best decision. When no typing objects are present, as when executing plain SQL strings, a default "outputtypehandler" is present which will generally return numeric values which specify precision and scale as Python ``Decimal`` objects. To disable this coercion to decimal for performance reasons, pass the flag ``coerce_to_decimal=False`` to :func:`_sa.create_engine`:: engine = create_engine("oracle+cx_oracle://dsn", coerce_to_decimal=False) The ``coerce_to_decimal`` flag only impacts the results of plain string SQL statements that are not otherwise associated with a :class:`.Numeric` SQLAlchemy type (or a subclass of such). .. versionchanged:: 1.2 The numeric handling system for cx_Oracle has been reworked to take advantage of newer cx_Oracle features as well as better integration of outputtypehandlers. ) annotationsN)base)OracleCompiler) OracleDialect)OracleExecutionContext)_OracleDateLiteralRender)exc)util)cursor) interfaces) processors)sqltypes)is_sql_compileric eZdZdZddZdZy)_OracleIntegerctSNintselfdbapis MD:\EasyAligner\venv\Lib\site-packages\sqlalchemy/dialects/oracle/cx_oracle.pyget_dbapi_typez_OracleInteger.get_dbapi_types  Nc|j}|j|jd| |tS|jtS)N arraysize outconverter)rvarSTRINGr!r)rdialectr r! cx_Oracles r_cx_oracle_varz_OracleInteger._cx_oracle_var sVMM zz    #,#8i   ?E>N>N   rcfd}|S)Nc(j|Sr)r')r name default_typesize precisionscaler%rs rhandlerz<_OracleInteger._cx_oracle_outputtypehandler..handlers&&w7 7r)rr%r/s`` r_cx_oracle_outputtypehandlerz+_OracleInteger._cx_oracle_outputtypehandlers 8rr)__name__ __module__ __qualname__rr'r1r0rrrrs  rrc"eZdZdZdZdZdZy)_OracleNumericFc|jdk(ry|jr5tjtj |j fd}|StjS)Nrc~t|ttfr|S||jr t|S|Sr) isinstancerfloat is_infinite)value processors rprocessz._OracleNumeric.bind_processor..process%s<ec5\2$U++&5+<+<+> <' Lr)r. asdecimalrto_decimal_processor_factorydecimalDecimal_effective_decimal_return_scaleto_float)rr%r>r=s @rbind_processorz_OracleNumeric.bind_processorsO ::? ^^"??!E!EI !N&& &rcyrr0)rr%coltypes rresult_processorz_OracleNumeric.result_processor1rc.|jfd}|S)Ncd}|r^ jr3|jk(r|}tj}ntj}n| jr|dk(ryj}n] jr3|jk(r|}tj}n/tj}n jr|dk(ryj}|j |d|j |S)Nrrr )r? NATIVE_FLOATrArB is_numberr#r!) r r*r+r,r-r.r"type_r&rs rr/z<_OracleNumeric._cx_oracle_outputtypehandler..handler7sL>>#y'='==!-'. '~~%1* $ ) 6 6>>#y'='== ,'. '~~%1* $ ) 6 6:: **)  r)r)rr%r/r&s` @rr1z+_OracleNumeric._cx_oracle_outputtypehandler4sMM * XrN)r2r3r4rMrErHr1r0rrr6r6sI'(/rr6ceZdZdZy) _OracleUUIDc|jSr)r$rs rrz_OracleUUID.get_dbapi_typegs ||rNr2r3r4rr0rrrPrPfsrrPceZdZdZy)_OracleBinaryFloatc|jSr)rLrs rrz!_OracleBinaryFloat.get_dbapi_typels!!!rNrRr0rrrTrTks"rrTc eZdZy)_OracleBINARY_FLOATNr2r3r4r0rrrWrWprrWc eZdZy)_OracleBINARY_DOUBLENrXr0rrr[r[trYrr[ceZdZdZy) _OracleNUMBERTN)r2r3r4rMr0rrr]r]xsIrr]ceZdZdZdZy) _CXOracleDatecyrr0rr%s rrEz_CXOracleDate.bind_processor}rIrc d}|S)Nc*||jS|Sr)dater<s rr>z/_CXOracleDate.result_processor..processs zz|# rr0)rr%rGr>s rrHz_CXOracleDate.result_processors  rN)r2r3r4rErHr0rrr_r_|s rr_ceZdZdZy)_CXOracleTIMESTAMPc$|j|Sr)_literal_processor_datetimeras rliteral_processorz$_CXOracleTIMESTAMP.literal_processors//88rN)r2r3r4rjr0rrrgrgs9rrgc eZdZy) _LOBDataTypeNrXr0rrrlrlrYrrlceZdZdZy) _OracleCharc|jSr) FIXED_CHARrs rrz_OracleChar.get_dbapi_typesrNrRr0rrrnrns rrnceZdZdZy) _OracleNCharc|jSr) FIXED_NCHARrs rrz_OracleNChar.get_dbapi_type   rNrRr0rrrrrr!rrrceZdZdZy)_OracleUnicodeStringNCHARc|jSr)NCHARrs rrz(_OracleUnicodeStringNCHAR.get_dbapi_type {{rNrRr0rrrxrxrrxceZdZdZy)_OracleUnicodeStringCHARc|jSr LONG_STRINGrs rrz'_OracleUnicodeStringCHAR.get_dbapi_typerurNrRr0rrr~r~rvrr~ceZdZdZy)_OracleUnicodeTextNCLOBc|jSrDB_TYPE_NVARCHARrs rrz&_OracleUnicodeTextNCLOB.get_dbapi_type%%%rNrRr0rrrr&rrceZdZdZy)_OracleUnicodeTextCLOBc|jSrrrs rrz%_OracleUnicodeTextCLOB.get_dbapi_typerrNrRr0rrrrrrrceZdZdZy) _OracleTextc|jSrrrs rrz_OracleText.get_dbapi_typerrNrRr0rrrrrrrceZdZdZy) _OracleLongc|jSrrrs rrz_OracleLong.get_dbapi_typerurNrRr0rrrrrvrrc eZdZy) _OracleStringNrXr0rrrrrYrrceZdZdZy) _OracleEnumcRtjj||fd}|S)Nc|}|Srr0)r<raw_str enum_procs rr>z+_OracleEnum.bind_processor..processs&GNr)rEnumrE)rr%r>rs @rrEz_OracleEnum.bind_processors%MM00w?  rN)r2r3r4rEr0rrrrsrrc*eZdZdZdZfdZxZS) _OracleBinaryc|jSr) DB_TYPE_RAWrs rrz_OracleBinary.get_dbapi_types   rcyrr0ras rrEz_OracleBinary.bind_processorrIrc>|jsyt| ||Sr)auto_convert_lobssuperrH)rr%rG __class__s rrHz_OracleBinary.result_processors!((7+GW= =r)r2r3r4rrErH __classcell__rs@rrrs! >>rrceZdZdZy)_OracleIntervalc|jSr)INTERVALrs rrz_OracleInterval.get_dbapi_types ~~rNrRr0rrrrsrrc eZdZy) _OracleRawNrXr0rrrrrYrrceZdZdZy) _OracleRowidc|jSr)ROWIDrs rrz_OracleRowid.get_dbapi_typer{rNrRr0rrrrr|rrcVeZdZdZdZej dddddddddddd ZdZy ) OracleCompiler_cx_oracleTFPAZC) %():.[] \/?c 6t|dd}|dus1|durPjj|r5|jdds#d|z}||d<|}t j |fi|S|jdd}|sj j|rGj jfd|}|djs|dd k(rd |z}||d<|}n'|djs|dd k(r d |z}||d<|}t j |fi|S) NquoteTF post_compilez"%s" escaped_fromc@j|jdSNr)_bind_translate_charsgroup)mrs rz;OracleCompiler_cx_oracle.bindparam_string..,sd88Drr_D) getattrpreparer_bindparam_requires_quotesgetrbindparam_string_bind_translate_researchsubisdigit)rr*kwr quoted_namernew_names` rrz)OracleCompiler_cx_oracle.bindparam_string s8gt, TME! 88> FF>51!4-K!%B~ D!224DD Dvvnd3 &&--d3 2266DA;&&(HQK3,>"X~H%)>"a"d1gn:%)>"..tT@R@@rN) r2r3r4_oracle_cx_sql_compiler_oracle_returningr immutabledictbindname_escape_charactersrr0rrrrsO" "4!3!3 " +ArrcReZdZdZdZdZdZfdZdZdZ dd d Z d Z xZ S) OracleExecutionContext_cx_oracleNc|jjs|jjrZ|j}|Jt |j }|jj }|jjjD]}|js|jj|}|jj|j}t|dr-|j|j|j |||<nF|j#|jj$}|jj$}|J|0t'j(d|j*d|jdt-|t.rZ||j0k(r |j2}n||j4k(r |j6}|j j9|d|||<nkt-|t:r;|j<r/|j j9t>j@|||<n |j j9||||<|j D]} ||| |jC||<yy)Nr'r!z*Cannot create out parameter for parameter z - its type z is not supported by cx_oraclec"|jSr)readres rrzOOracleExecutionContext_cx_oracle._generate_out_parameter_vars..ws 5::s9 == + +t}}/N/N!00N!- --T__-J $ @ @ !]]00779 ''==33I>D ) ; ;DLL IIy*:;/8/G/G LL$++0H0t,"+!9!9$,,:L:L!M$(LL$6$6 (444!>"%"9"91: y~~!O#&&i>%)C)CC)2!'9+@+@!@)248;;?? &.H*4 4C4N40'y.A ) 3 337;;?? '*44C4N40 48;;?? &*4C4N40"&*40/33D$?@"1A:0Orc@ i |jjD]Q\}}}}|j|jd|j}|s2|jj |}| |<S r.|j j fd}||j_yy)Ncx_oracle_outputtypehandlercF|vr|||||||S||||||Srr0)r r*r+r,r-r.default_handleroutput_handlerss routput_type_handlerzaOracleExecutionContext_cx_oracle._generate_cursor_outputtype_handler..output_type_handlersJ?*0?40lD)U+lD)Ur) r_result_columns_cached_custom_processorr%_get_cx_oracle_type_handlerdenormalize_name_dbapi_connectionoutputtypehandlerr ) rkeynamer*objectsrNr/denormalized_namerrrs @@r#_generate_cursor_outputtype_handlerzDOracleExecutionContext_cx_oracle._generate_cursor_outputtype_handlers-1]]-J-J )GT7E44 -00G $(LL$A$A'$J!5< 12.K "44FFO -@DKK ) rcRt|dr|j|jSy)Nr1)rr1r%)rimpls rrz!>!>]]D)!> . N*8D &0/ sB0 c|jj}|jjr|jj|_|Sr)rr r%r!)rcs r create_cursorz.OracleExecutionContext_cx_oracle.create_cursors9  " " ) ) + << ! !,,00AKrFrcl|j}|s|t|r |js tdt |j }t tt|Dcgc]9}|j d|jDcgc]}|xsdD]}|c}};c}}}Scc}}wcc}}}w)Nz7execution context was not prepared for Oracle RETURNINGret_r0) rrrNotImplementedErrorrrlistzipranger)rr rrnumcolsj stmt_resultvals rrz7OracleExecutionContext_cx_oracle.fetchall_for_returnings== "8,--%I d))*  #7^ , ,0+>+>"1#J, &,!,!K%0$52$5C %6 ,!,     s!$B/B)B/)B/c|jjrJ|Dcgc]*}|jj|j|,c}Scc}wr)r returningr% _paramvalr)rout_param_namesr*s rget_out_parameter_valuesz9OracleExecutionContext_cx_oracle.get_out_parameter_valuessX==****( ' LL " "4#6#6t#< ='   s/A) r2r3r4rrr rrrrrr,rrs@rrr;s:NM^@> 38*;@# J  rrcNeZdZdZeZeZdZdZ dZ dZ dZ dZ ejj ZdZej(ej,iej0eej4eej8eej<eej@e!ejDe#ejHe%ejLe'ejPe)ejTejVejXe-ej\e-ej^e0ejbe2ejfe4ejje6ejne8ejre:ejveej~e@ejeBejeDejeFejeHiZeIZJdZKejZMejd ddZOdZPeQdZRfd ZSd ZTfd ZUd ZVd ZWdZXeYjZ[dZ\dZ]dZ^dZ_dZ`dZaddZbdZcdZd ddZe ddZfdZgdZhxZiS)OracleDialect_cx_oracleT cx_oracleN)1.3aAThe 'threaded' parameter to the cx_oracle/oracledb dialect is deprecated as a dialect-level argument, and will be removed in a future release. As of version 1.3, it defaults to False rather than True. The 'threaded' option can be passed to cx_Oracle directly in the URL query string passed to :func:`_sa.create_engine`.)threadedc tj|fi|||_||_|r d|i|_|||_||_||_|jra|jj|_ t|jtj<t|jtj<|j }|j#|||j$|j&|j(|j*|j,|j.|j0|j2|j4|j6|j8t:|j<h |_d|_ yy)NencodingErrorsc"|jSr)getvalueres rrz2OracleDialect_cx_oracle.__init__..~s 5>>+;r)!r__init__r!encoding_errors_cursor_var_unicode_kwargs_cx_oracle_threadedrcoerce_to_decimal_use_nchar_for_unicodecolspecscopyrxrUnicoder UnicodeTextr _load_versionDATETIMErrrCLOBLOBrrzrtrp TIMESTAMPrrLinclude_set_input_sizesr*)rrr:r!r7r1kwargs dbapi_modules rr6z OracleDialect_cx_oracle.__init__@sC( t.v.".  //D +  '/D $!2!2  & & MM..0DM.GDMM(** +2IDMM(.. /zz  <(  #%%--((""!!  !!""((''&&)),D ("z8OracleDialect_cx_oracle._load_version..s $4q CF$4srr )z+cx_Oracle version 8 and above are supported)rematchversiontupler cx_oracle_verr r)rrGrRrs rr@z%OracleDialect_cx_oracle._load_versions  #4l6J6JKA $%GGAq!$4 %    $););i)G))= *H $rcddl}|Sr)r&)clsr&s r import_dbapiz$OracleDialect_cx_oracle.import_dbapis rcFt|||j|yr)r initialize_detect_decimal_char)r connectionrs rrYz"OracleDialect_cx_oracle.initializes :& !!*-rct|j5}|jt}|jdd|i|j }|j dd\}}}|jd|||d|j }|tjd|d} ddd| S#1swY SxYw) Nz begin :trans_id := dbms_transaction.local_transaction_id( TRUE ); end; trans_idrrNzSELECT CASE BITAND(t.flag, POWER(2, 28)) WHEN 0 THEN 'READ COMMITTED' ELSE 'SERIALIZABLE' END AS isolation_level FROM v$transaction t WHERE (t.xidusn, t.xidslot, t.xidsqn) = ((:xidusn, :xidslot, :xidsqn)))xidusnxidslotxidsqnz"could not retrieve isolation levelr) r r#strexecuter5splitfetchoner r) rdbapi_connectionr outvalr]r^r_r`rowresults rget_isolation_levelz+OracleDialect_cx_oracle.get_isolation_levels $ $ && ZZ_F NN V$  (H&.nnS!&< #FGV NN1 "gH //#C{--8VF?'B C'B s BB--B7c*t||dgzS)N AUTOCOMMIT)rget_isolation_level_values)rrers rrlz2OracleDialect_cx_oracle.get_isolation_level_valuess$w12BC G   rc|dk(rd|_yd|_|j|j5}|jd|dddy#1swYyxYw)NrkTFz"ALTER SESSION SET ISOLATION_LEVEL=) autocommitrollbackr rb)rrelevelr s rset_isolation_levelz+OracleDialect_cx_oracle.set_isolation_levelsV L *.  '*/  '  % % '!((*f!CE7KL+**s AAc|j}|j5}fd}||_|jd|j d}|j dd}|dj rJ ddd_jdk7r/jjfd_fd_ yy#1swYOxYw) Nch|jjjd|jS)Nrr)r#rr$r!)r r* defaultTyper,r-r.rs rrzIOracleDialect_cx_oracle._detect_decimal_char..output_type_handlers2zzJJ%%sf6F6F"rzSELECT 1.1 FROM DUALr0rrcH|jjdSNrreplace _decimal_char)r<_detect_decimalrs rrz>OracleDialect_cx_oracle._detect_decimal_char..s d00#62rcH|jjdSrwrx)r< _to_decimalrs rrz>OracleDialect_cx_oracle._detect_decimal_char..s[ d00#6.r) r[r rrbrdlstriprrzr{r}) rr[rer rr< decimal_charr{r}s ` @@rrZz,OracleDialect_cx_oracle._detect_decimal_chars&00  $ $ && (;F $ NN1 2OO%a(E <<,Q/L#A..0 000+'.*    $"22O**K$D  D  %3' &s AC  CcBd|vr|j|St|Srw)r}r)rr<s rr{z'OracleDialect_cx_oracle._detect_decimals$ %<##E* *u: rc|jtdjtdjfd}|S)z^establish the default outputtypehandler established at the connection level. T)r?Fcr|jk(rx|jurjjsy|dk(r7|dvr3|jjdj |j S|r|dkDr  ||||||S ||||||Sjrc|jjfvrI|jur;|jur-|jt||j fijSjrm|jjfvrS|jur jn j}|j|t|j fijSjr;|j fvr+|jj"t|j Syy)Nr)rirr)NUMBERrLr:r#r$r{r!r8rprBrrarDB_TYPE_VARCHARr_CX_ORACLE_MAGIC_LOB_SIZErr) r r*r+r,r-r.typr&r% float_handlernumber_handlers rrz\OracleDialect_cx_oracle._generate_connection_outputtype_handler..output_type_handlers 0 00 (>(>>00!^(:"::!((%,%<%<"("2"2 & 519)lD)U)lD)U22 $$(( ! 6 7!vzz$$88 **|@0 $y~~5--"33 "vzz-$$88 **|@0zz))-$$0*r)rr]r1)rrr&r%rrs @@@@r'_generate_connection_outputtype_handlerz?OracleDialect_cx_oracle._generate_connection_outputtype_handler sZ MM & & &w / & & &w / E N#"rc2|jfd}|S)Nc|_yr)r)connrs r on_connectz6OracleDialect_cx_oracle.on_connect..on_connectfs %8D "r)r)rrrs @rrz"OracleDialect_cx_oracle.on_connectcs"JJL 9rct|j}dD]e}||vstjjd|ddtj ||t t||j|g|j}|jdd}|s|rj|j}|r t|}nd}|r|rtjd|rd |i}|rd|i}jj|j |fi}n |j }|||d <|j"|j"|d <|j$|j$|d <j&|j)d j&fd} tj |d| tj |d t tj |dt tj |d| g|fS)N)use_ansirz dialect option zK should only be passed to create_engine directly, not within the URL stringr0)rR service_nameizI"service_name" option shouldn't be used with a "database" part of the urlsiddsnpassworduserr1ct|tr t|}|S|S#t$r)|j }t j |cYSwxYwr)r9rar ValueErrorupperrr)r<int_valrs rconvert_cx_oracle_constantzOOracleDialect_cx_oracle.create_connect_args..convert_cx_oracle_constantsT%%#!%jG #N "6!KKME"4::u556s "/AAmodeeventspurity)dictqueryr warn_deprecateddrivercoerce_kw_typeboolsetattrpopdatabaseportrr rrmakedsnhostrusernamer9 setdefault) rurloptsoptrrrmakedsn_kwargsrrs ` rcreate_connect_argsz+OracleDialect_cx_oracle.create_connect_argsksCII4Cd{$${{m#3C7;"  ##D#t4c488C=15<<xx5 |88D4yL--@"'!2"0,!?$$**$$SXXtF~FC((C ?DK << #"||D  << #<.sN%MSV%Msr)rSr[rRrcrr[s r_get_server_version_infoz0OracleDialect_cx_oracle._get_server_version_infos*NZ%:%:%B%B%H%H%MNNNrc|j\}t||jj|jjfrdt |vryt |dr|jdvrytjdt |ryy)Nz not connectedTcode> ) * ? \ z(^(?:DPI-1010|DPI-1080|DPY-1001|DPY-4011)F) argsr9rInterfaceError DatabaseErrorrarrrPrQ)rer[r errors r is_disconnectz%OracleDialect_cx_oracle.is_disconnects|66   ))4::+C+CD Q' 5& !ejj5 '  88?Q HrcJtjdddz}dd|zddzfS)NrrNi4z%032x )randomrandint)rid_s r create_xidz"OracleDialect_cx_oracle.create_xids+nnQ3'# w{33rc^t|tr t|}|j||yr)r9rSr! executemany)rr statementrcontexts rdo_executemanyz&OracleDialect_cx_oracle.do_executemanys& j% (j)J9j1rch|jj|||jjd<y)N cx_oracle_xid)r[begininfo)rr[xids rdo_begin_twophasez)OracleDialect_cx_oracle.do_begin_twophases.# ##S)69 ""?3rcV|jj}||jd<y)Ncx_oracle_prepared)r[preparer)rr[rrhs rdo_prepare_twophasez+OracleDialect_cx_oracle.do_prepare_twophases%&&..006 ,-rc:|j|jyr) do_rollbackr[)rr[r is_preparedrecovers rdo_rollback_twophasez,OracleDialect_cx_oracle.do_rollback_twophases ../rc|s|j|jy|r td|jd}|r|j|jyy)Nz*2pc recovery not implemented for cx_Oracler) do_commitr[r r)rr[rrr oci_prepareds rdo_commit_twophasez*OracleDialect_cx_oracle.do_commit_twophasesW NN:00 1)@&??+?@Lz445rc |jr&|j|Dcgc]\}}}| c}}}yd|D}|jdi|Dcic]\}}|| c}}ycc}}}wcc}}w)Nc30K|]\}}}|r||fywrr0)rKrrsqltypes rrMz=OracleDialect_cx_oracle.do_set_input_sizes..s&,:(Cf ,:sr0) positional setinputsizes)rr list_of_tuplesrrrr collections rdo_set_input_sizesz*OracleDialect_cx_oracle.do_set_input_sizess{ ?? !F 5CD^1S&'&^D ,:J !F O:#N:KCCK:#N OE$Os A#  A*ctd)Nz5recover two phase query for cx_Oracle not implemented)r rs rdo_recover_twophasez+OracleDialect_cx_oracle.do_recover_twophase s! C  r)TTNNNr)TF)jr2r3r4supports_statement_cacherexecution_ctx_clsrstatement_compilersupports_sane_rowcountsupports_sane_multi_rowcountinsert_executemany_returning4insert_executemany_returning_sort_by_parameter_orderupdate_executemany_returningdelete_executemany_returningr BindTyping SETINPUTSIZES bind_typingrr update_copyrr<rrDrgNumericr6Floatoracle BINARY_FLOATrW BINARY_DOUBLEr[Integerrrr]Dater_ LargeBinaryrBoolean_OracleBooleanIntervalrrTextrStringrr?rCHARrnrzrrrrLONGrRAWrr>r~NVARCHARrxUuidrPrrrrr!execute_sequence_formatr9rr8deprecated_paramsr6r@ classmethodrWrYrirlrqrZr{rArBr}rrrrrrrrrrrrrrrs@rr.r. s#81!#' #' ;?8#' #' ''55K Ft    2   n  NNN    !4   "6    n   MM=  MM=   -    f33      OO_  MM;  OO]   "8 MM;! " NNL# $ MM; KK JJ   6   8 MM; LL1 LL,3 H>#!3!3!3!5T   3< 3r~rrr?rrrrrrrrrrrrrrrrrrrr.r%r0rrrsaD#  (+' *#X%%,IX%%IX(-- ""  ,f.A.A  -v/C/C N F&& 9183E3E9    (-- !8>>!  0 0 !x//! &lFLL&&\8+?+?&&, &!, !  HOO (-->L("6"6>"foo   6<< DA~DANL '=L ^C mC L "r