django-azure-sql-backend 2.1.1.1
Django backend for Microsoft SQL Server and Azure SQL Database using pyodbc
License: BSD
Keywords: azure django

django-azure-sql-backend
========================

.. image:: http://img.shields.io/pypi/v/django-azure-sql-backend.svg?style=flat
    :target: https://pypi.python.org/pypi/django-azure-sql-backend

.. image:: http://img.shields.io/pypi/l/django-azure-sql-backend.svg?style=flat
    :target: http://opensource.org/licenses/BSD-3-Clause

*django-azure-sql-backend* is a modern fork of
`django-pyodbc-azure <https://github.com/michiya/django-pyodbc-azure/>`__
made to support AAD access token authentication. It is also a fork of
`django-pyodbc <https://code.google.com/archive/p/django-pyodbc/>`__, a
`Django <https://www.djangoproject.com/>`__ Microsoft SQL Server external
DB backend that uses ODBC by employing the
`pyodbc <https://github.com/mkleehammer/pyodbc>`__ library. It supports
Microsoft SQL Server and Azure SQL Database.

Features
--------

-  Supports Django 2.1
-  Supports Microsoft SQL Server 2008/2008R2, 2012, 2014, 2016, 2017 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.1
-  pyodbc 3.0 or newer

Installation
------------

1. Install pyodbc and Django

2. Install django-azure-sql-backend ::

    pip install django-azure-sql-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'

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"`` (on-premise) or
   ``"server.database.windows.net"`` (Azure SQL Database) 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 using user and password:

::

    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

Notice
------

This version of *django-azure-sql-backend* only supports Django 2.1.
If you want to use it on older versions of Django,
specify an appropriate version number (2.0.x.x for Django 2.0)
at installation like this: ::

    pip install "django-azure-sql-backend<2.1"