############################## Tables ##############################

CREATE TABLE Course (

    id INTEGER PRIMARY KEY AUTOINCREMENT,

    -- Other Course fields );

CREATE TABLE Project (

    id INTEGER PRIMARY KEY AUTOINCREMENT,

    course_id INTEGER REFERENCES Course(id) ON DELETE CASCADE,

    -- Other Project fields );

CREATE TABLE Learner (

    id INTEGER PRIMARY KEY AUTOINCREMENT,

    user_id INTEGER UNIQUE REFERENCES auth_user(id) ON DELETE CASCADE,

    -- Other Learner fields );

CREATE TABLE AssignedProject (

    id INTEGER PRIMARY KEY AUTOINCREMENT,

    learner_id INTEGER REFERENCES Learner(id) ON DELETE CASCADE,

    project_id INTEGER REFERENCES Project(id) ON DELETE CASCADE,

    assigned_date DATE,

    UNIQUE (learner_id, project_id));

################################ Django equivalent Models ##############################

class Course(models.Model):

    # Course fields

class Project(models.Model):

    course = models.ForeignKey(Course, on_delete=models.CASCADE)

class Learner(models.Model):

    user = models.OneToOneField(User, on_delete=models.CASCADE)

    projects_completed = models.ManyToManyField(Project, through='AssignedProject')

class AssignedProject(models.Model):

    learner = models.ForeignKey(Learner, on_delete=models.CASCADE)

    project = models.ForeignKey(Project, on_delete=models.CASCADE)

    assigned_date = models.DateField()

    class Meta:

        unique_together = ('learner', 'project') # Ensure uniqueness of learner-project pairs

################################ CRUD operations using ORM  ##############################

### Create

course = Course.objects.create(name="Django Course") # Create a Course

project = Project.objects.create(course=course, name="Django Project") # Create a Project

user = User.objects.create(username="john_doe") # Create a User

learner = Learner.objects.create(user=user) # # Create a User associated Learner

AssignedProject.objects.create(learner=learner, project=project, assigned_date=date.today()) # Assign Project to Learner (many-to-many relationship)

### Read

all_courses = Course.objects.all() # Retrieve all courses

course = Course.objects.get(pk=1) # Retrieve a specific course by ID

projects_of_course = course.project_set.all() # Retrieve all projects associated with a course

user = User.objects.get(username="john_doe").learner # Retrieve a specific learner by user

projects_completed_by_learner = learner.projects_completed.all() # Retrieve all projects completed by a learner

# Update a learner

learner = Learner.objects.get(pk=1)

learner.user.first_name = "John"

learner.user.save()

### Delete

project.delete()

### Adding related objects

projects = Project.objects.filter(course__name='Django Course')

learner.projects_completed.add(*projects) # Adding new related objects

learner.projects_completed.remove(*projects) # Removing related objects

learner.projects_completed.clear() # Remove all related objects

################################ Accessing Related objects  ##############################

# Learner has foreign key of User (with one-to-one relationship: user = models.OneToOneField(User))

learner = Learner.objects.get(name="abir")

learner.user # forward access

user.learner # backward access

# Project has foreign key of Course (with many-to-one relationship: course = ForeignKey(Course))

project.course # Forward access

course.project_set.all() # backward access. all because there are many courses

# Learner has foreign key of Project (with many-to-many relationship: projects_completed = models.ManyToManyField('Project', related_name='completed_by'))

learner.projects_completed.all() # forward access

project.completed_by.all() # backward access

# Learner is a subclass of User (class Learner(User) , and it is one-to-one relationship)

learner.user_ptr # Forward access to parent object

user.learner # Backward access to child object 

# Learner has foreign key of Project through intermediate table ("AssignedProject")

assigned_projects = AssignedProject.objects.filter(learner=learner).all() # Access all projects for specified learner

assigned_learners = AssignedProject.objects.filter(project=project).all() # Access all learners for specified project

################################ Some Other Common Operations  ##############################

queryset = EntityName.objects.all().delete() # .count()

queryset = EntityName.objects.order_by('-colName')[2] # Second row after sorting in descending order

print(str(queryset.query)) # See SQL equivalent query

queryset = EntityName1.objects.filter(foreignEntityField__colName__gt=5)  # Filtering: foreignEntityKey is relation to another table

queryset = EntityName.objects.exclude(colName__gt=5)  # Filtering with NOT operation

queryset = queryset1.union(queryset2) # UNION

from django.db.models import Q

queryset = EntityName.objects.filter(Q(colName__startswith='R')|Q(colName__startswith='D'))  # Alternative approach for OR

queryset = EntityName.objects.filter(~Q(colName__startswith='R'))  # Alternative approach for NOT

The Django web framework includes a default object-relational mapping layer (ORM) that can be used to interact with application data from various relational databases such as SQLite, PostgreSQL and MySQL. The Django ORM is an implementation of the object-relational mapping (ORM) concept.