In this tutorial, we are going to explain the how to connect the Django Framework with a database, such as - Oracle Database 18c Express Edition Release 18.0.0.0.0.
If you are trying to connect Django Framework with Oracle database, then you need to install the cx_Oracle package.
Softwares required before we install cx_Oracle
To connect Python with Oracle database using cx_Oracle, we need the have the following software packages installed in our system:
You must have installed Django(we have Django 2.2.2 version).
You must have installed Python(we have Python 3.7.3 version).
Note: Please make sure to follow the links of the above software packages to install the correct and the latest version(at the time of writing this tutorial)of each software. An older version of any of these software may not work the new version of the other mentioned software.
Once we have installed all the above mentioned software packages, we need to move to the next step i.e. installing the cx_Oracle module.
Installing cx_Oracle package
The cx_Oracle is a module which acts as a communication channel between Python API and Oracle database.
To install the cx_Oracle, you need to open the command prompt and move to the directory where the pip.exe is present on your system.
Once you've correctly installed the Python languages, the directory of pip.exe is - "C:\Users\User_Name\AppData\Local\Programs\Python\Python37\Scripts"
Move to the above mentioned directory and enter the following command:
pip install cx_Oracle
This installs the cx_Oracle in our system.
And that's it! We have installed all the important software packages needed to connect Django Framework with Oracle database using Python language. In the next tutorial, we are going to teach you about how to connect a Django project with Oracle database using Python. So, please turn over the page.
Creating a Django Project
So let us create a Django project to explain you how to work with the Django Framework in connection with a database. For those who have not read our last tutorials and for those who don't know how to create a Django project, here is a recap.
Creating a Django project
To create a directory for our project, we need to open the Command Prompt and type in the command -
django-admin startproject django_db2
dhago-admin is a management utility for Django Framework, using which we could create a new project and much more.
startproject is a command to start a new Django project.
django_db2 is the name of our Django project and also the name of our project directory created in the current directory.
The startproject command gives us a sub-directory and files
Executing the startproject command has not only created a project directory named django_db2, but has also created a file manage.py and another sub-directory
with the same name as the project directory, which also contains some Python files -
django_db2 is the root directory of our Django project, also known as the container of our project.
manage.py is a command-line utility which allows us to interact with Django project in various ways.
django_db2 sub-directory is actually a Python package for our project. We can import this package(a group of modules) and its contents just like we import any general Python package/module and its contents.
__init__.py is a file which allows our sub-directory django_proj1 to be treated as a Python package.
settings.py is a file used for setting the configurations for our Django project.
urls.py is a file used to specify the URL declarations for our Django project, also known as a a table of contents.
wsgi.py is a file used as an entry-point for WSGI web-servers to serve your project.
Starting the development server
After creating the project directory and the files required to run our Django project, it is time to execute the Django Development Server. To do this,
we will have to open the command prompt, change the current directory to the root directory of our Django project and execute the following command.
python manage.py runserver
Executing the above mentioned command will trigger the Django Development Server in action, as you can see in the picture below.
Now that you have successfully started the Django development server, it is time to visit the http://127.0.0.1:8000/ link and you will see a webpage displaying a congratulatory message, as shown below.
Note: The runserver command runs the Django development server at the port 8000.
Creating an app in our project
A project may contain one or multiple applications. As we have already created a project, now let us create a welcome application in it which welcomes the user. This application will be created right under our root - project directory django_db2.
To create an application, we have to open another window command prompt, change the current directory to the root directory of our Django project and execute the following command -
python manage.py startapp customer
The command startapp in combination with manage.py utility is used to create an app of a project, using which we have created an app named - customer.
Executing the startapp command has not only created an application directory named customer in the root - project directory, but has also created the following set of Python files -
Next, we have to create a model class, where each model class corresponds to a database table on which we could perform database operations by using the Django Framework.
Each model class is a subclass of django.db.model.Model class.
Note: The upcoming model class - Customer_Info is defined in the file models.py, which is already created and stored in our application directory, customer. Let us just copy and paste the following code in models.py.
models.py
from django.db import models
# Creating our model class - Customer_Info
class Customer_Info(models.Model):
name = models.CharField(max_length=30)
address = models.CharField(max_length=50)
city = models.CharField(max_length=30)
state = models.CharField(max_length=50)
country = models.CharField(max_length=30)
def __str__(self):
return (self.name + ', ' + self.address + ', ' + self.city + ', ' + self.state + ', ' + self.country)
Each model class could have a number of class variables, where each class variable represents a database field in the database table.
Each database field is represented by an appropriate Field class, such as -
CharField class is used to specify character fields
DataTimeField class is used to specify the datetimes field.
URLField class is used to specify a URL field.
The name of the field is used a column name in the database table.
As you can see in the model class Customer_Info, we have defined its class variables such as name, address, city, state, country using the appropriate Field classes, where each of these class variables correspond to a column name in the database table.
Note: Django automatically gives an integer primary key field called id to each model class.
Installing the Model
Next, we need to add the app customer to our project by adding the reference to its configuration class in the INSTALLED_APPS property within the settings.py file(which is present within the django_db2 folder).
The CustomerConfig configuration class named CustomerConfig is present in the apps.py file within the app customer folder.
Within the settings.py file, you need to locate the property INSTALLED_APPS and copy-paste the full-path of this configuration file against it, as shown below and save the file.
Now Django Framework will include the customer app on executing this Django project.
Storing the migrations
Next, we need to execute the makemigrations command to tell Django Framework that we have made some changes to the existing models or have specified new models and in our case, we have specified a new model class in our app Customer.
We can execute the makemigrations command from within the project directory in combination with the manage.py file, as shown below.
python manage.py makemigrations customer
On executing the makemigrations command, the Django Framework store these changes as migrations within the file named 0001_initial.py, which is stored within the migrations folder of the customer app, as shown in the picture below.
Note: Migrations are just files specifying the changes to the existing models or when we specify new models.
Specifying the database configuration
Next, we need to specify the database configurations within the settings.py file(which is present within the django_db2 folder). These database configurations tells Django which database we are going to use and how to connect it. The database configurations settings could be different depending on the database you are using to connect to using the Django Framework.
Note: The upcoming database configurations are specific to Oracle Database.
Within the settings.py file, you need to locate the property DATABASES and specify the database configurations against each database setting such as engine, name, user, password, host, port, as shown below. Save the file once you've specified the database configurations.
While specifying the database setting, such as - password and host, please enter your Oracle's database password and username.
Now, using these database configurations, the Django Framework will be able to connect to the Oracle Database.
Executing the "sqlmigrate" command
If you want to see the SQL statements required to implement the migrations that we have stored, then please execute the sqlmigrate command, as shown below.
python manage.py sqlmigrate customer 0001
The sqlmigrate command should be executed with manage.py, followed by the name of the app, which in our case is customer, followed by the name the migration file that we have just created, which in our case is 0001, and it returns its equivalent SQL commands, which is displayed in the picture below.
Please Note:
The sqlmigrate command does not execute any SQL statement and no database table is created after executing this command, it only shows us the SQL statements required to implement our stored migrations. To execute these SQL statements, we need to execute the migrate command.
As you can see from the SQL statements in the picture above, a table Customer_Customer_Info will be created i.e. name of the app combined with an underscore(_) and name of the model class specified in the models.py file.
Executing the "migrate" command
So far, we have only stored the database migrations and have seen the SQL statements required to implement the migrations in a database. Now let's execute these SQL statements to implement the migrations and apply the changes to the database by using the migrate command, as shown below.
python manage.py migrate
The migrate command should be executed with manage.py and it applies the stored migrations(as shown below) and creates the necessary database tables corresponding to the model classes specified the file, models.py.
On executing the migrate command, a new database table customer_customer_info is created, which you can verify by entering the following SQL command at the SQL prompt in SQL PlUS:
SQL> select * from customer_customer_info;
no rows selected
SQL>
Inserting the data into database
Once we have created a database table, we can simply insert a row of data in this table by executing a few commands in Python. To do this, first we have to execute the following command at the command prompt which opens the Python shell, with a prompt >>>.
python manage.py shell
At Python Shell, we are going to enter a few Python statements to insert the data in this database table, as shown below. We are first going to import our model class Customer_Info, create its object and save it.
E:\Django Project2\django_db2>python manage.py shell
Python 3.7.3 (v3.7.3:ef4ec6ed12, Mar 25 2019, 22:22:05) [MSC v.1916 64 bit (AMD6
4)] on win32
Type "help", "copyright", "credits" or "license" for more information.
(InteractiveConsole)
>>> from customer.models import Customer_Info
>>> cust1 = Customer_Info(name='Shawn', address='271 N Monroe St', city='Tallaha
ssee', state='Florida', country='USA')
>>> cust1.save()
>>> customer_info_list = Customer_Info.objects.all()
>>> customer_info_list
<QuerySet [<Customer_Info: Shawn, 271 N Monroe St, Tallahassee, Florida, USA>]>
>>>
Program Analysis:
from customer.models import Customer_Info
We have first imported our model class Customer_Info, which is defined in the file models.py stored within our app customer
cust1 = Customer_Info(name='Shawn', address='271 N Monroe St', city='Tallahassee', state='Florida', country='USA')
Next, we have created and initialized an object of this model class.
cust1.save()
Finally, we have saved this object by using the save() function, which saves a row of data in the database table.
customer_info_list = Customer_Info.objects.all()
Next, we are going to retrieve all the saved object of the model class Customer_Info from the database, by calling the all() method of Django, like Customer_Info.objects.all(). This retrieves and returns a QuerySet that contains all Customer_Info objects in the database.
customer_info_list
At the end, we are just going to print the QuerySet object customer_info_list to display the values of the saved object in the database.
Displaying the saved object using SQL PLUS
Additionally, you could even run the SQL PLUS to see the content of the database table that we have just created and inserted data into, by entering the following SQL command at the SQL prompt:
SQL> select * from customer_customer_info;
ID NAME ADDRESS CITY STATE COUNTRY
---------- ---------- ------------ ---------- ---------- -------------
23 Shawn 271 N Monroe Tallahasse Florida USA
