Django: Legacy DB Integrations

How it is possible to integrate a django project with a legacy database system

• Django is best suited for developing new applications.

• In case you want to use it in an already existing ecosystem you have to bear

in mind:

• To use all the built-in applications you need to create some tables.

• You can use many databases, one for the legacy data and one for the

django’s functionalities

• If your database is not well designed probably you’ll lost some of the

django’s orm features.

• Better if your legacy database is read-only

Assumptions

• Standard way:

• Let django creates users, group and permission tables in a database for you.

• All the built-ins work well.

• Custom way:

• Use your authentication system writing a custom authentication’s backend and plug

it in django

• Write a custom user model based on your legacy table and substitute the django

user model with it.

• You have to implements some methods in order to maintain compatibility with the

django’s built-ins

• Example: http://tomforb.es/using-a-custom-sqlalchemy-users-model-with-django

Django authentication system

• Configure the database parameters into the settings.py

• Do one or more of the followings:

• Run inspectdb over your schema

• Manually create models from tables

• Manually create unmanaged models from database views

• Manually create unmanaged models from RawQuerySet

• Use Python DB API or another ORM

Integrate django with your legacy db

• Django tries to write all models for you by reverse engineering your database.

• By default all the generated models are unmanaged (you can’t apply

migrations)

• Inspectdb is meant as a shortcut, not as definitive model generation. Indeed

you’ll have to look over the generated models yourself to make customizations:

• Make sure that all models have a primary key

• Rearrange models’ order

• Rename models’ fields with more meaningful names

Inspectdb commandpython manage.py inspectdb > models.py

• Naming:• You can call your model and its fields as you like.

• You can specify the table name inside model’s Meta class

• You can specifythe column’ s names using the field’attribute column_name

• Foreign Keys:• You can specify all the foreign keys you tables has.

• You can also specify foreign keys if there aren’t real constraint into the table

• It is sufficient that the column used as foreign key contains the related table’s ids.

• You don’t have to specify all columns as fields, just the one you will use

• You have to specify the primary key field

Manually create models from tables

• You can create your models starting from a logical or materialized view in the

same way you do for the tables.

• You have to specify the primary key field

• Same Naming and Foreign keys rules

• You cannot use these models to insert, delete or update

• They must be unmanaged

• You need databases authorizations in order to create custom views

Manually create models from views

• The model need to have a custom Manager (the one who retrieves the data and

instantiates the model)

• The custom manager use a RawQuerySet object to query the db.

• The query must retrieve all the columns specified in the model

• The query can span across multiple tables

• You have to specify the primary key field

• Same Naming and Foreign keys rules

• You can’t use Django ORM features, you have to implements all the query methods you

need

• RawQuerySet allows you to make parameterized queries

Manually create models from RawQuerySet

• Django provide a way to perform query directly to the db via django.db.connection:

https://docs.djangoproject.com/en/1.7/topics/db/sql/#executing-custom-sql-directly

• You can execute either SELECT, INSERT, DELETE or UPDATE but you can’t use django’s

models.

• Alternatively you can use a completely different ORM like SQLAlchemy to manage your

database.

• Both these methods cannot be compatible with many of the built-in features of django.

Use Python DB API or other ORM

Constraints Model instances

ORM query and filtering on the same model

ORM relationship queries

ORM Insert, Update and Delete Operations

Django Admin Django Migrate

Inspectdb Every model must have only one field with PrimaryKey = True

Inspectdb runs across all tables in the schema

Manually check the models compliance

YES YES YES If the related models are ORM query compliance

YES YES YES if managed = True

Manually created models from tables

Every model must have only one field with PrimaryKey = True

You have to create a model for each needed table

YES YES YES If the related models are ORM query compliance

YES YES YES if managed = True

Manually created unmanaged models from views

Every model must have only one field with PrimaryKey = True (easly done inside sql with row_count)

Database write permission needed

YES YES YES If the related models are ORM query compliance

NO YES but read only

NO

RawQuerySet Every model must have only one field with PrimaryKey = True (easly done inside sql with row_count)

You have to write raw sql inside python’s scripts

YES NO, you have to write every query method by yourself

YES If the related models are ORM query compliance

NO NO NO

Python DB API or other ORMs

You have to do all by hand!!! NO NO NO NO NO NO

Database integrations summary