sqlalchemy-pytds 1.0.3__py3-none-any.whl

sqlalchemy_pytds/__init__.py

@@ -0,0 +1,5 @@
+__version__ = "1.0.3"
+
+from sqlalchemy.dialects import registry
+
+registry.register("mssql.pytds", "sqlalchemy_pytds.dialect", "MSDialect_pytds")

sqlalchemy_pytds/connector.py

@@ -0,0 +1,141 @@
+# connectors/pytds.py
+import re
+
+from sqlalchemy.connectors import Connector
+from sqlalchemy.util import asbool
+
+import pytds
+import pytds.login
+from pytds import tds_base, tds_session
+
+prevexecute = pytds.Cursor.execute
+
+
+def execute(self, operation, params=None):
+    # print('execute:', operation, params)
+    if operation[:15] == "EXEC sp_columns":
+        proc = "sp_columns"
+        params = {
+            "@table_name": params["table_name"],
+            "@table_owner": params["table_owner"],
+        }
+        return pytds.Cursor.callproc(self, proc, params)
+    elif operation[:10] == "sp_columns":
+        proc = "sp_columns"
+        params = {
+            "@table_name": params["table_name"],
+            "@table_owner": params["table_owner"],
+        }
+        return pytds.Cursor.callproc(self, proc, params)
+    return prevexecute(self, operation, params)
+
+
+pytds.Cursor.execute = execute
+
+
+def process_tabname(self):
+    r = self._reader
+    total_length = r.get_smallint()
+    if not tds_base.IS_TDS71_PLUS(self):
+        name_length = r.get_smallint()
+    tds_base.skipall(r, total_length)
+
+
+def process_colinfo(self):
+    r = self._reader
+    total_length = r.get_smallint()
+    tds_base.skipall(r, total_length)
+
+
+tds_session._token_map.update(
+    {
+        tds_base.TDS_TABNAME_TOKEN: lambda self: process_tabname(self),
+        tds_base.TDS_COLINFO_TOKEN: lambda self: process_colinfo(self),
+    }
+)
+
+
+class PyTDSConnector(Connector):
+    driver = "pytds"
+
+    supports_sane_multi_rowcount = False
+    supports_unicode = True
+    supports_unicode_binds = True
+    supports_unicode_statements = True
+    supports_native_decimal = True
+    default_paramstyle = "pyformat"
+
+    @classmethod
+    def import_dbapi(cls):
+        return pytds
+
+    def is_disconnect(self, e, connection, cursor):
+        if isinstance(e, self.dbapi.ProgrammingError):
+            return "The cursor's connection has been closed." in str(
+                e
+            ) or "Attempt to use a closed connection." in str(e)
+        elif isinstance(e, self.dbapi.Error):
+            return "[08S01]" in str(e)
+        else:
+            return False
+
+    def create_connect_args(self, url):
+        opts = url.translate_connect_args(username="user")
+        opts.update(url.query)
+
+        keys = opts
+        query = url.query
+
+        connect_args = {}
+        for param in ("autocommit", "use_mars", "as_dict"):
+            if param in keys:
+                connect_args[param] = asbool(keys.pop(param))
+        for param in ("port", "timeout", "login_timeout"):
+            if param in keys:
+                connect_args[param] = int(keys.pop(param))
+        for param in ("host", "user", "password", "database", "auth_method"):
+            if param in keys:
+                connect_args[param] = keys.pop(param)
+
+        connect_args["dsn"] = connect_args.pop("host", "localhost")
+
+        if "auth_method" in connect_args:
+            if connect_args["auth_method"] == "mssql":
+                del connect_args["auth_method"]
+            elif connect_args["auth_method"] == "ntlm":
+                connect_args["auth"] = pytds.login.NtlmAuth(
+                    connect_args["user"], connect_args["password"]
+                )
+                del connect_args["auth_method"]
+                del connect_args["user"]
+                del connect_args["password"]
+            elif connect_args["auth_method"] == "sso":
+                connect_args["use_sso"] = True
+                del connect_args["auth_method"]
+            else:
+                raise Exception("Unknown auth_method " + connect_args["auth_method"])
+
+        return [[], connect_args]
+
+    def _dbapi_version(self):
+        if not self.dbapi:
+            return ()
+        return self._parse_dbapi_version(self.dbapi.version)
+
+    def _parse_dbapi_version(self, vers):
+        m = re.match(r"(?:py.*-)?([\d\.]+)(?:-(\w+))?", vers)
+        if not m:
+            return ()
+        vers = tuple([int(x) for x in m.group(1).split(".")])
+        if m.group(2):
+            vers += (m.group(2),)
+        return vers
+
+    def _get_server_version_info(self, connection):
+        l = connection.connection.product_version
+        version = []
+        for i in range(4):
+            version.append(l & 0xFF)
+            l >>= 8
+        version.reverse()
+        return tuple(version)

sqlalchemy_pytds/dialect.py

@@ -0,0 +1,212 @@
+import re
+
+from sqlalchemy import util
+from sqlalchemy.dialects.mssql import SQL_VARIANT
+from sqlalchemy.dialects.mssql.base import (
+    MSDialect,
+    MSExecutionContext,
+    MSIdentifierPreparer,
+    MSSQLCompiler,
+)
+from sqlalchemy.engine.interfaces import ExecuteStyle
+
+from pytds import tds_base, tds_types
+
+from .connector import PyTDSConnector
+
+_server_side_id = util.counter()
+
+
+class SSCursor(object):
+    def __init__(self, c):
+        self._c = c
+        self._name = None
+        self._nrows = 0
+        self._row = 0
+
+    def execute(self, statement, parameters):
+        _name = "tc%08X" % _server_side_id()
+        sql = (
+            "DECLARE "
+            + _name
+            + " CURSOR GLOBAL SCROLL STATIC READ_ONLY FOR "
+            + statement
+        )
+        # print(sql, parameters)
+        self._c.execute(sql, parameters)
+        self._name = _name
+        sql = "OPEN " + _name
+        self._c.execute(sql)
+        self._c.execute("SELECT @@CURSOR_ROWS AS nrows")
+        self._nrows = self._c.fetchone()[0]
+        return self.fetchone()
+
+    def close(self):
+        sql = "CLOSE " + self._name
+        self._c.execute(sql)
+        sql = "DEALLOCATE " + self._name
+        self._c.execute(sql)
+        self._c.close()
+        self._name = None
+        self._nrows = 0
+        self._row = 0
+
+    def fetchone(self):
+        if not (0 <= self._row < self._nrows):
+            return None
+        sql = "FETCH ABSOLUTE %d FROM %s" % (self._row + 1, self._name)
+        self._c.execute(sql)
+        return self._c.fetchone()
+
+    def movefirst(self):
+        value = 0
+        if value >= 0 and value < self._nrows:
+            self._row = value
+            return True
+        return False
+
+    def moveprev(self):
+        value = self._row - 1
+        if value >= 0 and value < self._nrows:
+            self._row = value
+            return True
+        return False
+
+    def movenext(self):
+        value = self._row + 1
+        if value >= 0 and value < self._nrows:
+            self._row = value
+            return True
+        return False
+
+    def movelast(self):
+        value = self._nrows - 1
+        if value >= 0 and value < self._nrows:
+            self._row = value
+            return True
+        return False
+
+    def goto(self, value):
+        if value >= 0 and value < self._nrows:
+            self._row = value
+            return True
+        return False
+
+    def __getattr__(self, name):
+        # print('getattr(%s)' %name)
+        return getattr(self._c, name)
+
+
+class MSSQLCompiler_pytds(MSSQLCompiler):
+    pass
+
+
+class MSSQLIdentifierPreparer_pytds(MSIdentifierPreparer):
+
+    def _escape_identifier(self, value: str) -> str:
+        value = value.replace("]", "]]")
+        value = value.replace("%", "%%")
+        return value
+
+    def _unescape_identifier(self, value: str) -> str:
+        return value.replace("]]", "]")
+
+
+class MSExecutionContext_pytds(MSExecutionContext):
+    _embedded_scope_identity = False
+
+    def pre_exec(self):
+        super(MSExecutionContext_pytds, self).pre_exec()
+        if (
+            self._select_lastrowid
+            and self.dialect.use_scope_identity
+            and len(self.parameters[0])
+        ):
+            self._embedded_scope_identity = True
+
+            self.statement += "; select scope_identity()"
+
+    def post_exec(self):
+        if self._embedded_scope_identity:
+            while True:
+                try:
+                    row = self.cursor.fetchall()[0]
+                    break
+                except self.dialect.dbapi.Error as e:
+                    self.cursor.nextset()
+
+            self._lastrowid = int(row[0])
+            self.cursor.lastrowid = int(row[0])
+            self._select_lastrowid = False
+        super(MSExecutionContext_pytds, self).post_exec()
+
+    def create_cursor(self):
+        usess = self.execution_options.get("stream_results", None)
+        if usess:
+            self._is_server_side = True
+            return SSCursor(self._dbapi_connection.cursor())
+        else:
+            self._is_server_side = False
+            return self._dbapi_connection.cursor()
+
+
+class MSDialect_pytds(PyTDSConnector, MSDialect):
+
+    execution_ctx_cls = MSExecutionContext_pytds
+    statement_compiler = MSSQLCompiler_pytds
+    preparer = MSSQLIdentifierPreparer_pytds  # type: ignore
+
+    supports_server_side_cursors = True
+    supports_statement_cache = True
+    supports_sane_rowcount_returning = True
+    supports_sane_multi_rowcount = False
+    supports_native_decimal = True
+    supports_native_uuid = True
+
+    def __init__(self, server_side_cursors=False, **params):
+        super(MSDialect_pytds, self).__init__(**params)
+        self.use_scope_identity = True
+        self.server_side_cursors = server_side_cursors
+
+    def do_execute(self, cursor, statement, parameters, context=None):
+        if context and context.isinsert or context.isupdate:
+            tbl = context.compiled.compile_state.dml_table
+            # print('*'*20, 'do_execute')
+            # print('stmt:', statement)
+            # print('parm:', parameters)
+            for c in tbl._columns:
+                if isinstance(c.type, SQL_VARIANT):
+                    todo = [
+                        name
+                        for name in parameters.keys()
+                        if c.name == name or re.match(c.name + r"__(\d+)", name)
+                    ]
+                    # print('todo:', todo)
+                    for name in todo:
+                        v = parameters.get(name, None)
+                        # print('cvt', name, v)
+                        if isinstance(v, str):
+                            # assert len(v) <= 4000
+                            parameters[name] = tds_base.Param(
+                                name=name,
+                                type=tds_types.NVarCharType(size=len(v)),
+                                value=v,
+                                flags=0,
+                            )
+                        elif isinstance(v, bytes):
+                            # assert len(v) <= 8000
+                            parameters[name] = tds_base.Param(
+                                name=name,
+                                type=tds_types.VarBinaryType(size=len(v)),
+                                value=v,
+                                flags=0,
+                            )
+            # print('parm:', parameters)
+        cursor.execute(statement, parameters)
+
+    def set_isolation_level(self, connection, level):
+        if level == "AUTOCOMMIT":
+            connection.autocommit(True)
+        else:
+            connection.autocommit(False)
+            super(MSDialect_pytds, self).set_isolation_level(connection, level)

sqlalchemy_pytds/provision.py

@@ -0,0 +1,9 @@
+from sqlalchemy.testing.provision import normalize_sequence
+
+
+@normalize_sequence.for_db("mssql")
+def normalize_sequence(cfg, sequence):
+    # avoid numeric overflow (int) in tests
+    if sequence.start is None:
+        sequence.start = 1
+    return sequence

sqlalchemy_pytds/requirements.py

@@ -0,0 +1,209 @@
+from sqlalchemy.testing import exclusions
+from sqlalchemy.testing.requirements import SuiteRequirements
+
+
+class Requirements(SuiteRequirements):
+
+    @property
+    def temp_table_reflection(self):
+        return exclusions.closed()
+
+    @property
+    def order_by_col_from_union(self):
+        """target database supports ordering by a column from a SELECT
+        inside of a UNION
+        E.g.  (SELECT id, ...) UNION (SELECT id, ...) ORDER BY id"""
+        return exclusions.open()
+
+    @property
+    def independent_connections(self):
+        return exclusions.open()
+
+    @property
+    def implicitly_named_constraints(self):
+        """target database must apply names to unnamed constraints."""
+        return exclusions.open()
+
+    @property
+    def reflects_pk_names(self):
+        return exclusions.open()
+
+    @property
+    def index_reflection(self):
+        return exclusions.closed()
+
+    @property
+    def unique_constraint_reflection(self):
+        """target dialect supports reflection of unique constraints"""
+        return exclusions.closed()
+
+    @property
+    def self_referential_foreign_keys(self):
+        """Target database must support self-referential foreign keys."""
+        return exclusions.open()
+
+    @property
+    def returning(self):
+        """target platform supports RETURNING."""
+        return exclusions.closed()
+
+    @property
+    def empty_strings_varchar(self):
+        """target database can persist/return an empty string with a
+        varchar."""
+        return exclusions.open()
+
+    @property
+    def text_type(self):
+        """Target database must support an unbounded Text()
+        type such as TEXT or CLOB"""
+        return exclusions.open()
+
+    @property
+    def datetime_microseconds(self):
+        """target dialect supports representation of Python
+        datetime.datetime() with microsecond objects."""
+        return exclusions.closed()
+
+    @property
+    def datetime_historic(self):
+        """target dialect supports representation of Python
+        datetime.datetime() objects with historic (pre 1970) values."""
+        return exclusions.open()
+
+    @property
+    def date_historic(self):
+        """target dialect supports representation of Python
+        datetime.date() objects with historic (pre 1970) values."""
+        return exclusions.open()
+
+    @property
+    def time(self):
+        """target dialect supports representation of Python
+        datetime.time() objects."""
+        return exclusions.open()
+
+    @property
+    def time_microseconds(self):
+        """target dialect supports representation of Python
+        datetime.time() with microsecond objects."""
+        return exclusions.open()
+
+    @property
+    def unbounded_varchar(self):
+        """Target database must support VARCHAR with no length"""
+        return exclusions.open()
+
+    @property
+    def implements_get_lastrowid(self):
+        """target dialect implements the executioncontext.get_lastrowid()
+        method without reliance on RETURNING."""
+        return exclusions.open()
+
+    @property
+    def emulated_lastrowid(self):
+        """target dialect retrieves cursor.lastrowid, or fetches
+        from a database-side function after an insert() construct executes,
+        within the get_lastrowid() method.
+
+        Only dialects that "pre-execute", or need RETURNING to get last
+        inserted id, would return closed/fail/skip for this.
+        """
+        return exclusions.open()
+
+    @property
+    def dbapi_lastrowid(self):
+        """target platform includes a 'lastrowid' accessor on the DBAPI
+        cursor object.
+
+        """
+        return exclusions.open()
+
+    @property
+    def schemas(self):
+        """Target database supports named schemas"""
+        return exclusions.open()
+
+    @property
+    def views(self):
+        """Target database must support VIEWs."""
+
+        return exclusions.open()
+
+    @property
+    def view_reflection(self):
+        """Target database supports view metadata"""
+        return exclusions.open()
+
+    @property
+    def precision_numerics_enotation_large(self):
+        """Dialect converts small/large scale decimals into scientific notation"""
+        return exclusions.closed()
+
+    @property
+    def temporary_tables(self):
+        """target database supports temporary tables"""
+        return exclusions.open()
+
+    @property
+    def temp_table_names(self):
+        """target dialect supports listing of temporary table names"""
+        return exclusions.closed()
+
+    @property
+    def offset(self):
+        """target database can render OFFSET, or an equivalent, in a
+        SELECT.
+        """
+        return exclusions.open()
+
+    @property
+    def bound_limit_offset(self):
+        """target database can render LIMIT and/or OFFSET using a bound
+        parameter
+        """
+
+        return exclusions.open()
+
+    @property
+    def duplicate_key_raises_integrity_error(self):
+        return exclusions.open()
+
+    @property
+    def parens_in_union_contained_select_w_limit_offset(self):
+        return exclusions.closed()
+
+    @property
+    def parens_in_union_contained_select_wo_limit_offset(self):
+        return exclusions.open()
+
+    @property
+    def broken_cx_oracle6_numerics(self):
+        return exclusions.closed()
+
+    @property
+    def floats_to_four_decimals(self):
+        return exclusions.closed()
+
+    @property
+    def server_side_cursors(self):
+        """Target dialect must support server side cursors."""
+        return exclusions.closed()
+
+    @property
+    def array_type(self):
+        # ARRAY type not implemented.
+        return exclusions.closed()
+
+    @property
+    def sane_multi_rowcount(self):
+        return exclusions.closed()
+
+    @property
+    def unicode_data_no_special_types(self):
+        """Target database/dialect can receive / deliver / compare data with
+        non-ASCII characters in plain VARCHAR, TEXT columns, without the need
+        for special "national" datatypes like NVARCHAR or similar.
+
+        """
+        return exclusions.closed()

sqlalchemy_pytds-1.0.3.dist-info/METADATA

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: sqlalchemy_pytds
+Version: 1.0.3
+Summary: A Microsoft SQL Server TDS connector for SQLAlchemy.
+Author-email: Grzegorz Makarewicz <mak@trisoft.com.pl>
+License: MIT
+Project-URL: Homepage, https://github.com/m32/sqlalchemy-tds
+Keywords: SQLAlchemy,Microsoft SQL Server
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3.3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Topic :: Database :: Front-Ends
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: python-tds
+Requires-Dist: SQLAlchemy>=2.0
+Dynamic: license-file
+
+A Microsoft SQL Server TDS connector for SQLAlchemy.

sqlalchemy_pytds-1.0.3.dist-info/RECORD

@@ -0,0 +1,11 @@
+sqlalchemy_pytds/__init__.py,sha256=4wwiQa5tSK1D8jFfdWvySDwJSMP1NBbwb5yPPaAQ_60,145
+sqlalchemy_pytds/connector.py,sha256=qOBEewXYSMBMg1LqZTS7mZf536OAvMMlt_uzF1kSWls,4339
+sqlalchemy_pytds/dialect.py,sha256=uk-3mjO8q0M0sDiD-9IGLXCh9K8QvoxbnCeTM9yXeOQ,6694
+sqlalchemy_pytds/provision.py,sha256=PaQpbjV2OAt00x0XP3rTSkDPsN2p-XNYEFmUkPCD8X0,259
+sqlalchemy_pytds/requirements.py,sha256=xKJ3IrhdNeZ_OunUIznJw1c5sKwtte-rf5c-_K9K8gY,6019
+sqlalchemy_pytds-1.0.3.dist-info/licenses/LICENSE,sha256=1q5zV6eF0hfUtq1TFjccuSDABoec7G3TrOd6eJFIV-Q,1086
+sqlalchemy_pytds-1.0.3.dist-info/METADATA,sha256=EFuftnaKs1F2Z_digB52TRHEDCM9Y99CdUJY9IXOI10,815
+sqlalchemy_pytds-1.0.3.dist-info/WHEEL,sha256=Uvlg2aNlEKdilsyFSJt1QX5me0eEbCjQzR3nZeFkvy4,109
+sqlalchemy_pytds-1.0.3.dist-info/entry_points.txt,sha256=Jbzf2UfqTNoIQN2oJ2gHXAuhcTsNLn020Q8LY23PMyI,77
+sqlalchemy_pytds-1.0.3.dist-info/top_level.txt,sha256=vlDsdgZP5RBe_PCE3iyvjUl_h9asG4Wy-HWw6db4_6Q,17
+sqlalchemy_pytds-1.0.3.dist-info/RECORD,,

sqlalchemy_pytds-1.0.3.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+

sqlalchemy_pytds-1.0.3.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[sqlalchemy.dialects]
+mssql.pytds = sqlalchemy_pytds.dialect:MSDialect_pytds

sqlalchemy_pytds-1.0.3.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Grzegorz Makarewicz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

sqlalchemy_pytds-1.0.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+sqlalchemy_pytds