U
|
¸ý°d6k ã @ sþ d Z ddlZddlZddlZddlZddlmZ ddlmZ ddlmZ ddlm Z ddlm
|
Z
|
dd lm Z dd
|
lm Z dd lm Z dd lmZ dd lmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ G dd dZ G dd de ej Z G dd de ej Z G dd dZ!G d d d Z"G d d d e"eZ#G d d! d!e"e
|
Z$G d"d# d#e!e Z%G d$d% d%e!e Z&G d&d' d'ej'Z(G d(d) d)eZ)G d*d+ d+eZ*G d,d- d-eZ+G d.d/ d/eZ,G d0d1 d1eZ-G d2d3 d3e Z.G d4d5 d5ee Z/e/Z0dS )6ay6
|
.. dialect:: mssql+pyodbc
|
:name: PyODBC
|
:dbapi: pyodbc
|
:connectstring: mssql+pyodbc://<username>:<password>@<dsnname>
|
:url: https://pypi.org/project/pyodbc/
|
|
Connecting to PyODBC
|
--------------------
|
|
The URL here is to be translated to PyODBC connection strings, as
|
detailed in `ConnectionStrings <https://code.google.com/p/pyodbc/wiki/ConnectionStrings>`_.
|
|
DSN Connections
|
^^^^^^^^^^^^^^^
|
|
A DSN connection in ODBC means that a pre-existing ODBC datasource is
|
configured on the client machine. The application then specifies the name
|
of this datasource, which encompasses details such as the specific ODBC driver
|
in use as well as the network address of the database. Assuming a datasource
|
is configured on the client, a basic DSN-based connection looks like::
|
|
engine = create_engine("mssql+pyodbc://scott:tiger@some_dsn")
|
|
Which above, will pass the following connection string to PyODBC::
|
|
DSN=some_dsn;UID=scott;PWD=tiger
|
|
If the username and password are omitted, the DSN form will also add
|
the ``Trusted_Connection=yes`` directive to the ODBC string.
|
|
Hostname Connections
|
^^^^^^^^^^^^^^^^^^^^
|
|
Hostname-based connections are also supported by pyodbc. These are often
|
easier to use than a DSN and have the additional advantage that the specific
|
database name to connect towards may be specified locally in the URL, rather
|
than it being fixed as part of a datasource configuration.
|
|
When using a hostname connection, the driver name must also be specified in the
|
query parameters of the URL. As these names usually have spaces in them, the
|
name must be URL encoded which means using plus signs for spaces::
|
|
engine = create_engine("mssql+pyodbc://scott:tiger@myhost:port/databasename?driver=ODBC+Driver+17+for+SQL+Server")
|
|
The ``driver`` keyword is significant to the pyodbc dialect and must be
|
specified in lowercase.
|
|
Any other names passed in the query string are passed through in the pyodbc
|
connect string, such as ``authentication``, ``TrustServerCertificate``, etc.
|
Multiple keyword arguments must be separated by an ampersand (``&``); these
|
will be translated to semicolons when the pyodbc connect string is generated
|
internally::
|
|
e = create_engine(
|
"mssql+pyodbc://scott:tiger@mssql2017:1433/test?"
|
"driver=ODBC+Driver+18+for+SQL+Server&TrustServerCertificate=yes"
|
"&authentication=ActiveDirectoryIntegrated"
|
)
|
|
The equivalent URL can be constructed using :class:`_sa.engine.URL`::
|
|
from sqlalchemy.engine import URL
|
connection_url = URL.create(
|
"mssql+pyodbc",
|
username="scott",
|
password="tiger",
|
host="mssql2017",
|
port=1433,
|
database="test",
|
query={
|
"driver": "ODBC Driver 18 for SQL Server",
|
"TrustServerCertificate": "yes",
|
"authentication": "ActiveDirectoryIntegrated",
|
},
|
)
|
|
|
Pass through exact Pyodbc string
|
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
|
A PyODBC connection string can also be sent in pyodbc's format directly, as
|
specified in `the PyODBC documentation
|
<https://github.com/mkleehammer/pyodbc/wiki/Connecting-to-databases>`_,
|
using the parameter ``odbc_connect``. A :class:`_sa.engine.URL` object
|
can help make this easier::
|
|
from sqlalchemy.engine import URL
|
connection_string = "DRIVER={SQL Server Native Client 10.0};SERVER=dagger;DATABASE=test;UID=user;PWD=password"
|
connection_url = URL.create("mssql+pyodbc", query={"odbc_connect": connection_string})
|
|
engine = create_engine(connection_url)
|
|
.. _mssql_pyodbc_access_tokens:
|
|
Connecting to databases with access tokens
|
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
|
Some database servers are set up to only accept access tokens for login. For
|
example, SQL Server allows the use of Azure Active Directory tokens to connect
|
to databases. This requires creating a credential object using the
|
``azure-identity`` library. More information about the authentication step can be
|
found in `Microsoft's documentation
|
<https://docs.microsoft.com/en-us/azure/developer/python/azure-sdk-authenticate?tabs=bash>`_.
|
|
After getting an engine, the credentials need to be sent to ``pyodbc.connect``
|
each time a connection is requested. One way to do this is to set up an event
|
listener on the engine that adds the credential token to the dialect's connect
|
call. This is discussed more generally in :ref:`engines_dynamic_tokens`. For
|
SQL Server in particular, this is passed as an ODBC connection attribute with
|
a data structure `described by Microsoft
|
<https://docs.microsoft.com/en-us/sql/connect/odbc/using-azure-active-directory#authenticating-with-an-access-token>`_.
|
|
The following code snippet will create an engine that connects to an Azure SQL
|
database using Azure credentials::
|
|
import struct
|
from sqlalchemy import create_engine, event
|
from sqlalchemy.engine.url import URL
|
from azure import identity
|
|
SQL_COPT_SS_ACCESS_TOKEN = 1256 # Connection option for access tokens, as defined in msodbcsql.h
|
TOKEN_URL = "https://database.windows.net/" # The token URL for any Azure SQL database
|
|
connection_string = "mssql+pyodbc://@my-server.database.windows.net/myDb?driver=ODBC+Driver+17+for+SQL+Server"
|
|
engine = create_engine(connection_string)
|
|
azure_credentials = identity.DefaultAzureCredential()
|
|
@event.listens_for(engine, "do_connect")
|
def provide_token(dialect, conn_rec, cargs, cparams):
|
# remove the "Trusted_Connection" parameter that SQLAlchemy adds
|
cargs[0] = cargs[0].replace(";Trusted_Connection=Yes", "")
|
|
# create token credential
|
raw_token = azure_credentials.get_token(TOKEN_URL).token.encode("utf-16-le")
|
token_struct = struct.pack(f"<I{len(raw_token)}s", len(raw_token), raw_token)
|
|
# apply it to keyword arguments
|
cparams["attrs_before"] = {SQL_COPT_SS_ACCESS_TOKEN: token_struct}
|
|
.. tip::
|
|
The ``Trusted_Connection`` token is currently added by the SQLAlchemy
|
pyodbc dialect when no username or password is present. This needs
|
to be removed per Microsoft's
|
`documentation for Azure access tokens
|
<https://docs.microsoft.com/en-us/sql/connect/odbc/using-azure-active-directory#authenticating-with-an-access-token>`_,
|
stating that a connection string when using an access token must not contain
|
``UID``, ``PWD``, ``Authentication`` or ``Trusted_Connection`` parameters.
|
|
.. _azure_synapse_ignore_no_transaction_on_rollback:
|
|
Avoiding transaction-related exceptions on Azure Synapse Analytics
|
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
|
Azure Synapse Analytics has a significant difference in its transaction
|
handling compared to plain SQL Server; in some cases an error within a Synapse
|
transaction can cause it to be arbitrarily terminated on the server side, which
|
then causes the DBAPI ``.rollback()`` method (as well as ``.commit()``) to
|
fail. The issue prevents the usual DBAPI contract of allowing ``.rollback()``
|
to pass silently if no transaction is present as the driver does not expect
|
this condition. The symptom of this failure is an exception with a message
|
resembling 'No corresponding transaction found. (111214)' when attempting to
|
emit a ``.rollback()`` after an operation had a failure of some kind.
|
|
This specific case can be handled by passing ``ignore_no_transaction_on_rollback=True`` to
|
the SQL Server dialect via the :func:`_sa.create_engine` function as follows::
|
|
engine = create_engine(connection_url, ignore_no_transaction_on_rollback=True)
|
|
Using the above parameter, the dialect will catch ``ProgrammingError``
|
exceptions raised during ``connection.rollback()`` and emit a warning
|
if the error message contains code ``111214``, however will not raise
|
an exception.
|
|
.. versionadded:: 1.4.40 Added the
|
``ignore_no_transaction_on_rollback=True`` parameter.
|
|
Enable autocommit for Azure SQL Data Warehouse (DW) connections
|
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
|
Azure SQL Data Warehouse does not support transactions,
|
and that can cause problems with SQLAlchemy's "autobegin" (and implicit
|
commit/rollback) behavior. We can avoid these problems by enabling autocommit
|
at both the pyodbc and engine levels::
|
|
connection_url = sa.engine.URL.create(
|
"mssql+pyodbc",
|
username="scott",
|
password="tiger",
|
host="dw.azure.example.com",
|
database="mydb",
|
query={
|
"driver": "ODBC Driver 17 for SQL Server",
|
"autocommit": "True",
|
},
|
)
|
|
engine = create_engine(connection_url).execution_options(
|
isolation_level="AUTOCOMMIT"
|
)
|
|
Avoiding sending large string parameters as TEXT/NTEXT
|
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
|
By default, for historical reasons, Microsoft's ODBC drivers for SQL Server
|
send long string parameters (greater than 4000 SBCS characters or 2000 Unicode
|
characters) as TEXT/NTEXT values. TEXT and NTEXT have been deprecated for many
|
years and are starting to cause compatibility issues with newer versions of
|
SQL_Server/Azure. For example, see `this
|
issue <https://github.com/mkleehammer/pyodbc/issues/835>`_.
|
|
Starting with ODBC Driver 18 for SQL Server we can override the legacy
|
behavior and pass long strings as varchar(max)/nvarchar(max) using the
|
``LongAsMax=Yes`` connection string parameter::
|
|
connection_url = sa.engine.URL.create(
|
"mssql+pyodbc",
|
username="scott",
|
password="tiger",
|
host="mssqlserver.example.com",
|
database="mydb",
|
query={
|
"driver": "ODBC Driver 18 for SQL Server",
|
"LongAsMax": "Yes",
|
},
|
)
|
|
|
Pyodbc Pooling / connection close behavior
|
------------------------------------------
|
|
PyODBC uses internal `pooling
|
<https://github.com/mkleehammer/pyodbc/wiki/The-pyodbc-Module#pooling>`_ by
|
default, which means connections will be longer lived than they are within
|
SQLAlchemy itself. As SQLAlchemy has its own pooling behavior, it is often
|
preferable to disable this behavior. This behavior can only be disabled
|
globally at the PyODBC module level, **before** any connections are made::
|
|
import pyodbc
|
|
pyodbc.pooling = False
|
|
# don't use the engine before pooling is set to False
|
engine = create_engine("mssql+pyodbc://user:pass@dsn")
|
|
If this variable is left at its default value of ``True``, **the application
|
will continue to maintain active database connections**, even when the
|
SQLAlchemy engine itself fully discards a connection or if the engine is
|
disposed.
|
|
.. seealso::
|
|
`pooling <https://github.com/mkleehammer/pyodbc/wiki/The-pyodbc-Module#pooling>`_ -
|
in the PyODBC documentation.
|
|
Driver / Unicode Support
|
-------------------------
|
|
PyODBC works best with Microsoft ODBC drivers, particularly in the area
|
of Unicode support on both Python 2 and Python 3.
|
|
Using the FreeTDS ODBC drivers on Linux or OSX with PyODBC is **not**
|
recommended; there have been historically many Unicode-related issues
|
in this area, including before Microsoft offered ODBC drivers for Linux
|
and OSX. Now that Microsoft offers drivers for all platforms, for
|
PyODBC support these are recommended. FreeTDS remains relevant for
|
non-ODBC drivers such as pymssql where it works very well.
|
|
|
Rowcount Support
|
----------------
|
|
Previous limitations with the SQLAlchemy ORM's "versioned rows" feature with
|
Pyodbc have been resolved as of SQLAlchemy 2.0.5. See the notes at
|
:ref:`mssql_rowcount_versioning`.
|
|
.. _mssql_pyodbc_fastexecutemany:
|
|
Fast Executemany Mode
|
---------------------
|
|
The PyODBC driver includes support for a "fast executemany" mode of execution
|
which greatly reduces round trips for a DBAPI ``executemany()`` call when using
|
Microsoft ODBC drivers, for **limited size batches that fit in memory**. The
|
feature is enabled by setting the attribute ``.fast_executemany`` on the DBAPI
|
cursor when an executemany call is to be used. The SQLAlchemy PyODBC SQL
|
Server dialect supports this parameter by passing the
|
``fast_executemany`` parameter to
|
:func:`_sa.create_engine` , when using the **Microsoft ODBC driver only**::
|
|
engine = create_engine(
|
"mssql+pyodbc://scott:tiger@mssql2017:1433/test?driver=ODBC+Driver+17+for+SQL+Server",
|
fast_executemany=True)
|
|
.. versionchanged:: 2.0.9 - the ``fast_executemany`` parameter now has its
|
intended effect of this PyODBC feature taking effect for all INSERT
|
statements that are executed with multiple parameter sets, which don't
|
include RETURNING. Previously, SQLAlchemy 2.0's :term:`insertmanyvalues`
|
feature would cause ``fast_executemany`` to not be used in most cases
|
even if specified.
|
|
.. versionadded:: 1.3
|
|
.. seealso::
|
|
`fast executemany <https://github.com/mkleehammer/pyodbc/wiki/Features-beyond-the-DB-API#fast_executemany>`_
|
- on github
|
|
.. _mssql_pyodbc_setinputsizes:
|
|
Setinputsizes Support
|
-----------------------
|
|
As of version 2.0, the pyodbc ``cursor.setinputsizes()`` method is used for
|
all statement executions, except for ``cursor.executemany()`` calls when
|
fast_executemany=True where it is not supported (assuming
|
:ref:`insertmanyvalues <engine_insertmanyvalues>` is kept enabled,
|
"fastexecutemany" will not take place for INSERT statements in any case).
|
|
The use of ``cursor.setinputsizes()`` can be disabled by passing
|
``use_setinputsizes=False`` to :func:`_sa.create_engine`.
|
|
When ``use_setinputsizes`` is left at its default of ``True``, the
|
specific per-type symbols passed to ``cursor.setinputsizes()`` can be
|
programmatically customized using the :meth:`.DialectEvents.do_setinputsizes`
|
hook. See that method for usage examples.
|
|
.. versionchanged:: 2.0 The mssql+pyodbc dialect now defaults to using
|
``use_setinputsizes=True`` for all statement executions with the exception of
|
cursor.executemany() calls when fast_executemany=True. The behavior can
|
be turned off by passing ``use_setinputsizes=False`` to
|
:func:`_sa.create_engine`.
|
|
é Né )Ú _MSDateTime)Ú
|
_MSUnicode)Ú_MSUnicodeText)ÚBINARY)ÚDATETIMEOFFSET)Ú MSDialect)ÚMSExecutionContext)Ú VARBINARY)ÚJSON)Ú JSONIndexType)Ú JSONPathTypeé )Úexc)Útypes)Úutil)ÚPyODBCConnectorc s0 e Zd ZdZ fddZdd Zdd Z ZS )Ú_ms_numeric_pyodbcz¡Turns Decimals with adjusted() < 0 or > 7 into strings.
|
|
The routines here are needed for older pyodbc versions
|
as well as current mxODBC versions.
|
|
c s( t |¡|jsS fdd}|S )Nc sR j r>t| tjr>| ¡ }|dk r, | ¡S |dkr> | ¡S rJ| S | S d S )Nr é )Z asdecimalÚ
|
isinstanceÚdecimalÚDecimalÚadjustedÚ_small_dec_to_stringÚ_large_dec_to_string)Úvaluer ©ÚselfZ super_process© úWd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\sqlalchemy/dialects/mssql/pyodbc.pyÚprocess s
|
|
z2_ms_numeric_pyodbc.bind_processor.<locals>.process)ÚsuperÚbind_processorÚ_need_decimal_fix©r Údialectr ©Ú __class__r r r" { s
|
z!_ms_numeric_pyodbc.bind_processorc C sB d|dk rdpddt | ¡ d d dd | ¡ d D ¡f S ) Nz%s0.%s%sr ú-Ú Ú0r c S s g | ] }t |qS r ©Ústr)Ú.0Znintr r r Ú
|
<listcomp> s z;_ms_numeric_pyodbc._small_dec_to_string.<locals>.<listcomp>)Úabsr ÚjoinÚas_tuple)r r r r r r s
|
ýz'_ms_numeric_pyodbc._small_dec_to_stringc C s | ¡ d }dt|krXd|dk r&dp(dd dd |D ¡d | ¡ t|d f }n¨t|d | ¡ krÈd
|
|dk rzdp|dd d d |D d| ¡ d
¡d d d |D | ¡ d d
¡f }n8d |dk rÖdpØdd dd |D d| ¡ d
¡f }|S )Nr ÚEz%s%s%sr r( r) c S s g | ] }t |qS r r+ ©r- Úsr r r r. s z;_ms_numeric_pyodbc._large_dec_to_string.<locals>.<listcomp>r* z%s%s.%sc S s g | ] }t |qS r r+ r3 r r r r. § s c S s g | ] }t |qS r r+ r3 r r r r. ¨ s z%s%sc S s g | ] }t |qS r r+ r3 r r r r. s )r1 r, r0 r Úlen)r r Ú_intÚresultr r r r s$ ý""ý"þz'_ms_numeric_pyodbc._large_dec_to_string)Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__r" r r Ú __classcell__r r r& r r r s r c @ s e Zd ZdS )Ú_MSNumeric_pyodbcN©r8 r9 r: r r r r r= ² s r= c @ s e Zd ZdS )Ú_MSFloat_pyodbcNr> r r r r r? ¶ s r? c @ s e Zd ZdZdd ZdS )Ú_ms_binary_pyodbczÿWraps binary values in dialect-specific Binary wrapper.
|
If the value is null, return a pyodbc-specific BinaryNull
|
object to prevent pyODBC [and FreeTDS] from defaulting binary
|
NULL types to SQLWCHAR and causing implicit conversion errors.
|
c s( j d krd S j j fdd}|S )Nc s | d k r | S j jS d S ©N)ÚdbapiZ
|
BinaryNull)r ©Z DBAPIBinaryr% r r r Ç s z1_ms_binary_pyodbc.bind_processor.<locals>.process)rB ÚBinaryr$ r rC r r" Á s
|
|
z _ms_binary_pyodbc.bind_processorN)r8 r9 r: r; r" r r r r r@ º s r@ c @ s e Zd ZdZdZdd ZdS )Ú_ODBCDateTimeBindProcessorz6Add bind processors to handle datetimeoffset behaviorsFc s fdd}|S )Nc sP | d kr d S t | tr| S | jr, js0 js0| S | d¡}t dd|¡}|S d S )Nz%Y-%m-%d %H:%M:%S.%f %zz([\+\-]\d{2})([\d\.]+)$z\1:\2)r r, ÚtzinfoÚtimezoneÚhas_tzÚstrftimeÚreÚsub)r Z
|
dto_string©r r r r × s
|
|
ÿz:_ODBCDateTimeBindProcessor.bind_processor.<locals>.processr r$ r rL r r" Ö s z)_ODBCDateTimeBindProcessor.bind_processorN)r8 r9 r: r; rH r" r r r r rE Ñ s rE c @ s e Zd ZdS )Ú _ODBCDateTimeNr> r r r r rM ð s rM c @ s e Zd ZdZdS )Ú_ODBCDATETIMEOFFSETTN)r8 r9 r: rH r r r r rN ô s rN c @ s e Zd ZdS )Ú_VARBINARY_pyodbcNr> r r r r rO ø s rO c @ s e Zd ZdS )Ú_BINARY_pyodbcNr> r r r r rP ü s rP c @ s e Zd Zdd ZdS )Ú_String_pyodbcc C s* | j dks| j dkr |jddfS |jS d S ©N)NÚmaxiÐ r )ÚlengthZ SQL_VARCHAR©r rB r r r Úget_dbapi_type s z _String_pyodbc.get_dbapi_typeN©r8 r9 r: rV r r r r rQ s rQ c @ s e Zd Zdd ZdS )Ú_Unicode_pyodbcc C s* | j dks| j dkr |jddfS |jS d S rR ©rT Ú SQL_WVARCHARrU r r r rV s z _Unicode_pyodbc.get_dbapi_typeNrW r r r r rX s rX c @ s e Zd Zdd ZdS )Ú_UnicodeText_pyodbcc C s* | j dks| j dkr |jddfS |jS d S rR rY rU r r r rV s z"_UnicodeText_pyodbc.get_dbapi_typeNrW r r r r r[ s r[ c @ s e Zd Zdd ZdS )Ú _JSON_pyodbcc C s |j ddfS ©Nr ©rZ rU r r r rV s z_JSON_pyodbc.get_dbapi_typeNrW r r r r r\ s r\ c @ s e Zd Zdd ZdS )Ú_JSONIndexType_pyodbcc C s |j S rA r^ rU r r r rV s z$_JSONIndexType_pyodbc.get_dbapi_typeNrW r r r r r_ s r_ c @ s e Zd Zdd ZdS )Ú_JSONPathType_pyodbcc C s |j S rA r^ rU r r r rV # s z#_JSONPathType_pyodbc.get_dbapi_typeNrW r r r r r` " s r` c s, e Zd ZdZ fddZ fddZ ZS )ÚMSExecutionContext_pyodbcFc s> t ¡ | jr:| jjr:t| jd r:d| _| jd7 _dS )a¼ where appropriate, issue "select scope_identity()" in the same
|
statement.
|
|
Background on why "scope_identity()" is preferable to "@@identity":
|
https://msdn.microsoft.com/en-us/library/ms190315.aspx
|
|
Background on why we attempt to embed "scope_identity()" into the same
|
statement as the INSERT:
|
https://code.google.com/p/pyodbc/wiki/FAQs#How_do_I_retrieve_autogenerated/identity_values?
|
|
r Tz; select scope_identity()N) r! Úpre_execZ_select_lastrowidr% Úuse_scope_identityr5 Ú
|
parametersÚ_embedded_scope_identityÚ statementrL r& r r rb * s
|
ÿþ ýz"MSExecutionContext_pyodbc.pre_execc sb | j rTz| j ¡ d }W qDW q | jjjk
|
r@ | j ¡ Y qX qt|d | _n
|
t
|
¡ d S r] ) re ÚcursorZfetchallr% rB ÚErrorÚnextsetÚintZ
|
_lastrowidr! Ú post_exec)r Úrowr& r r rk D s z#MSExecutionContext_pyodbc.post_exec)r8 r9 r: re rb rk r< r r r& r ra ' s ra c ! sÌ e Zd ZdZdZeZe e j
|
e j e e jeeee jeeeeee jee jee jee je e j e e j e e j j!e"e j j#e$e j%e j%i¡Z
|
d fdd Z& fddZ' fddZ(d d
|
Z)d fd d Z* fddZ+ Z,S )ÚMSDialect_pyodbcTFc sZ t jf d|i| | jo.| jo.t| jjd| _| joB| ¡ dk | _|| _|rVd| _ d S )NÚuse_setinputsizesri )é r é F)
|
r! Ú__init__rc rB ÚhasattrÚCursorZ_dbapi_versionr# Úfast_executemanyZ!use_insertmanyvalues_wo_returning)r rt rn Úparamsr& r r rq ~ s ÿ ýzMSDialect_pyodbc.__init__c s z| d¡ ¡ }W n" tjk
|
r4 t |¡ Y S X g }t d¡}| |¡D ],}z| t
|
|¡ W qN t k
|
rx Y qNX qNt |S d S )Nz8SELECT CAST(SERVERPROPERTY('ProductVersion') AS VARCHAR)z[.\-]) Zexec_driver_sqlZscalarr Z
|
DBAPIErrorr! Ú_get_server_version_inforJ ÚcompileÚsplitÚappendrj Ú
|
ValueErrorÚtuple)r Ú
|
connectionÚrawÚversionÚrÚnr& r r rv s ÿ
|
z)MSDialect_pyodbc._get_server_version_infoc s t ¡ fdd}|S )Nc s d k r| | ¡ d S rA )Ú_setup_timestampoffset_type)Úconn©r Zsuper_r r Ú
|
on_connect¬ s z/MSDialect_pyodbc.on_connect.<locals>.on_connect)r! r )r r r& r r r © s
|
zMSDialect_pyodbc.on_connectc C s dd }d}| ||¡ d S )Nc S s\ t d| ¡}t |d |d |d |d |d |d |d d t tj|d
|
|d d ¡¡S ) Nz<6hI2hr r ro r é é é iè r rp )ÚhoursÚminutes)ÚstructÚunpackÚdatetimerG Ú timedelta)Z dto_valueÚtupr r r Ú_handle_datetimeoffset¶ s
|
ÿøzLMSDialect_pyodbc._setup_timestampoffset_type.<locals>._handle_datetimeoffsetieÿÿÿ)Zadd_output_converter)r r| r Zodbc_SQL_SS_TIMESTAMPOFFSETr r r r ´ s ÿz,MSDialect_pyodbc._setup_timestampoffset_typeNc s$ | j r d|_ t j||||d d S )NT)Úcontext)rt r! Údo_executemany)r rg rf rd r r& r r r Ê s z MSDialect_pyodbc.do_executemanyc s4 t || jjr$|jd }|dkr$dS t |||¡S )Nr >
|
ÚHYT00Ú01002Ú08S02Ú08001Ú08003Ú08S01ÚHY010Ú01000Ú10054Ú08007T)r rB rh Úargsr! Ú is_disconnect)r Úer| rg Úcoder& r r r Ï s
|
|
z MSDialect_pyodbc.is_disconnect)FT)N)-r8 r9 r: Zsupports_statement_cacheZ supports_sane_rowcount_returningra Zexecution_ctx_clsr Z update_copyr ZcolspecsÚsqltypesÚNumericr= ÚFloatr? r rP ÚDateTimerM r rN r
|
rO Z LargeBinaryÚStringrQ ZUnicoderX Z UnicodeTextr[ r r\ r r_ r r` ÚEnumrq rv r r r r r< r r r& r rm Y sZ êþ ý rm )1r; r r rJ r Úbaser r r r r r r r
|
Újsonr Z_MSJsonr Z_MSJsonIndexTyper Z_MSJsonPathTyper) r r r r Zconnectors.pyodbcr r r¡ r= r¢ r? r@ rE rM rN rO rP r¤ rQ rX r[ r\ r_ r` ra rm r% r r r r Ú<module> sP U @ 2
|
