DJ-Database-URL

This simple Django utility allows you to utilize the 12factor inspired DATABASE_URL environment variable to configure your Django application.

The dj_database_url.config method returns a Django database connection dictionary, populated with all the data specified in your URL. There is also a conn_max_age argument to easily enable Django's connection pool.

If you'd rather not use an environment variable, you can pass a URL in directly instead to dj_database_url.parse.

Installation

Installation is simple:

$ pip install dj-database-url

Usage

1. If DATABASES is already defined:

• Configure your database in settings.py from DATABASE_URL:

  import dj_database_url
  
  DATABASES['default'] = dj_database_url.config(
      conn_max_age=600,
      conn_health_checks=True,
  )

• Provide a default:

  DATABASES['default'] = dj_database_url.config(
      default='postgres://...',
      conn_max_age=600,
      conn_health_checks=True,
  )

• Parse an arbitrary Database URL:

  DATABASES['default'] = dj_database_url.parse(
      'postgres://...',
      conn_max_age=600,
      conn_health_checks=True,
  )

2. If DATABASES is not defined:

• Configure your database in settings.py from DATABASE_URL:

  import dj_database_url
  
  DATABASES = {
      'default': dj_database_url.config(
          conn_max_age=600,
          conn_health_checks=True,
      ),
  }

• You can provide a default, used if the DATABASE_URL setting is not defined:

  DATABASES = {
      'default': dj_database_url.config(
          default='postgres://...',
          conn_max_age=600,
          conn_health_checks=True,
      )
  }

• Parse an arbitrary Database URL:

  DATABASES = {
      'default': dj_database_url.parse(
          'postgres://...',
          conn_max_age=600,
          conn_health_checks=True,
      )
  }

By default, config() reads DATABASE_URL. Use the env argument to select a different environment variable, for example when configuring multiple databases:

import dj_database_url

DATABASES = {
    'default': dj_database_url.config(),
    'analytics': dj_database_url.config(
        env='ANALYTICS_DATABASE_URL',
        default='sqlite:///analytics.sqlite3',
    ),
}

Here, the default database uses DATABASE_URL and the analytics database uses ANALYTICS_DATABASE_URL. The optional default URL applies to the selected environment variable: if ANALYTICS_DATABASE_URL is not set, the analytics database uses analytics.sqlite3. If the selected variable is set to an empty string, config() returns an empty dictionary instead of using the default URL.

conn_max_age sets the CONN_MAX_AGE setting, which tells Django to persist database connections between requests, up to the given lifetime in seconds. If you do not provide a value, it will follow Django’s default of 0. Setting it is recommended for performance.

conn_health_checks sets the CONN_HEALTH_CHECKS setting (new in Django 4.1), which tells Django to check a persisted connection still works at the start of each request. If you do not provide a value, it will follow Django’s default of False. Enabling it is recommended if you set a non-zero conn_max_age.

Strings passed to dj_database_url must be valid URLs; in particular, special characters must be url-encoded. The following url will raise a ValueError:

postgres://user:p#ssword!@localhost/foobar

and should instead be passed as:

postgres://user:p%23ssword!@localhost/foobar

TEST settings can be configured using the test_options attribute:

DATABASES['default'] = dj_database_url.config(default='postgres://...', test_options={'NAME': 'mytestdatabase'})

Supported Databases

Support currently exists for PostgreSQL, PostGIS, MySQL, MySQL (GIS), Oracle, Oracle (GIS), Redshift, CockroachDB, Timescale, Timescale (GIS) and SQLite.

If you want to use some non-default backends, you need to register them first:

import dj_database_url

# registration should be performed only once
dj_database_url.register("mysql-connector", "mysql.connector.django")

assert dj_database_url.parse("mysql-connector://user:password@host:port/db-name") == {
    "ENGINE": "mysql.connector.django",
    # ...other connection params
}

Some backends need further config adjustments (e.g. oracle and mssql expect PORT to be a string). For such cases you can provide a post-processing function to register() (note that register() is used as a decorator(!) in this case):

import dj_database_url

@dj_database_url.register("mssql", "sql_server.pyodbc")
def stringify_port(config):
    config["PORT"] = str(config["PORT"])

@dj_database_url.register("redshift", "django_redshift_backend")
def apply_current_schema(config):
    options = config["OPTIONS"]
    schema = options.pop("currentSchema", None)
    if schema:
        options["options"] = f"-c search_path={schema}"

@dj_database_url.register("snowflake", "django_snowflake")
def adjust_snowflake_config(config):
    config.pop("PORT", None)
    config["ACCOUNT"] = config.pop("HOST")
    name, _, schema = config["NAME"].partition("/")
    if schema:
        config["SCHEMA"] = schema
        config["NAME"] = name
    options = config.get("OPTIONS", {})
    warehouse = options.pop("warehouse", None)
    if warehouse:
        config["WAREHOUSE"] = warehouse
    role = options.pop("role", None)
    if role:
        config["ROLE"] = role

URL schema

Engine	Django Backend	URL
PostgreSQL	django.db.backends.postgresql [1]	postgres://USER:PASSWORD@HOST:PORT/NAME [2] postgresql://USER:PASSWORD@HOST:PORT/NAME
PostGIS	django.contrib.gis.db.backends.postgis	postgis://USER:PASSWORD@HOST:PORT/NAME
MSSQL	sql_server.pyodbc	mssql://USER:PASSWORD@HOST:PORT/NAME
MSSQL [5]	mssql	mssqlms://USER:PASSWORD@HOST:PORT/NAME
MySQL	django.db.backends.mysql	mysql://USER:PASSWORD@HOST:PORT/NAME [2]
MySQL (GIS)	django.contrib.gis.db.backends.mysql	mysqlgis://USER:PASSWORD@HOST:PORT/NAME
SQLite	django.db.backends.sqlite3	sqlite:///PATH [3]
SpatiaLite	django.contrib.gis.db.backends.spatialite	spatialite:///PATH [3]
Oracle	django.db.backends.oracle	oracle://USER:PASSWORD@HOST:PORT/NAME [4]
Oracle (GIS)	django.contrib.gis.db.backends.oracle	oraclegis://USER:PASSWORD@HOST:PORT/NAME
Redshift	django_redshift_backend	redshift://USER:PASSWORD@HOST:PORT/NAME
CockroachDB	django_cockroachdb	cockroach://USER:PASSWORD@HOST:PORT/NAME
Timescale [6]	timescale.db.backends.postgresql	timescale://USER:PASSWORD@HOST:PORT/NAME
Timescale (GIS) [6]	timescale.db.backend.postgis	timescalegis://USER:PASSWORD@HOST:PORT/NAME

[1]	The django.db.backends.postgresql backend is named django.db.backends.postgresql_psycopg2 in older releases. For backwards compatibility, the old name still works in newer versions. (The new name does not work in older versions).

[2]	(1, 2) With PostgreSQL or CloudSQL, you can also use unix domain socket paths with percent encoding: postgres://%2Fvar%2Flib%2Fpostgresql/dbname mysql://uf07k1i6d8ia0v@%2fcloudsql%2fproject%3alocation%3ainstance/dbname

[3]	(1, 2) SQLite connects to file based databases. The same URL format is used, omitting the hostname, and using the "file" portion as the filename of the database. This has the effect of four slashes being present for an absolute file path: sqlite:////full/path/to/your/database/file.sqlite.

[4]	Note that when connecting to Oracle the URL isn't in the form you may know from using other Oracle tools (like SQLPlus) i.e. user and password are separated by : not by /. Also you can omit HOST and PORT and provide a full DSN string or TNS name in NAME part.

[5]	Microsoft official mssql-django adapter.

[6]	(1, 2) Using the django-timescaledb Package which must be installed.

Example database URLs

config() reads DATABASE_URL and uses the default URL only when that environment variable is not set. To use a particular backend as the default, pass a URL for that backend:

import dj_database_url

DATABASES = {
    'default': dj_database_url.config(
        default='postgres://user:password@localhost:5432/mydatabase',
    ),
}

Replace the default value with an example URL for the backend you use:

• PostgreSQL: postgres://user:password@localhost:5432/mydatabase
• PostGIS: postgis://user:password@localhost:5432/mydatabase
• MSSQL (pyodbc): mssql://user:password@localhost:1433/mydatabase
• MSSQL (official): mssqlms://user:password@localhost:1433/mydatabase
• MySQL: mysql://user:password@localhost:3306/mydatabase
• MySQL (GIS): mysqlgis://user:password@localhost:3306/mydatabase
• SQLite: sqlite:////absolute/path/to/mydatabase.sqlite3
• SpatiaLite: spatialite:////absolute/path/to/mydatabase.sqlite3
• Oracle: oracle://user:password@localhost:1521/myservice
• Oracle (GIS): oraclegis://user:password@localhost:1521/myservice
• Redshift: redshift://user:password@localhost:5439/mydatabase
• CockroachDB: cockroach://user:password@localhost:26257/mydatabase
• Timescale: timescale://user:password@localhost:5432/mydatabase
• Timescale (GIS): timescalegis://user:password@localhost:5432/mydatabase

For SQLite, use four slashes before an absolute file path, as shown above. For connection options specific to a backend, see the URL schema notes and your Django backend's documentation.

Contributing

We welcome contributions to this project. Projects can take two forms:

1. Raising issues or helping others through the github issue tracker.
2. Contributing code.

Raising Issues or helping others:

When submitting an issue or helping other remember you are talking to humans who have feelings, jobs and lives of their own. Be nice, be kind, be polite. Remember english may not be someone first language, if you do not understand or something is not clear be polite and re-ask/ re-word.

Contributing code:

• Before writing code be sure to check existing PR's and issues in the tracker.
• Write code to the pylint spec.
• Large or wide sweeping changes will take longer, and may face more scrutiny than smaller confined changes.
• Code should be pass black and flake8 validation.