Django ORM Example

For Django, we need to set up a minimal Django project structure. We need to create a new directory and add the following files:

Project Structure

django_orm_example/
├── manage.py
├── myproject/
│ ├── **init**.py
│ ├── settings.py
│ └── models.py
└── run_example.py

Overview

The example demonstrates how to:

1. Set up a Django project with a SQLite database
2. Define a model using Django's ORM
3. Perform basic CRUD operations (Create and Read)

Code Explanation

Project Configuration (settings.py)

import os

BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

SECRET_KEY = 'your-secret-key'
DEBUG = True
ALLOWED_HOSTS = []

INSTALLED_APPS = [
    'myproject',
]

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
    }
}

USE_TZ = True

This file configures the Django project, including the database settings (SQLite in this case) and installed apps.

Model Definition (models.py)

from django.db import models

class User(models.Model):
    username = models.CharField(max_length=50, unique=True)
    email = models.EmailField(unique=True)

    def __str__(self):
        return f"User: {self.username}, Email: {self.email}"

Here, we define the User model with two fields: username and email. The __str__ method provides a string representation of the object.

Django Management Script (manage.py)

#!/usr/bin/env python
"""Django's command-line utility for administrative tasks."""
import os
import sys

def main():
    """Run administrative tasks."""
    os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'myproject.settings')
    try:
        from django.core.management import execute_from_command_line
    except ImportError as exc:
        raise ImportError(
            "Couldn't import Django. Are you sure it's installed and "
            "available on your PYTHONPATH environment variable? Did you "
            "forget to activate a virtual environment?"
        ) from exc
    execute_from_command_line(sys.argv)

if __name__ == '__main__':
    main()

The manage.py file is a command-line utility that lets you interact with your Django project in various ways. It's automatically created in each Django project.

Key points about manage.py:

1. It sets up the Django environment by specifying the settings module.

2. It provides a way to run Django management commands. For example:

   • python manage.py runserver to start the development server
   • python manage.py makemigrations to create new migrations
   • python manage.py migrate to apply migrations

3. It handles exceptions if Django isn't installed or can't be imported.

4. While not used directly in our ORM example, it's crucial for many Django development tasks and would be used in a full Django application.

In a typical Django workflow, you'd use manage.py for tasks like creating database tables (python manage.py migrate), but our example script (run_example.py) bypasses this for simplicity.

Database Operations (run_example.py)

import os
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "myproject.settings")

import django
django.setup()

def run_example():
    from django.db import connection
    from myproject.models import User
    # Ensure the model table is created
    with connection.schema_editor() as schema_editor:
        schema_editor.create_model(User)

    try:
        new_user = User(username='jane_doe', email='jane@example.com')
        new_user.save()

        user = User.objects.get(username='jane_doe')
        print(user)
    except Exception as e:
        print(f"An error occurred: {e}")

if __name__ == "__main__":
    run_example()
    print(f"SQLite database created at: {os.path.abspath('db.sqlite3')}")

This script demonstrates:

1. Setting up the Django environment
2. Creating the necessary database table
3. Creating a new user (Create operation)
4. Retrieving that user from the database (Read operation)
5. Error handling
6. Printing the location of the created database file

Additional Notes

• The manage.py file is Django's command-line utility for administrative tasks, but it's not used directly in this example.
• This example uses a minimal Django setup without the full project structure typically created by django-admin startproject.
• In a real-world scenario, you'd typically use Django's migration system to create database tables, but this example manually creates the table for simplicity.

Django Imports in "run_example.py"

It is generally considered good practice in Python to have all imports at the top of the module. However, in this specific case with Django, there's a particular reason why the imports need to be structured this way. Let's break it down:

• The placement of django.setup() is crucial. It needs to be called before any Django-specific imports (like models) are made.
• The os.environ.setdefault() call must come before django.setup().
• Importing Django models or other Django-specific modules should happen after django.setup() has been called.

The reason for this structure is that django.setup() configures Django's settings and initializes various components. Without this setup, Django-specific imports will fail because the Django environment isn't properly configured yet.

Running the Example

Install Django:

pip install django

Run migrations:

python manage.py migrate

Run the example:

python run_example.py

The script will create a SQLite database file, add a user to it, retrieve and print the user's information, and then display the location of the created database file.