Metadata-Version: 1.1
Name: django-mssql-backend-azure
Version: 2.9.1
Summary: Django backend for Microsoft SQL Server and Azure
Home-page: https://dev.azure.com/novonordiskit/CMC%20OPF/_git/django-mssql-backend-azure
Author: Oliver Reinholdt
Author-email: ogre@novonordisk.com
License: BSD
Description: django-mssql-backend
        ====================
        
        .. image:: https://img.shields.io/pypi/v/django-mssql-backend.svg
           :target: https://pypi.python.org/pypi/django-mssql-backend
        
        *django-mssql-backend* is a fork of
        `django-pyodbc-azure <https://pypi.org/project/django-pyodbc-azure/>`__
        Support for AAD access has been adapted from
        `django-azure-sql-backend <https://github.com/langholz/django-azure-sql-backend>`__
        , which only support Django 2.1.
        
        Features
        --------
        
        -  Supports Django 2.2, 3.0
        -  Supports Microsoft SQL Server 2008/2008R2, 2012, 2014, 2016, 2017, 2019 and Azure SQL Database
        -  AAD authentication through registered application access token
        -  Passes most of the tests of the Django test suite
        -  Compatible with
           `Micosoft ODBC Driver for SQL Server <https://docs.microsoft.com/en-us/sql/connect/odbc/microsoft-odbc-driver-for-sql-server>`__,
           `SQL Server Native Client <https://msdn.microsoft.com/en-us/library/ms131321(v=sql.120).aspx>`__,
           and `FreeTDS <http://www.freetds.org/>`__ ODBC drivers
        
        Dependencies
        ------------
        
        -  Django 2.2 or newer
        -  pyodbc 3.0 or newer
        
        Installation
        ------------
        
        1. Install pyodbc and Django
        
        2. Install django-mssql-backend ::
        
            pip install django-mssql-backend
        
        3. Now you can point the ``ENGINE`` setting in the settings file used by
           your Django application or project to the ``'sql_server.pyodbc'``
           module path ::
        
            'ENGINE': 'sql_server.pyodbc'
        
        Regex Support
        -------------
        
        django-mssql-backend supports regex using a CLR .dll file. To install it, run ::
        
            python manage.py install_regex_clr {database_name}
        
        Configuration
        -------------
        
        Standard Django settings
        ~~~~~~~~~~~~~~~~~~~~~~~~
        
        The following entries in a database-level settings dictionary
        in DATABASES control the behavior of the backend:
        
        -  ENGINE
        
           String. It must be ``"sql_server.pyodbc"``.
        
        -  NAME
        
           String. Database name. Required.
        
        -  HOST
        
           String. SQL Server instance in ``"server\instance"`` format.
        
        -  PORT
        
           String. Server instance port.
           An empty string means the default port.
        
        -  USER
        
           String. Database user name in ``"user"`` (on-premise) or
           ``"user@server"`` (Azure SQL Database) format.
           If not given then MS Integrated Security will be used.
        
        -  PASSWORD
        
           String. Database user password.
        
        -  AUTOCOMMIT
        
           Boolean. Set this to False if you want to disable
           Django's transaction management and implement your own.
        
        and the following entries are also available in the TEST dictionary
        for any given database-level settings dictionary:
        
        -  NAME
        
           String. The name of database to use when running the test suite.
           If the default value (``None``) is used, the test database will use
           the name "test\_" + ``NAME``.
        
        -  COLLATION
        
           String. The collation order to use when creating the test database.
           If the default value (``None``) is used, the test database is assigned
           the default collation of the instance of SQL Server.
        
        -  DEPENDENCIES
        
           String. The creation-order dependencies of the database.
           See the official Django documentation for more details.
        
        -  MIRROR
        
           String. The alias of the database that this database should
           mirror during testing. Default value is ``None``.
           See the official Django documentation for more details.
        
        AAD-AUTH
        ~~~~~~~~
        
        When provided, ``USER`` and ``PASSWORD`` are not used and AAD authentication using
        application access token is used instead.
        
        References:
        
        -  https://github.com/AzureAD/microsoft-authentication-library-for-python
        -  https://github.com/AzureAD/azure-activedirectory-library-for-python/wiki/Connect-to-Azure-SQL-Database
        -  https://docs.microsoft.com/en-us/azure/active-directory/develop/quickstart-v2-python-webapp
        -  https://docs.microsoft.com/en-us/sql/connect/python/pyodbc/step-3-proof-of-concept-connecting-to-sql-using-pyodbc?view=sql-server-ver15
        
        
        Dictionary. Current available keys are:
        
        -  tenant_id
        
           String. Refers to the registered application tenant identifier to use.
           It is also known as the directory identifier and can sometimes be provided
           within the STS url like so: ``https://login.microsoftonline.com/<TENANT_ID>/oauth2/v2.0/token``
        
        -  client_id
        
           String. Refers to the registered application client identifier to use.
           It is also known as the application identifier.
        
        -  secret
        
           String. Refers to the secret that will be use to authenticate with AAD.
        
        OPTIONS
        ~~~~~~~
        
        Dictionary. Current available keys are:
        
        -  driver
        
           String. ODBC Driver to use (``"ODBC Driver 13 for SQL Server"``,
           ``"SQL Server Native Client 11.0"``, ``"FreeTDS"`` etc).
           Default is ``"ODBC Driver 13 for SQL Server"``.
        
        -  isolation_level
        
           String. Sets `transaction isolation level
           <https://docs.microsoft.com/en-us/sql/t-sql/statements/set-transaction-isolation-level-transact-sql>`__
           for each database session. Valid values for this entry are
           ``READ UNCOMMITTED``, ``READ COMMITTED``, ``REPEATABLE READ``,
           ``SNAPSHOT``, and ``SERIALIZABLE``. Default is ``None`` which means
           no isolation levei is set to a database session and SQL Server default
           will be used.
        
        -  dsn
        
           String. A named DSN can be used instead of ``HOST``.
        
        -  host_is_server
        
           Boolean. Only relevant if using the FreeTDS ODBC driver under
           Unix/Linux.
        
           By default, when using the FreeTDS ODBC driver the value specified in
           the ``HOST`` setting is used in a ``SERVERNAME`` ODBC connection
           string component instead of being used in a ``SERVER`` component;
           this means that this value should be the name of a *dataserver*
           definition present in the ``freetds.conf`` FreeTDS configuration file
           instead of a hostname or an IP address.
        
           But if this option is present and it's value is ``True``, this
           special behavior is turned off.
        
           See http://www.freetds.org/userguide/dsnless.htm for more information.
        
        -  unicode_results
        
           Boolean. If it is set to ``True``, pyodbc's *unicode_results* feature
           is activated and strings returned from pyodbc are always Unicode.
           Default value is ``False``.
        
        -  extra_params
        
           String. Additional parameters for the ODBC connection. The format is
           ``"param=value;param=value"``.
        
        -  collation
        
           String. Name of the collation to use when performing text field
           lookups against the database. Default is ``None``; this means no
           collation specifier is added to your lookup SQL (the default
           collation of your database will be used). For Chinese language you
           can set it to ``"Chinese_PRC_CI_AS"``.
        
        -  connection_timeout
        
           Integer. Sets the timeout in seconds for the database connection process.
           Default value is ``0`` which disables the timeout.
        
        -  connection_retries
        
           Integer. Sets the times to retry the database connection process.
           Default value is ``5``.
        
        -  connection_retry_backoff_time
        
           Integer. Sets the back off time in seconds for reries of
           the database connection process. Default value is ``5``.
        
        -  query_timeout
        
           Integer. Sets the timeout in seconds for the database query.
           Default value is ``0`` which disables the timeout.
        
        backend-specific settings
        ~~~~~~~~~~~~~~~~~~~~~~~~~
        
        The following project-level settings also control the behavior of the backend:
        
        -  DATABASE_CONNECTION_POOLING
        
           Boolean. If it is set to ``False``, pyodbc's connection pooling feature
           won't be activated.
        
        Example
        ~~~~~~~
        
        Here is an example of the database settings:
        
        ::
        
            DATABASES = {
                'default': {
                    'ENGINE': 'sql_server.pyodbc',
                    'NAME': 'mydb',
                    'USER': 'user@myserver',
                    'PASSWORD': 'password',
                    'HOST': 'myserver.database.windows.net',
                    'PORT': '',
        
                    'OPTIONS': {
                        'driver': 'ODBC Driver 13 for SQL Server',
                    },
                },
            }
        
            # set this to False if you want to turn off pyodbc's connection pooling
            DATABASE_CONNECTION_POOLING = False
        
        Here is an example of the database settings using AAD access token authentication:
        
        ::
        
            DATABASES = {
                'default': {
                    'ENGINE': 'sql_server.pyodbc',
                    'NAME': 'mydb',
                    'HOST': 'myserver.database.windows.net',
                    'PORT': '',
                    'AAD-AUTH': {
                        'tenant_id': '02a2e49f-b581-45c4-84a9-bdee0198b26f',
                        'client_id': '818979f8-a731-48d9-bf42-b00a04e1e618',
                        'secret': "MY_SUPER_SECRET",
                    },
                    'OPTIONS': {
                        'driver': 'ODBC Driver 13 for SQL Server',
                    },
                },
            }
            
            # set this to False if you want to turn off pyodbc's connection pooling
            DATABASE_CONNECTION_POOLING = False
            
        Limitations
        -----------
        
        The following features are currently not supported:
        
        - Altering a model field from or to AutoField at migration
        
Keywords: AZURE django
Platform: UNKNOWN
Classifier: License :: OSI Approved :: BSD License
Classifier: Framework :: Django
Classifier: Operating System :: POSIX :: Linux
Classifier: Operating System :: Microsoft :: Windows
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.5
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Classifier: Framework :: Django :: 2.2
Classifier: Framework :: Django :: 3.0
