Initializing the Framework Environment

To execute framework-specific database interactions from an isolated Python script outside the standard command-line utilities, the application configuration must be explicitly loaded. This routine requires defining the settings module path and invoking the environment setup prior to importing any model classes.

import os
import sys
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'core_project.settings')

import django
django.setup()

# Models can now be safely imported
from inventory.models import InventoryRecord

Single-Entity CRUD Operations

Schema Definition

Database tables map directly to Python classes inheriting from models.Model. The following schema demonstrates basic field constraints, custom string representation, and timestamp automation.

class InventoryRecord(models.Model):
    product_name = models.CharField(max_length=64)
    unit_cost = models.DecimalField(max_digits=10, decimal_places=2)
    creation_timestamp = models.DateField(auto_now_add=True)
    last_modified = models.DateField(auto_now=True)

    def __str__(self):
        return f'<Inventory: {self.product_name}>'

After defining the clas, execute the migration utilities to synchronize the schema with the underlying database.

Record Creation

Persisting new rows can be achieved through a manager shortcut or explicit class instantiation followed by a save operation.

# Approach 1: Manager shortcut (immediately persists)
item_a = InventoryRecord.objects.create(
    product_name='Wireless Mouse', 
    unit_cost=45.99, 
    creation_timestamp='2023-05-15'
)

# Approach 2: Class instantiation + explicit save
item_b = InventoryRecord(product_name='Mechanical Keyboard', unit_cost=120.50)
item_b.save()

Data Retrieval

Query execution returns either a collection-like object or a single instance. The filter() method yields a lazy evaluation set that supports chaining, whereas get() extracts exactly one object and raises exceptions if multiple or zero matches occur.

# Fetches a collection (lazy evaluation, supports .query for SQL inspection)
results = InventoryRecord.objects.filter(id__gt=10)
print(results.query)

# Fetches a single instance (strict)
try:
    target = InventoryRecord.objects.get(pk=1)
except InventoryRecord.DoesNotExist:
    target = None

Record Modification & Removal

Updating can target multiple rows efficiently via the manager, or modify a single instance by altering attributes and committing changes. Deletion follows the same pattern.

# Bulk update (single SQL UPDATE statement)
InventoryRecord.objects.filter(product_name='Wireless Mouse').update(unit_cost=39.99)

# Instance-level modification
target = InventoryRecord.objects.get(id=1)
target.unit_cost = 35.00
target.save()

# Bulk deletion
InventoryRecord.objects.filter(creation_timestamp__lt='2020-01-01').delete()

# Instance deletion
old_item = InventoryRecord.objects.get(id=5)
old_item.delete()

Core QuerySet Manipulation Techniques

Framework queries are evaluated lazily; the database is only contacted when the results are consumed or printed. The following methods form the foundation of data retreival.

# 1. Retrieve all records
all_items = InventoryRecord.objects.all()

# 2. Filtered subset (translates to WHERE clause with AND logic)
filtered = InventoryRecord.objects.filter(unit_cost__gt=50, product_name__icontains='mouse')

# 3. Single object extraction
exact_match = InventoryRecord.objects.get(id=10)

# 4. Boundary elements
first_record = InventoryRecord.objects.first()
last_record = InventoryRecord.objects.last()

# 5. Aggregate count
total_entries = InventoryRecord.objects.count()

# 6. Dictionary projection
dict_view = InventoryRecord.objects.values('product_name', 'unit_cost')

# 7. Tuple projection
tuple_view = InventoryRecord.objects.values_list('product_name', 'unit_cost')

# 8. Sorting
ascending = InventoryRecord.objects.order_by('unit_cost')
descending = InventoryRecord.objects.order_by('-unit_cost')

# 9. Reversal order (requires prior ordering)
reversed_set = InventoryRecord.objects.order_by('id').reverse()

# 10. Exclusion filter
not_mouse = InventoryRecord.objects.exclude(product_name__icontains='mouse')

# 11. Existence check (boolean)
has_records = InventoryRecord.objects.filter(id=999).exists()

# 12. Deduplication (requires identical rows including primary keys unless using values())
unique_costs = InventoryRecord.objects.values('unit_cost').distinct()

Field Lookups with Double Underscores

Advanced filtering leverages a specific syntax to generate comparison operators and pattern matching directly within the ORM, avoiding manual SQL concatenation.

# Greater than / Less than or equal
over_budget = InventoryRecord.objects.filter(unit_cost__gt=200)
under_budget = InventoryRecord.objects.filter(unit_cost__lte=100)

# Membership and range
specific_items = InventoryRecord.objects.filter(id__in=[1, 5, 9])
range_items = InventoryRecord.objects.filter(unit_cost__range=[50, 150])

# Date extraction
year_2023 = InventoryRecord.objects.filter(creation_timestamp__year=2023)
month_dec = InventoryRecord.objects.filter(creation_timestamp__month=12)

# String pattern matching
starts_with_k = InventoryRecord.objects.filter(product_name__startswith='K')
ends_with_x = InventoryRecord.objects.filter(product_name__endswith='x')
contains_usb = InventoryRecord.objects.filter(product_name__contains='USB')
# Case-insensitive variant
contains_usb_ci = InventoryRecord.objects.filter(product_name__icontains='usb')

Relational Data Modeling & Operations

Handling interconnected tables requires understanding foreign key assignments, many-to-many junction tables, and automated timestamp fields. Relations are defined via ForeignKey and ManyToManyField.

Foreign Key (One-to-Many) Management

Establish relationships by referencing the related model’s instance or its primary key identifier.

from inventory.models import Supplier, InventoryRecord

# Insert using ID directly
InventoryRecord.objects.create(product_name='Monitor', unit_cost=250.00, supplier_id=3)

# Insert using model instance
supplier_obj = Supplier.objects.filter(name='TechDistro').first()
InventoryRecord.objects.create(product_name='Cable', unit_cost=5.00, supplier=supplier_obj)

# Update relationship
InventoryRecord.objects.filter(id=4).update(supplier_id=7)
# Or via instance
InventoryRecord.objects.filter(id=4).update(supplier=supplier_obj)

# Deletion cascades by default unless explicitly overridden
Supplier.objects.filter(id=2).delete()

Many-to-Many Association Management

The junction table is manipulated through the related manager attached to the model instance. These methods accept primary keys or model instances.

# Establish links
record_obj = InventoryRecord.objects.get(id=4)
record_obj.technicians.add(101)
record_obj.technicians.add(101, 103)
record_obj.technicians.add(Technician.objects.get(id=105))

# Overwrite existing links (requires iterable, replaces current associations)
record_obj.technicians.set([102, 104])
record_obj.technicians.set([Technician.objects.get(id=106)])

# Remove specific links
record_obj.technicians.remove(102)
record_obj.technicians.remove(Technician.objects.get(id=103))

# Wipe all associations for this specific record
record_obj.technicians.clear()

Cross-Entity Query Strategies

Navigation across related tables follows directional logic. Forward traversal occurs from the table holding the relationship field. Reverse traversal moves from the referenced table back to the source.

Instance-Based Navigation

This approach relies on Python object attribute access. Forward queries use the field name directly. Reverse queries append _set to the source model name (except for one-to-one relationships).

# Forward: Record -> Supplier
entry = InventoryRecord.objects.get(id=4)
print(entry.supplier.name)

# Forward: Record -> Technicians (returns queryset due to potential multiples)
print(entry.technicians.all())

# Reverse: Supplier -> Records
vendor = Supplier.objects.get(name='TechDistro')
print(vendor.inventoryrecord_set.all())

# Reverse: Technician -> Records
tech = Technician.objects.get(employee_id=101)
print(tech.inventoryrecord_set.all())

# One-to-One Reverse (no _set suffix required)
contact_info = ContactProfile.objects.get(phone='555-0198')
print(contact_info.employee.name)

Double-Underscore Relational Queries

For optimized performance, the ORM generates SQL JOIN operations when traversing relationships using the __ syntax within values() or filter().

# Forward traversal in projection
supplier_names = InventoryRecord.objects.filter(id=4).values('supplier__company_name')

# Multi-hop reverse traversal
# Find technicians managing records under $50
cheap_item_techs = Technician.objects.filter(
    inventoryrecord__unit_cost__lt=50
).values('name', 'employee_id')

# Complex chain across three entities
# Retrieve phone numbers of technicians who worked on 'Cable' products
tech_phones = InventoryRecord.objects.filter(
    product_name='Cable'
).values('technicians__contact__phone_number')

# Alternative reverse chain achieving identical SQL structure
tech_phones_v2 = Technician.objects.filter(
    inventoryrecord__product_name='Cable'
).values('contact__phone_number')