பைதான் DRF சீரியலைசர் உறவுகள்: நெஸ்டெட் ஆப்ஜெக்ட் சீரியலைசேஷனில் தேர்ச்சி பெறுதல்

Django REST Framework (DRF) இணைய API-களை உருவாக்குவதற்கான சக்திவாய்ந்த மற்றும் நெகிழ்வான அமைப்பை வழங்குகிறது. API உருவாக்கத்தின் ஒரு முக்கியமான அம்சம், தரவு மாதிரிகளுக்கு இடையிலான உறவுகளைக் கையாள்வது ஆகும். DRF சீரியலைசர்கள் நெஸ்டெட் ஆப்ஜெக்ட்களை சீரியலைஸ் மற்றும் டீசீரியலைஸ் செய்வதற்கு வலுவான வழிமுறைகளை வழங்குகின்றன. இந்த வழிகாட்டி DRF சீரியலைசர்களில் உறவுகளை நிர்வகிப்பதற்கான பல்வேறு வழிகளை ஆராய்கிறது, நடைமுறை எடுத்துக்காட்டுகள் மற்றும் சிறந்த நடைமுறைகளை வழங்குகிறது.

சீரியலைசர் உறவுகளைப் புரிந்துகொள்ளுதல்

ரிலேஷனல் டேட்டாபேஸ்களில், உறவுகள் வெவ்வேறு அட்டவணைகள் அல்லது மாதிரிகள் எவ்வாறு இணைக்கப்பட்டுள்ளன என்பதை வரையறுக்கின்றன. டேட்டாபேஸ் ஆப்ஜெக்ட்களை JSON அல்லது API பயன்பாட்டிற்கான பிற தரவு வடிவங்களாக மாற்றும்போது DRF சீரியலைசர்கள் இந்த உறவுகளை பிரதிபலிக்க வேண்டும். மூன்று முதன்மை உறவு வகைகளை நாங்கள் உள்ளடக்குவோம்:

• ForeignKey (ஒன்று-க்கு-பல): ஒரு ஆப்ஜெக்ட் பல ஆப்ஜெக்ட்களுடன் தொடர்புடையது. உதாரணமாக, ஒரு எழுத்தாளர் பல புத்தகங்களை எழுத முடியும்.
• ManyToManyField (பல-க்கு-பல): பல ஆப்ஜெக்ட்கள் பல ஆப்ஜெக்ட்களுடன் தொடர்புடையவை. உதாரணமாக, பல எழுத்தாளர்கள் பல புத்தகங்களில் கூட்டாக வேலை செய்யலாம்.
• OneToOneField (ஒன்று-க்கு-ஒன்று): ஒரு ஆப்ஜெக்ட் மற்றொரு ஆப்ஜெக்ட்டுடன் தனித்துவமாக தொடர்புடையது. உதாரணமாக, ஒரு பயனர் சுயவிவரம் பெரும்பாலும் ஒரு பயனர் கணக்குடன் ஒன்று-க்கு-ஒன்று இணைக்கப்பட்டுள்ளது.

ForeignKey உடன் அடிப்படை நெஸ்டெட் சீரியலைசேஷன்

ForeignKey உறவை சீரியலைஸ் செய்வதற்கான எளிய உதாரணத்துடன் தொடங்கலாம். இந்த மாதிரிகளைக் கவனியுங்கள்:

from django.db import models

class Author(models.Model):
    name = models.CharField(max_length=100)
    country = models.CharField(max_length=50, default='USA') # சர்வதேச சூழலுக்காக நாடு புலத்தைச் சேர்த்தல்

    def __str__(self):
        return self.name

class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.ForeignKey(Author, on_delete=models.CASCADE, related_name='books')
    publication_date = models.DateField()

    def __str__(self):
        return self.title

`Book` மாடலை அதன் தொடர்புடைய `Author` தரவுடன் சீரியலைஸ் செய்ய, நெஸ்டெட் சீரியலைசரைப் பயன்படுத்தலாம்:

from rest_framework import serializers

class AuthorSerializer(serializers.ModelSerializer):
    class Meta:
        model = Author
        fields = ['id', 'name', 'country']

class BookSerializer(serializers.ModelSerializer):
    author = AuthorSerializer(read_only=True) # PrimaryKeyRelatedField-லிருந்து மாற்றப்பட்டது

    class Meta:
        model = Book
        fields = ['id', 'title', 'author', 'publication_date']

இந்த எடுத்துக்காட்டில், `BookSerializer` `AuthorSerializer` புலத்தை உள்ளடக்கியது. `read_only=True` `author` புலத்தை படிக்க மட்டும் கூடியதாக ஆக்குகிறது, புத்தக எண்ட்பாயிண்ட் மூலம் ஆசிரியரின் மாற்றத்தைத் தடுக்கிறது. ஆசிரியர் தகவலுடன் புத்தகங்களை உருவாக்க அல்லது புதுப்பிக்க நீங்கள் விரும்பினால், நீங்கள் எழுதுவதற்கான செயல்பாடுகளை வித்தியாசமாக கையாள வேண்டும் (கீழே பார்க்கவும்).

இப்போது, நீங்கள் `Book` ஆப்ஜெக்டைச் சீரியலைஸ் செய்யும்போது, JSON வெளியீடு புத்தகத் தரவுக்குள் நெஸ்டெட் செய்யப்பட்ட முழு ஆசிரியர் விவரங்களையும் உள்ளடக்கும்:

{
    "id": 1,
    "title": "The Hitchhiker's Guide to the Galaxy",
    "author": {
        "id": 1,
        "name": "Douglas Adams",
        "country": "UK"
    },
    "publication_date": "1979-10-12"
}

ManyToManyField உறவுகளை சீரியலைஸ் செய்தல்

`ManyToManyField` உறவைக் கவனியுங்கள். எங்களிடம் `Category` மாடல் உள்ளது என்று வைத்துக்கொள்வோம், மேலும் ஒரு புத்தகம் பல வகைகளைச் சேர்ந்ததாக இருக்கலாம்.

class Category(models.Model):
    name = models.CharField(max_length=100)

    def __str__(self):
        return self.name

class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.ForeignKey(Author, on_delete=models.CASCADE, related_name='books')
    categories = models.ManyToManyField(Category, related_name='books')
    publication_date = models.DateField()

    def __str__(self):
        return self.title

நாங்கள் `serializers.StringRelatedField` அல்லது `serializers.PrimaryKeyRelatedField` ஐப் பயன்படுத்தி வகைகளை சீரியலைஸ் செய்யலாம் அல்லது நெஸ்டெட் சீரியலைசரை உருவாக்கலாம்.

class CategorySerializer(serializers.ModelSerializer):
    class Meta:
        model = Category
        fields = ['id', 'name']

class BookSerializer(serializers.ModelSerializer):
    author = AuthorSerializer(read_only=True)
    categories = CategorySerializer(many=True, read_only=True) # ManyToManyField-க்கு many=True அவசியம்

    class Meta:
        model = Book
        fields = ['id', 'title', 'author', 'categories', 'publication_date']

`ManyToManyField` ஐ சீரியலைஸ் செய்யும் போது `many=True` ஆர்க்யுமெண்ட் முக்கியமானது. இது ஒரு வகை ஆப்ஜெக்ட்களின் பட்டியலை எதிர்பார்க்க சீரியலைசருக்கு சொல்கிறது. வெளியீடு இப்படி இருக்கும்:

{
    "id": 1,
    "title": "Pride and Prejudice",
    "author": {
        "id": 2,
        "name": "Jane Austen",
        "country": "UK"
    },
    "categories": [
        {
            "id": 1,
            "name": "Classic Literature"
        },
        {
            "id": 2,
            "name": "Romance"
        }
    ],
    "publication_date": "1813-01-28"
}

OneToOneField உறவுகளை சீரியலைஸ் செய்தல்

`OneToOneField` உறவுகளுக்கு, அணுகுமுறை ForeignKey ஐப் போன்றது, ஆனால் தொடர்புடைய ஆப்ஜெக்ட் இல்லாத சந்தர்ப்பங்களைக் கையாள்வது முக்கியம்.

from django.contrib.auth.models import User

class UserProfile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE, related_name='profile')
    bio = models.TextField(blank=True)
    location = models.CharField(max_length=100, blank=True, default='Global') # சர்வதேச சூழலுக்காக இருப்பிடத்தைச் சேர்த்தது

    def __str__(self):
        return self.user.username

class UserProfileSerializer(serializers.ModelSerializer):
    class Meta:
        model = UserProfile
        fields = ['id', 'bio', 'location']

class UserSerializer(serializers.ModelSerializer):
    profile = UserProfileSerializer(read_only=True)

    class Meta:
        model = User
        fields = ['id', 'username', 'email', 'profile']

வெளியீடு பின்வருமாறு இருக்கும்:

{
    "id": 1,
    "username": "johndoe",
    "email": "john.doe@example.com",
    "profile": {
        "id": 1,
        "bio": "Software Engineer.",
        "location": "London, UK"
    }
}

எழுதுவதற்கான செயல்பாடுகளைக் கையாளுதல் (உருவாக்குதல் மற்றும் புதுப்பித்தல்)

மேலே உள்ள எடுத்துக்காட்டுகள் படிக்க மட்டும் கூடிய சீரியலைசேஷனில் முதன்மையாக கவனம் செலுத்துகின்றன. தொடர்புடைய ஆப்ஜெக்ட்களை உருவாக்க அல்லது புதுப்பிக்க அனுமதிக்கும் வகையில், உங்கள் சீரியலைசரில் உள்ள `create()` மற்றும் `update()` முறைகளை நீங்கள் மேலெழுத வேண்டும்.

நெஸ்டெட் ஆப்ஜெக்ட்களை உருவாக்குதல்

ஒரு புதிய புத்தகம் மற்றும் ஆசிரியரை ஒரே நேரத்தில் உருவாக்க விரும்புகிறீர்கள் என்று வைத்துக்கொள்வோம்.

class BookSerializer(serializers.ModelSerializer):
    author = AuthorSerializer()

    class Meta:
        model = Book
        fields = ['id', 'title', 'author', 'publication_date']

    def create(self, validated_data):
        author_data = validated_data.pop('author')
        author = Author.objects.create(**author_data)
        book = Book.objects.create(author=author, **validated_data)
        return book

`create()` முறையில், நாங்கள் ஆசிரியர் தரவைப் பிரித்தெடுத்து, ஒரு புதிய `Author` ஆப்ஜெக்ட்டை உருவாக்கி, பின்னர் புதிதாக உருவாக்கப்பட்ட ஆசிரியருடன் தொடர்புபடுத்தி, `Book` ஆப்ஜெக்ட்டை உருவாக்குகிறோம்.

முக்கியம்: `author_data` இல் உள்ள சாத்தியமான சரிபார்ப்பு பிழைகளைக் கையாள வேண்டும். நீங்கள் try-except தொகுதியைப் பயன்படுத்தலாம் மற்றும் ஆசிரியர் தரவு தவறானதாக இருந்தால் `serializers.ValidationError` ஐ உயர்த்தலாம்.

நெஸ்டெட் ஆப்ஜெக்ட்களை புதுப்பித்தல்

இதேபோல், ஒரு புத்தகம் மற்றும் அதன் ஆசிரியரை புதுப்பிக்க:

class BookSerializer(serializers.ModelSerializer):
    author = AuthorSerializer()

    class Meta:
        model = Book
        fields = ['id', 'title', 'author', 'publication_date']

    def update(self, instance, validated_data):
        author_data = validated_data.pop('author', None)

        if author_data:
            author = instance.author
            for attr, value in author_data.items():
                setattr(author, attr, value)
            author.save()

        for attr, value in validated_data.items():
            setattr(instance, attr, value)
        instance.save()

        return instance

`update()` முறையில், நாங்கள் இருக்கும் ஆசிரியரை மீட்டெடுத்து, வழங்கப்பட்ட தரவின் அடிப்படையில் அதன் பண்புகளைப் புதுப்பித்து, பின்னர் புத்தகத்தின் பண்புகளைப் புதுப்பிக்கிறோம். `author_data` வழங்கப்படாவிட்டால் (அதாவது ஆசிரியர் புதுப்பிக்கப்படவில்லை என்றால்), குறியீடு ஆசிரியர் புதுப்பிப்பு பகுதியைத் தவிர்க்கிறது. `validated_data.pop('author', None)` இல் உள்ள `None` இயல்புநிலை, புதுப்பிப்பு கோரிக்கையில் ஆசிரியர் தரவு சேர்க்கப்படாத சந்தர்ப்பங்களைக் கையாள முக்கியமானது.

`PrimaryKeyRelatedField` ஐப் பயன்படுத்துதல்

நெஸ்டெட் சீரியலைசர்களுக்குப் பதிலாக, தொடர்புடைய ஆப்ஜெக்ட்டின் முதன்மை விசையைப் பயன்படுத்தி உறவுகளைக் குறிக்க `PrimaryKeyRelatedField` ஐப் பயன்படுத்தலாம். தொடர்புடைய ஆப்ஜெக்ட்டின் ஐடியை மட்டும் நீங்கள் குறிப்பிட வேண்டும் மற்றும் முழு ஆப்ஜெக்டையும் சீரியலைஸ் செய்ய விரும்பவில்லை என்றால் இது பயனுள்ளதாக இருக்கும்.

class BookSerializer(serializers.ModelSerializer):
    author = serializers.PrimaryKeyRelatedField(queryset=Author.objects.all())

    class Meta:
        model = Book
        fields = ['id', 'title', 'author', 'publication_date']

இப்போது, `author` புலத்தில் ஆசிரியரின் ஐடி இருக்கும்:

{
    "id": 1,
    "title": "1984",
    "author": 3,  // ஆசிரியர் ஐடி
    "publication_date": "1949-06-08"
}

உருவாக்குவதற்கும் புதுப்பிப்பதற்கும், கோரிக்கை தரவில் ஆசிரியரின் ஐடியை அனுப்புவீர்கள். `queryset=Author.objects.all()` வழங்கப்பட்ட ஐடி டேட்டாபேஸில் இருப்பதை உறுதி செய்கிறது.

`HyperlinkedRelatedField` ஐப் பயன்படுத்துதல்

`HyperlinkedRelatedField` தொடர்புடைய ஆப்ஜெக்ட்டின் API எண்ட்பாயிண்ட்டிற்கான ஹைப்பர்லிங்க்களைப் பயன்படுத்தி உறவுகளைக் குறிக்கிறது. இது ஹைப்பர்மீடியா API-களில் (HATEOAS) பொதுவானது.

class BookSerializer(serializers.ModelSerializer):
    author = serializers.HyperlinkedRelatedField(view_name='author-detail', read_only=True)

    class Meta:
        model = Book
        fields = ['id', 'title', 'author', 'publication_date']

`view_name` ஆர்க்யுமெண்ட் தொடர்புடைய ஆப்ஜெக்டிற்கான கோரிக்கைகளைக் கையாளும் காட்சியின் பெயரை (எ.கா., `author-detail`) குறிப்பிடுகிறது. உங்கள் `urls.py` இல் இந்த காட்சிய வரையறுக்க வேண்டும்.

வெளியீடு ஆசிரியரின் விவர எண்ட்பாயிண்ட்டைச் சுட்டிக்காட்டும் URL ஐ உள்ளடக்கும்:

{
    "id": 1,
    "title": "Brave New World",
    "author": "http://example.com/api/authors/4/",
    "publication_date": "1932-01-01"
}

மேம்பட்ட நுட்பங்கள் மற்றும் பரிசீலனைகள்

• `depth` ஆப்சன்: `ModelSerializer` இல், ஒரு குறிப்பிட்ட ஆழம் வரை ForeignKey உறவுகளுக்கு தானாகவே நெஸ்டெட் சீரியலைசர்களை உருவாக்க `depth` ஆப்சனைப் பயன்படுத்தலாம். இருப்பினும், உறவுகள் சிக்கலானதாக இருந்தால் `depth` ஐப் பயன்படுத்துவது செயல்திறன் சிக்கல்களுக்கு வழிவகுக்கும், எனவே சீரியலைசர்களை வெளிப்படையாக வரையறுக்க பொதுவாகப் பரிந்துரைக்கப்படுகிறது.
• `SerializerMethodField`: தொடர்புடைய தரவுக்கான தனிப்பயன் சீரியலைசேஷன் தர்க்கத்தை உருவாக்க `SerializerMethodField` ஐப் பயன்படுத்தவும். தரவை ஒரு குறிப்பிட்ட வழியில் வடிவமைக்க அல்லது கணக்கிடப்பட்ட மதிப்புகளைச் சேர்க்க வேண்டும் என்றால் இது பயனுள்ளதாக இருக்கும். உதாரணமாக, லோகேலை அடிப்படையாகக் கொண்டு ஆசிரியரின் முழுப் பெயரை வெவ்வேறு வரிசையில் காட்டலாம். பல ஆசிய கலாச்சாரங்களுக்கு, குடும்பப் பெயர் கொடுக்கப்பட்ட பெயருக்கு முன்பு வருகிறது.
• தனிப்பயனாக்குதல் பிரதிநிதித்துவம்: தொடர்புடைய தரவு எவ்வாறு பிரதிநிதித்துவப்படுத்தப்படுகிறது என்பதைத் தனிப்பயனாக்க உங்கள் சீரியலைசரில் உள்ள `to_representation()` முறையை மேலெழுதவும்.
• செயல்திறன் மேம்படுத்தல்: சிக்கலான உறவுகள் மற்றும் பெரிய தரவுத்தொகுப்புகளுக்கு, டேட்டாபேஸ் வினவல்களை மேம்படுத்த மற்றும் டேட்டாபேஸ் ஹிட்களின் எண்ணிக்கையைக் குறைக்க select_related மற்றும் prefetch_related போன்ற நுட்பங்களைப் பயன்படுத்தவும். மெதுவான இணைப்புகளைக் கொண்ட உலகளாவிய பயனர்களுக்குச் சேவை செய்யும் API-களுக்கு இது மிகவும் முக்கியமானது.
• பூஜ்ஜிய மதிப்புகளைக் கையாளுதல்: உங்கள் சீரியலைசர்களில் பூஜ்ய மதிப்புகள் எவ்வாறு கையாளப்படுகின்றன என்பதில் கவனமாக இருங்கள், குறிப்பாக விருப்ப உறவுகளைக் கையாளும் போது. தேவைப்பட்டால் உங்கள் சீரியலைசர் புலங்களில் `allow_null=True` ஐப் பயன்படுத்தவும்.
• சரிபார்த்தல்: தரவு ஒருமைப்பாட்டை உறுதிப்படுத்த வலுவான சரிபார்ப்பை செயல்படுத்தவும், குறிப்பாக தொடர்புடைய ஆப்ஜெக்ட்களை உருவாக்கும் அல்லது புதுப்பிக்கும் போது. வணிக விதிகளுக்குட்பட்டு இருக்க தனிப்பயன் வேலிடேட்டர்களைப் பயன்படுத்தவும். உதாரணமாக, புத்தகத்தின் வெளியீட்டு தேதி எதிர்காலத்தில் இருக்கக்கூடாது.
• சர்வதேசமயமாக்கல் மற்றும் உள்மயமாக்கல் (i18n/l10n): உங்கள் தரவு வெவ்வேறு மொழிகள் மற்றும் பகுதிகளில் எவ்வாறு காட்டப்படும் என்பதைப் பரிசீலிக்கவும். பயனரின் லோகேலுக்கான தேதிகள், எண்கள் மற்றும் நாணயங்களைச் சரியாக வடிவமைக்கவும். உங்கள் மாதிரிகள் மற்றும் சீரியலைசர்களில் சர்வதேசமயமாக்கக்கூடிய சரங்களை சேமிக்கவும்.

சீரியலைசர் உறவுகளுக்கான சிறந்த நடைமுறைகள்

• சீரியலைசர்களை மையமாகக் கொள்ளுங்கள்: ஒவ்வொரு சீரியலைசரும் ஒரு குறிப்பிட்ட மாடல் அல்லது நெருக்கமாக தொடர்புடைய தரவுத் தொகுப்பை சீரியலைஸ் செய்வதற்குப் பொறுப்பாக இருக்க வேண்டும். அதிகப்படியான சிக்கலான சீரியலைசர்களை உருவாக்குவதைத் தவிர்க்கவும்.
• வெளிப்படையான சீரியலைசர்களைப் பயன்படுத்தவும்: `depth` ஆப்சனை அதிகமாக நம்புவதைத் தவிர்க்கவும். சீரியலைசேஷன் செயல்முறையின் மீது அதிகக் கட்டுப்பாடு வைத்திருக்க ஒவ்வொரு தொடர்புடைய மாடலுக்கும் வெளிப்படையான சீரியலைசர்களை வரையறுக்கவும்.
• சரியாகச் சோதிக்கவும்: உங்கள் சீரியலைசர்கள் தரவை சரியாக சீரியலைஸ் செய்து டீசீரியலைஸ் செய்கிறதா என்பதைச் சரிபார்க்க யூனிட் டெஸ்ட்களை எழுதுங்கள், குறிப்பாக சிக்கலான உறவுகளைக் கையாளும் போது.
• உங்கள் API ஐ ஆவணப்படுத்தவும்: உங்கள் API எண்ட்பாயிண்ட்களைத் தெளிவாக ஆவணப்படுத்தவும் மேலும் அவை எதிர்பார்க்கும் மற்றும் வழங்கும் தரவு வடிவங்களை ஆவணப்படுத்தவும். ஊடாடும் API ஆவணத்தை உருவாக்க Swagger அல்லது OpenAPI போன்ற கருவிகளைப் பயன்படுத்தவும்.
• API பதிப்பைக் கவனியுங்கள்: உங்கள் API வளர்ந்து வரும்போது, இருக்கும் கிளையண்ட்களுடன் இணக்கத்தன்மையை பராமரிக்க பதிப்பைப் பயன்படுத்தவும். பழைய பயன்பாடுகளை பாதிக்காமல் உடைக்கும் மாற்றங்களை அறிமுகப்படுத்த இது உங்களை அனுமதிக்கிறது.
• செயல்திறனைக் கண்காணிக்கவும்: உங்கள் API இன் செயல்திறனைக் கண்காணிக்கவும் மற்றும் சீரியலைசர் உறவுகள் தொடர்பான ஏதேனும் நெரிசல்களை அடையாளம் காணவும். டேட்டாபேஸ் வினவல்கள் மற்றும் சீரியலைசேஷன் தர்க்கத்தை மேம்படுத்த சுயவிவர கருவிகளைப் பயன்படுத்தவும்.

முடிவுரை

Django REST Framework இல் சீரியலைசர் உறவுகளில் தேர்ச்சி பெறுவது வலுவான மற்றும் திறமையான இணைய API-களை உருவாக்குவதற்கு அவசியம். பல்வேறு வகையான உறவுகள் மற்றும் DRF சீரியலைசர்களில் கிடைக்கும் பல்வேறு விருப்பங்களைப் புரிந்துகொள்வதன் மூலம், நெஸ்டெட் ஆப்ஜெக்ட்களை திறம்பட சீரியலைஸ் செய்து டீசீரியலைஸ் செய்யலாம், எழுதுவதற்கான செயல்பாடுகளைக் கையாளலாம் மற்றும் உங்கள் API ஐ செயல்திறனுக்காக மேம்படுத்தலாம். உலகளாவிய பார்வையாளர்களுக்கு அணுகக்கூடியதாக இருப்பதை உறுதிசெய்ய உங்கள் API ஐ வடிவமைக்கும்போது சர்வதேசமயமாக்கல் மற்றும் உள்மயமாக்கலைக் கருத்தில் கொள்ள நினைவில் கொள்ளுங்கள். முழுமையான சோதனை மற்றும் தெளிவான ஆவணப்படுத்தல் ஆகியவை உங்கள் API இன் நீண்டகால பராமரிப்பு மற்றும் பயன்பாட்டினை உறுதி செய்வதற்கான முக்கியமாகும்.