In Django, a model is a Python class that represents a database table. It is used to define the structure of your database and provides an abstraction layer to interact with the database without writing raw SQL queries. Django models are part of Django’s Object-Relational Mapping (ORM) system, which means they allow you to work with the database using Python objects rather than writing SQL queries directly

Key Concepts of a Django Model:

Model Class:

• A model is defined as a Python class that inherits from django.db.models.Model.
• The attributes (or fields) of the model class correspond to the columns in the database table.
• Django automatically creates the necessary database table based on this model when you run migrations.

Fields:

• Fields in the model represent columns in the database table.
• Django provides a variety of field types (e.g., CharField, IntegerField, DateTimeField) that allow you to define the type of data that will be stored in each column.
• Example:
  • CharField for short text fields.
  • IntegerField for integer values.
  • DateTimeField for date and time values.

CharField field that translates into a VARCHAR column in the SQL database

SlugField field that translates into a VARCHAR column in the SQL database. A slug is a short label that contains only letters,numbers, underscores, or hyphens. . We will use the slug field to build beautiful, SEO-friendly URLs.

TextField field that translates into a TEXT column in the SQL database.

DateTimeField field that translates into a DATETIME column in the SQL database.

Methods:

• You can define methods inside the model class, which are used to perform actions related to that model.
• For example, you can define a method to calculate something based on the model’s fields or to return a formatted representation of the model.

Relationships:

• Models can define relationships to other models, such as one-to-many, many-to-one, and many-to-many.
• Django uses fields like ForeignKey (for many-to-one), OneToOneField (for one-to-one), and ManyToManyField (for many-to-many relationships) to define these relationships.

Example of a Basic Django Model:

from django.db import models

class Author(models.Model):
    name = models.CharField(max_length=100)
    birth_date = models.DateField()

    def __str__(self):
        return self.name

class Book(models.Model):
    title = models.CharField(max_length=255)
    published_date = models.DateField()
    author = models.ForeignKey(Author, on_delete=models.CASCADE)  # Many-to-One relationship
    pages = models.IntegerField()

    def __str__(self):
        return self.title

How to Use Django Models:

Defining Models:

• Models are usually defined in the models.py file of a Django app.
• Once you define a model, Django will create the corresponding database table when you run the makemigrations and migrate commands.

Creating Migrations:

• After defining or modifying your models, you need to create a migration. Migrations are Django’s way of propagating changes you make to your models into the database schema.

• Run the following command to create migrations:

  python manage.py makemigrations

  To apply the migrations and create or update the database tables, run:

  python manage.py migrate

   

Interacting with Models:

• Django provides a powerful ORM to interact with models. You can create, retrieve, update, and delete records without writing raw SQL.
• Example:

• # Creating an Author
  author = Author.objects.create(name="J.K. Rowling", birth_date="1965-07-31")
  
  # Creating a Book
  book = Book.objects.create(title="Harry Potter and the Philosopher's Stone", 
                             published_date="1997-06-26", 
                             author=author, 
                             pages=223)
  
  # Querying Books by Author
  books = Book.objects.filter(author=author)
  
  # Update a Book
  book.title = "Harry Potter and the Sorcerer's Stone"
  book.save()
  
  # Delete a Book
  book.delete()

Model Features and Benefits:

Abstraction:

• Django models allow you to work with database records as Python objects. This abstraction makes it easier to interact with the database without needing to write raw SQL.

Validation:

• Django provides built-in validation for model fields. For example, you can specify that a field is required (blank=False) or has a maximum length (max_length=100).

Querying:

• Django provides powerful query capabilities through its ORM. You can filter, order, and perform complex queries with ease.

Data Integrity:

• Django automatically handles relationships between models (such as ForeignKey and ManyToMany), ensuring data integrity and enforcing constraints like "a book cannot exist without an author."

Migrations:

• Django’s migration system allows you to evolve your database schema without losing data. You can add or remove fields, change relationships, and much more, with Django automatically handling the underlying SQL.

Auto-incrementing Primary Key in Django Models

By default, Django automatically adds an auto-incrementing primary key field to each model. This primary key is a unique identifier for each record in the database table associated with the model. The field type for this primary key is specified either in the application configuration or globally in the DEFAULT_AUTO_FIELD setting.

When you create a new application using the startapp command, the default value for DEFAULT_AUTO_FIELD is set to BigAutoField. This field type is a 64-bit integer that automatically increments based on the available IDs, ensuring each record has a unique identifier.

If you don't explicitly define a primary key for your model, Django will automatically add this BigAutoField as the primary key. However, you can also define a custom primary key by setting primary_key=True on any other model field, allowing you to choose a field other than the auto-generated one as the unique identifier.