Bài 2.1: Advanced Model Fields và Custom Fields - Phần 1

**Lưu ý:** Bài học này được chia thành nhiều phần do nội dung chi tiết: - **Bài 2.1 (bài này):** Advanced Field Types - JSONField, ArrayField, HStoreField - [**Bài 2.2:** Field Options, Validators và Meta Options](/django-advance/advanced-model-fields-phan-2) - [**Bài 2.3:** Custom Model Fields Creation](/django-advance/advanced-model-fields-phan-3) - [**Bài 2.4:** Computed Fields, Cached Properties và Model Mixins](/django-advance/advanced-model-fields-phan-4)

Mục Tiêu Bài 2.1

Sau khi hoàn thành Bài 2.1 này, bạn sẽ:

✅ Hiểu rõ và sử dụng thành thạo JSONField
✅ Làm việc với ArrayField trong PostgreSQL
✅ Sử dụng HStoreField cho key-value storage
✅ Biết khi nào nên dùng field nào
✅ Query và filter dữ liệu trong advanced fields
✅ Hiểu performance implications của từng field type

Tại Sao Cần Advanced Fields?

Django Basic vs Advanced Models

Django Basic (đã học):

# Simple, straightforward fieldsclass Product(models.Model):    name = models.CharField(max_length=200)    price = models.DecimalField(max_digits=10, decimal_places=2)    category = models.CharField(max_length=50)    in_stock = models.BooleanField(default=True)

Limitations:

❌ Không flexible cho complex data
❌ Khó scale khi requirements thay đổi
❌ Cần nhiều related tables cho simple relationships
❌ Performance issues với many joins

Django Advanced (sẽ học):

# Flexible, scalable fieldsclass Product(models.Model):    name = models.CharField(max_length=200)    price = models.DecimalField(max_digits=10, decimal_places=2)        # Store complex attributes without extra tables    attributes = models.JSONField(default=dict)  # {"color": "red", "size": "XL"}        # Store multiple values efficiently    tags = models.ArrayField(        models.CharField(max_length=50),        default=list    )        # Flexible key-value pairs    metadata = models.HStoreField(default=dict)

Advantages:

✅ Flexible schema
✅ Fewer database tables
✅ Easier to evolve
✅ Better performance trong many cases

Khi Nào Dùng Advanced Fields?

Use Cases Phù Hợp:

JSONField:
- User preferences/settings
- Product attributes (vary by category)
- API responses cần store
- Configuration data
- Audit logs
- Flexible metadata
ArrayField:
- Tags, categories
- Multiple phone numbers
- Multiple emails
- Skills, interests
- Feature flags
- Simple lists không cần normalization
HStoreField:
- Simple key-value pairs
- Translations (key: language, value: text)
- Custom attributes
- Metadata không complex

Khi KHÔNG Nên Dùng:

❌ Data cần frequent complex queries
❌ Data cần referential integrity
❌ Data cần full-text search (dùng dedicated search engine)
❌ Highly relational data
❌ Data cần foreign key constraints

1. JSONField - The Swiss Army Knife

Giới Thiệu JSONField

JSONField (Django 3.1+) cho phép store JSON objects directly trong database. Nó work với PostgreSQL, MySQL 5.7+, MariaDB 10.2+, và SQLite 3.9+.

Tại Sao JSONField Mạnh Mẽ:

Store complex nested data
Query JSON data directly trong database
No schema changes khi data structure evolves
Native JSON support trong modern databases

Basic Usage

Định Nghĩa Model

from django.db import models class UserProfile(models.Model):    user = models.OneToOneField('auth.User', on_delete=models.CASCADE)        # Simple JSON field    preferences = models.JSONField(default=dict, blank=True)        # JSON với default value phức tạp    settings = models.JSONField(        default=dict,        blank=True,        help_text="User application settings"    )        # JSON có thể null    metadata = models.JSONField(null=True, blank=True)

Best Practice - Default Values:

# ✅ GOOD: Use callablepreferences = models.JSONField(default=dict)tags = models.JSONField(default=list) # ❌ BAD: Don't use mutable default directlypreferences = models.JSONField(default={})  # All instances share same dict!

Storing Data

# Create với JSON dataprofile = UserProfile.objects.create(    user=user,    preferences={        'theme': 'dark',        'language': 'vi',        'notifications': {            'email': True,            'push': False,            'sms': True        },        'privacy': {            'show_email': False,            'show_phone': True        }    }) # Update JSON fieldprofile.preferences['theme'] = 'light'profile.preferences['notifications']['push'] = Trueprofile.save() # Update nested valuesprofile.preferences.update({    'sidebar_collapsed': True,    'font_size': 14})profile.save()

Important Note về Updates:

# ⚠️ PITFALL: Django không track nested changes automaticallyprofile.preferences['theme'] = 'dark'profile.save()  # May not save! (depends on Django version) # ✅ SOLUTION 1: Explicitly mark field as changedfrom django.db.models import F profile.preferences['theme'] = 'dark'profile.save(update_fields=['preferences']) # ✅ SOLUTION 2: Reassign entire fieldprefs = profile.preferencesprefs['theme'] = 'dark'profile.preferences = prefsprofile.save() # ✅ SOLUTION 3: Use F() object for atomic updatesfrom django.db.models import F UserProfile.objects.filter(pk=profile.pk).update(    preferences=F('preferences')  # Trigger update)

Querying JSONField

JSONField hỗ trợ powerful querying capabilities:

Basic Queries

# Exact matchUserProfile.objects.filter(preferences={'theme': 'dark'}) # Key existsUserProfile.objects.filter(preferences__has_key='theme') # Multiple keys existUserProfile.objects.filter(    preferences__has_keys=['theme', 'language']) # Any of keys existUserProfile.objects.filter(    preferences__has_any_keys=['theme', 'layout'])

Nested Queries

# Access nested values với __ (double underscore)UserProfile.objects.filter(    preferences__theme='dark') # Deep nestingUserProfile.objects.filter(    preferences__notifications__email=True) # Multiple nested conditionsUserProfile.objects.filter(    preferences__notifications__email=True,    preferences__privacy__show_email=False)

Advanced Queries

from django.db.models import Q # Contains (subset)UserProfile.objects.filter(    preferences__contains={'theme': 'dark'}) # Contained by (superset check)UserProfile.objects.filter(    preferences__contained_by={'theme': 'dark', 'language': 'vi', 'extra': 'value'}) # Combined queriesUserProfile.objects.filter(    Q(preferences__theme='dark') | Q(preferences__theme='auto')) # ExcludeUserProfile.objects.exclude(    preferences__notifications__push=False)

Filtering với List Values

# When JSON contains arraysclass Article(models.Model):    title = models.CharField(max_length=200)    tags = models.JSONField(default=list)  # ["django", "python", "web"] # Contains any tagArticle.objects.filter(tags__contains=['django']) # Contains all tagsArticle.objects.filter(    tags__contains=['django', 'python']) # Length of arrayfrom django.db.models.functions import JSONLength Article.objects.annotate(    tag_count=JSONLength('tags')).filter(tag_count__gte=3)

JSONField Best Practices

1. Schema Design

# ✅ GOOD: Consistent structureclass Product(models.Model):    name = models.CharField(max_length=200)    attributes = models.JSONField(default=dict)        # Always expect: {"color": "red", "size": "M", "material": "cotton"} # ❌ BAD: Inconsistent structure# Sometimes: {"color": "red"}# Sometimes: {"dimensions": {"width": 10, "height": 20}}# Sometimes: ["feature1", "feature2"]

Define Schema Contract:

# In models.py or separate schema filePRODUCT_ATTRIBUTES_SCHEMA = {    "type": "object",    "properties": {        "color": {"type": "string"},        "size": {"type": "string", "enum": ["S", "M", "L", "XL"]},        "material": {"type": "string"}    },    "required": ["color", "size"]} # Validate trong clean() method (sẽ học ở Bài 2.2)

2. Indexing JSONField

# Create GIN index for better query performance (PostgreSQL)from django.contrib.postgres.indexes import GinIndex class Product(models.Model):    name = models.CharField(max_length=200)    attributes = models.JSONField(default=dict)        class Meta:        indexes = [            GinIndex(fields=['attributes']),        ] # Index specific JSON path (PostgreSQL)from django.db import models class Product(models.Model):    attributes = models.JSONField(default=dict)        class Meta:        indexes = [            models.Index(                fields=['attributes__color'],                name='idx_product_color'            ),        ]

Performance Considerations:

✅ GIN indexes speed up containment queries (@>, <@)
✅ Path indexes speed up specific key queries
⚠️ Indexes increase storage và slow down writes
⚠️ Choose wisely based on query patterns

3. Migration Strategies

# When adding JSONField to existing modelfrom django.db import migrations, models class Migration(migrations.Migration):    dependencies = [        ('myapp', '0001_initial'),    ]        operations = [        # Add field        migrations.AddField(            model_name='product',            name='attributes',            field=models.JSONField(default=dict, blank=True),        ),                # Migrate existing data        migrations.RunPython(migrate_to_json, reverse_code=migrations.RunPython.noop),    ] def migrate_to_json(apps, schema_editor):    Product = apps.get_model('myapp', 'Product')        for product in Product.objects.all():        # Convert old fields to JSON        product.attributes = {            'color': product.color_old_field,            'size': product.size_old_field,        }        product.save(update_fields=['attributes'])

Real-World Use Cases

Use Case 1: E-commerce Product Attributes

class Product(models.Model):    name = models.CharField(max_length=200)    category = models.ForeignKey('Category', on_delete=models.CASCADE)    price = models.DecimalField(max_digits=10, decimal_places=2)        # Flexible attributes per category    attributes = models.JSONField(default=dict)    # Electronics: {"brand": "Sony", "warranty": "2 years", "voltage": "220V"}    # Clothing: {"color": "blue", "size": "M", "material": "cotton"}    # Books: {"author": "John Doe", "pages": 350, "isbn": "1234567890"} # Query products# Find all blue productsProduct.objects.filter(attributes__color='blue') # Find electronics with warranty >= 2 yearsProduct.objects.filter(    category__name='Electronics',    attributes__warranty__contains='2')

Use Case 2: User Activity Logs

class ActivityLog(models.Model):    user = models.ForeignKey('auth.User', on_delete=models.CASCADE)    action = models.CharField(max_length=50)  # "login", "purchase", "view_product"    timestamp = models.DateTimeField(auto_now_add=True)        # Flexible context data    context = models.JSONField(default=dict)    # Login: {"ip": "192.168.1.1", "device": "mobile", "browser": "Chrome"}    # Purchase: {"product_id": 123, "amount": 99.99, "payment_method": "credit_card"}    # View: {"product_id": 456, "duration": 30, "referrer": "google"} # Analytics queriesfrom django.db.models import Count # Count logins by device typeActivityLog.objects.filter(    action='login').values(    'context__device').annotate(    count=Count('id')) # Find users who viewed product but didn't purchaseviewed_users = set(    ActivityLog.objects.filter(        action='view_product',        context__product_id=123    ).values_list('user_id', flat=True)) purchased_users = set(    ActivityLog.objects.filter(        action='purchase',        context__product_id=123    ).values_list('user_id', flat=True)) potential_customers = viewed_users - purchased_users

Use Case 3: Multi-Language Content

class Article(models.Model):    slug = models.SlugField(unique=True)    author = models.ForeignKey('auth.User', on_delete=models.CASCADE)    published_date = models.DateTimeField(auto_now_add=True)        # Multi-language content    content = models.JSONField(default=dict)    # {    #     "en": {"title": "Hello", "body": "World"},    #     "vi": {"title": "Xin chào", "body": "Thế giới"},    #     "ja": {"title": "こんにちは", "body": "世界"}    # } # Helper methoddef get_localized_content(self, language='en'):    return self.content.get(language, self.content.get('en', {})) # Usagearticle = Article.objects.get(slug='my-article')vi_content = article.get_localized_content('vi')print(vi_content['title'])  # "Xin chào" # Query by languageArticle.objects.filter(content__has_key='vi')  # Articles with Vietnamese translationArticle.objects.filter(content__vi__title__icontains='django')  # Search in Vietnamese title

JSONField Performance Tips

1. Avoid Over-Nesting:

# ❌ BAD: Too deep{    "user": {        "profile": {            "settings": {                "privacy": {                    "email": {                        "visible_to": "friends"                    }                }            }        }    }} # ✅ GOOD: Flatten when possible{    "privacy_email_visible_to": "friends",    "privacy_phone_visible_to": "public"}

2. Limit JSON Size:

# ⚠️ Warning: Large JSON affects performance# Keep JSON fields under 1-2 KB when possible# For large data, consider:# - Separate table# - File storage# - Dedicated document store (MongoDB, Elasticsearch)

3. Selective Field Loading:

# Only load needed fieldsProduct.objects.only('id', 'name', 'price')  # Exclude heavy JSON # Defer JSON fields when not neededProduct.objects.defer('attributes', 'metadata')

Tóm Tắt Bài 2.1

Trong Bài 2.1 này, bạn đã học:

✅ JSONField Fundamentals:

Store complex nested data
Default values với dict/list
Update patterns và pitfalls

✅ Querying JSON:

Basic filtering với keys
Nested queries
Containment operations
Array filtering

✅ Best Practices:

Schema consistency
Indexing strategies
Migration patterns
Performance optimization

✅ Real-World Use Cases:

E-commerce attributes
Activity logs
Multi-language content
Flexible metadata

Bài Tập Thực Hành

Bài Tập 1: User Preferences System

Tạo một preference system cho users với các requirements:

Requirements:

Store theme (light/dark/auto)
Store notification settings (email, push, sms - each true/false)
Store display settings (font_size: 12-18, sidebar_collapsed: boolean)
Store privacy settings (profile_visible, email_visible, phone_visible)

Tasks:

Define UserPreference model với JSONField
Implement methods: get_preference(), set_preference(), reset_to_defaults()
Query users với dark theme enabled
Query users với email notifications enabled
Create migration to add indexes

Bài Tập 2: Product Catalog

Build a flexible product catalog:

Requirements:

Products có dynamic attributes based on category
Electronics: brand, warranty_years, voltage
Clothing: color, size, material, care_instructions
Books: author, publisher, isbn, pages, language

Tasks:

Define Product model với category và attributes JSONField
Create sample products in each category
Query all blue clothing items
Query electronics với warranty >= 2 years
Query books by specific author
Add GIN index on attributes

Bài Tập 3: Event Logging System

Create an event logging system:

Requirements:

Log different event types: login, logout, purchase, view, search
Each event type có different context data
Login: ip_address, user_agent, location
Purchase: product_ids[], total_amount, payment_method
Search: query, results_count, filters_applied

Tasks:

Define EventLog model
Log 10 different events
Query all login events from specific IP
Find all purchases over $100
Count events by type
Find users who searched but didn't purchase

Next Steps

Trong Bài 2.2, bạn sẽ học:

Field Options chi tiết (null, blank, default, choices)
Custom Validators creation
Field validation patterns
Meta Options trong models
Best practices for field configuration

Navigation:

← Bài 1.4: Career Path
Bài 2.1: JSONField và Advanced Field Types (current)
Bài 2.2: Field Options và Validators →

#jsonfield

Advanced Model Fields và Custom Fields - Phần 1