morro

sqlalchemy/connectors/__init__.py

@@ -0,0 +1,6 @@
+
+
+class Connector(object):
+    pass
+    
+    

sqlalchemy/connectors/mxodbc.py

@@ -0,0 +1,146 @@
+"""
+Provide an SQLALchemy connector for the eGenix mxODBC commercial
+Python adapter for ODBC. This is not a free product, but eGenix
+provides SQLAlchemy with a license for use in continuous integration
+testing.
+
+This has been tested for use with mxODBC 3.1.2 on SQL Server 2005
+and 2008, using the SQL Server Native driver. However, it is
+possible for this to be used on other database platforms.
+
+For more info on mxODBC, see http://www.egenix.com/
+
+"""
+
+import sys
+import re
+import warnings
+from decimal import Decimal
+
+from sqlalchemy.connectors import Connector
+from sqlalchemy import types as sqltypes
+import sqlalchemy.processors as processors
+
+class MxODBCConnector(Connector):
+    driver='mxodbc'
+    
+    supports_sane_multi_rowcount = False
+    supports_unicode_statements = False
+    supports_unicode_binds = False
+    
+    supports_native_decimal = True
+    
+    @classmethod
+    def dbapi(cls):
+        # this classmethod will normally be replaced by an instance
+        # attribute of the same name, so this is normally only called once.
+        cls._load_mx_exceptions()
+        platform = sys.platform
+        if platform == 'win32':
+            from mx.ODBC import Windows as module
+        # this can be the string "linux2", and possibly others
+        elif 'linux' in platform:
+            from mx.ODBC import unixODBC as module
+        elif platform == 'darwin':
+            from mx.ODBC import iODBC as module
+        else:
+            raise ImportError, "Unrecognized platform for mxODBC import"
+        return module
+
+    @classmethod
+    def _load_mx_exceptions(cls):
+        """ Import mxODBC exception classes into the module namespace,
+        as if they had been imported normally. This is done here
+        to avoid requiring all SQLAlchemy users to install mxODBC.
+        """
+        global InterfaceError, ProgrammingError
+        from mx.ODBC import InterfaceError
+        from mx.ODBC import ProgrammingError
+
+    def on_connect(self):
+        def connect(conn):
+            conn.stringformat = self.dbapi.MIXED_STRINGFORMAT
+            conn.datetimeformat = self.dbapi.PYDATETIME_DATETIMEFORMAT
+            conn.decimalformat = self.dbapi.DECIMAL_DECIMALFORMAT
+            conn.errorhandler = self._error_handler()
+        return connect
+    
+    def _error_handler(self):
+        """ Return a handler that adjusts mxODBC's raised Warnings to
+        emit Python standard warnings.
+        """
+        from mx.ODBC.Error import Warning as MxOdbcWarning
+        def error_handler(connection, cursor, errorclass, errorvalue):
+
+            if issubclass(errorclass, MxOdbcWarning):
+                errorclass.__bases__ = (Warning,)
+                warnings.warn(message=str(errorvalue),
+                          category=errorclass,
+                          stacklevel=2)
+            else:
+                raise errorclass, errorvalue
+        return error_handler
+
+    def create_connect_args(self, url):
+        """ Return a tuple of *args,**kwargs for creating a connection.
+
+        The mxODBC 3.x connection constructor looks like this:
+
+            connect(dsn, user='', password='',
+                    clear_auto_commit=1, errorhandler=None)
+
+        This method translates the values in the provided uri
+        into args and kwargs needed to instantiate an mxODBC Connection.
+
+        The arg 'errorhandler' is not used by SQLAlchemy and will
+        not be populated.
+        
+        """
+        opts = url.translate_connect_args(username='user')
+        opts.update(url.query)
+        args = opts.pop('host')
+        opts.pop('port', None)
+        opts.pop('database', None)
+        return (args,), opts
+
+    def is_disconnect(self, e):
+        # eGenix recommends checking connection.closed here,
+        # but how can we get a handle on the current connection?
+        if isinstance(e, self.dbapi.ProgrammingError):
+            return "connection already closed" in str(e)
+        elif isinstance(e, self.dbapi.Error):
+            return '[08S01]' in str(e)
+        else:
+            return False
+
+    def _get_server_version_info(self, connection):
+        # eGenix suggests using conn.dbms_version instead of what we're doing here
+        dbapi_con = connection.connection
+        version = []
+        r = re.compile('[.\-]')
+        # 18 == pyodbc.SQL_DBMS_VER
+        for n in r.split(dbapi_con.getinfo(18)[1]):
+            try:
+                version.append(int(n))
+            except ValueError:
+                version.append(n)
+        return tuple(version)
+
+    def do_execute(self, cursor, statement, parameters, context=None):
+        if context:
+            native_odbc_execute = context.execution_options.\
+                                        get('native_odbc_execute', 'auto')
+            if native_odbc_execute is True:
+                # user specified native_odbc_execute=True
+                cursor.execute(statement, parameters)
+            elif native_odbc_execute is False:
+                # user specified native_odbc_execute=False
+                cursor.executedirect(statement, parameters)
+            elif context.is_crud:
+                # statement is UPDATE, DELETE, INSERT
+                cursor.execute(statement, parameters)
+            else:
+                # all other statements
+                cursor.executedirect(statement, parameters)
+        else:
+            cursor.executedirect(statement, parameters)

sqlalchemy/connectors/pyodbc.py

@@ -0,0 +1,113 @@
+from sqlalchemy.connectors import Connector
+from sqlalchemy.util import asbool
+
+import sys
+import re
+import urllib
+import decimal
+
+class PyODBCConnector(Connector):
+    driver='pyodbc'
+
+    supports_sane_multi_rowcount = False
+    # PyODBC unicode is broken on UCS-4 builds
+    supports_unicode = sys.maxunicode == 65535
+    supports_unicode_statements = supports_unicode
+    supports_native_decimal = True
+    default_paramstyle = 'named'
+    
+    # for non-DSN connections, this should
+    # hold the desired driver name
+    pyodbc_driver_name = None
+    
+    # will be set to True after initialize()
+    # if the freetds.so is detected
+    freetds = False
+    
+    @classmethod
+    def dbapi(cls):
+        return __import__('pyodbc')
+
+    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 ('ansi', 'unicode_results', 'autocommit'):
+            if param in keys:
+                connect_args[param] = asbool(keys.pop(param))
+
+        if 'odbc_connect' in keys:
+            connectors = [urllib.unquote_plus(keys.pop('odbc_connect'))]
+        else:
+            dsn_connection = 'dsn' in keys or ('host' in keys and 'database' not in keys)
+            if dsn_connection:
+                connectors= ['dsn=%s' % (keys.pop('host', '') or keys.pop('dsn', ''))]
+            else:
+                port = ''
+                if 'port' in keys and not 'port' in query:
+                    port = ',%d' % int(keys.pop('port'))
+
+                connectors = ["DRIVER={%s}" % keys.pop('driver', self.pyodbc_driver_name),
+                              'Server=%s%s' % (keys.pop('host', ''), port),
+                              'Database=%s' % keys.pop('database', '') ]
+
+            user = keys.pop("user", None)
+            if user:
+                connectors.append("UID=%s" % user)
+                connectors.append("PWD=%s" % keys.pop('password', ''))
+            else:
+                connectors.append("Trusted_Connection=Yes")
+
+            # if set to 'Yes', the ODBC layer will try to automagically convert 
+            # textual data from your database encoding to your client encoding 
+            # This should obviously be set to 'No' if you query a cp1253 encoded 
+            # database from a latin1 client... 
+            if 'odbc_autotranslate' in keys:
+                connectors.append("AutoTranslate=%s" % keys.pop("odbc_autotranslate"))
+
+            connectors.extend(['%s=%s' % (k,v) for k,v in keys.iteritems()])
+        return [[";".join (connectors)], connect_args]
+        
+    def is_disconnect(self, e):
+        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 initialize(self, connection):
+        # determine FreeTDS first.   can't issue SQL easily
+        # without getting unicode_statements/binds set up.
+        
+        pyodbc = self.dbapi
+
+        dbapi_con = connection.connection
+
+        self.freetds = bool(re.match(r".*libtdsodbc.*\.so",  dbapi_con.getinfo(pyodbc.SQL_DRIVER_NAME)))
+
+        # the "Py2K only" part here is theoretical.
+        # have not tried pyodbc + python3.1 yet.
+        # Py2K
+        self.supports_unicode_statements = not self.freetds
+        self.supports_unicode_binds = not self.freetds
+        # end Py2K
+        
+        # run other initialization which asks for user name, etc.
+        super(PyODBCConnector, self).initialize(connection)
+
+    def _get_server_version_info(self, connection):
+        dbapi_con = connection.connection
+        version = []
+        r = re.compile('[.\-]')
+        for n in r.split(dbapi_con.getinfo(self.dbapi.SQL_DBMS_VER)):
+            try:
+                version.append(int(n))
+            except ValueError:
+                version.append(n)
+        return tuple(version)

sqlalchemy/connectors/zxJDBC.py

@@ -0,0 +1,48 @@
+import sys
+from sqlalchemy.connectors import Connector
+
+class ZxJDBCConnector(Connector):
+    driver = 'zxjdbc'
+    
+    supports_sane_rowcount = False
+    supports_sane_multi_rowcount = False
+    
+    supports_unicode_binds = True
+    supports_unicode_statements = sys.version > '2.5.0+'
+    description_encoding = None
+    default_paramstyle = 'qmark'
+    
+    jdbc_db_name = None
+    jdbc_driver_name = None
+    
+    @classmethod
+    def dbapi(cls):
+        from com.ziclix.python.sql import zxJDBC
+        return zxJDBC
+
+    def _driver_kwargs(self):
+        """Return kw arg dict to be sent to connect()."""
+        return {}
+        
+    def _create_jdbc_url(self, url):
+        """Create a JDBC url from a :class:`~sqlalchemy.engine.url.URL`"""
+        return 'jdbc:%s://%s%s/%s' % (self.jdbc_db_name, url.host,
+                                      url.port is not None and ':%s' % url.port or '',
+                                      url.database)
+        
+    def create_connect_args(self, url):
+        opts = self._driver_kwargs()
+        opts.update(url.query)
+        return [[self._create_jdbc_url(url), url.username, url.password, self.jdbc_driver_name],
+                opts]
+
+    def is_disconnect(self, e):
+        if not isinstance(e, self.dbapi.ProgrammingError):
+            return False
+        e = str(e)
+        return 'connection is closed' in e or 'cursor is closed' in e
+
+    def _get_server_version_info(self, connection):
+        # use connection.connection.dbversion, and parse appropriately
+        # to get a tuple
+        raise NotImplementedError()