AutoField w modelach Django jest używane do przechowywania liczb całkowitych, które są automatycznie inkrementowane. To pole jest zazwyczaj używane jako klucz główny modelu, a jego wartości są generowane automatycznie podczas dodawania nowego rekordu do bazy danych.

Przykłady zastosowań AutoField:

AutoField może być używane do przechowywania unikalnych identyfikatorów dla obiektów w aplikacji.

from django.db import models
 
class MyModel(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=255)
    # inne pola modelu

AutoField może być stosowane do numerowania zamówień w sklepie internetowym, gdzie każde nowe zamówienie otrzymuje automatycznie kolejny numer.

from django.db import models
 
class Order(models.Model):
    order_number = models.AutoField(primary_key=True)
    total_amount = models.DecimalField(max_digits=10, decimal_places=2)
    # inne pola modelu

AutoField może być używane do przechowywania identyfikatorów użytkowników w systemie.

from django.db import models
 
class UserProfile(models.Model):
    user_id = models.AutoField(primary_key=True)
    username = models.CharField(max_length=255)
    # inne pola modelu

AutoField może być stosowane do numerowania kategorii w systemie bloga.

from django.db import models
 
class BlogCategory(models.Model):
    category_id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=255)
    # inne pola modelu

AutoField automatycznie inkrementuje wartości przy dodawaniu nowych rekordów do bazy danych. Wartości te są zazwyczaj generowane na poziomie bazy danych, co oznacza, że nie musisz ręcznie przypisywać wartości dla tego pola podczas tworzenia nowego rekordu. W przypadku wielu baz danych jest to implementowane jako autoinkrementacja, ale szczegóły mogą się różnić w zależności od używanej bazy danych.

BigAutoField w modelach Django jest używane do przechowywania liczb całkowitych, które są automatycznie inkrementowane, podobnie jak w przypadku AutoField. Różnica polega na tym, że BigAutoField jest przystosowane do obsługi większych zakresów wartości, co jest szczególnie przydatne w przypadku baz danych, które oferują większe typy danych całkowitych.

Przykłady zastosowań BigAutoField:

BigAutoField może być używane do przechowywania unikalnych identyfikatorów dla dużych obiektów w aplikacji.

from django.db import models
 
class LargeObject(models.Model):
    id = models.BigAutoField(primary_key=True)
    name = models.CharField(max_length=255)
    # inne pola modelu

BigAutoField może być stosowane do numerowania dużych zamówień w sklepie internetowym, gdzie zakłada się większe zakresy numeracji.

from django.db import models
 
class LargeOrder(models.Model):
    order_number = models.BigAutoField(primary_key=True)
    total_amount = models.DecimalField(max_digits=10, decimal_places=2)
    # inne pola modelu

BigAutoField może być używane do przechowywania identyfikatorów użytkowników w systemie, zwłaszcza gdy przewiduje się dużą ilość użytkowników.

from django.db import models
 
class LargeUserProfile(models.Model):
    user_id = models.BigAutoField(primary_key=True)
    username = models.CharField(max_length=255)
    # inne pola modelu

BigAutoField jest szczególnie przydatne, gdy oczekuje się, że ilość rekordów w danej tabeli może osiągnąć bardzo dużą wartość, przekraczającą zakresy standardowych całkowitych typów danych. Wartości te są zazwyczaj generowane automatycznie przy dodawaniu nowych rekordów, a typ BigAutoField jest dostosowany do obsługi większych wartości niż standardowy AutoField.

BigIntegerField w modelach Django jest używane do przechowywania liczb całkowitych o dużych zakresach. Jest to szczególnie przydatne, gdy standardowe typy całkowite (takie jak IntegerField czy SmallIntegerField) nie wystarczają, a jednocześnie nie potrzebujesz automatycznej inkrementacji, jak w przypadku pól AutoField lub BigAutoField.

Przykłady zastosowań BigIntegerField:

BigIntegerField może być używane do przechowywania liczby punktów doświadczenia postaci w grze, zwłaszcza gdy ta liczba może osiągnąć bardzo duże wartości.

from django.db import models
 
class Player(models.Model):
    name = models.CharField(max_length=255)
    experience_points = models.BigIntegerField()

BigIntegerField może być stosowane do przechowywania liczby ocen w systemie edukacyjnym, gdzie duża ilość uczniów może generować dużą ilość danych.

from django.db import models
 
class Course(models.Model):
    name = models.CharField(max_length=255)
    number_of_grades = models.BigIntegerField()

BigIntegerField może być używane do przechowywania liczby zamówień w aplikacji sklepu internetowego, zwłaszcza w przypadku dużych sklepów obsługujących dużą ilość transakcji.

from django.db import models
 
class Store(models.Model):
    name = models.CharField(max_length=255)
    order_count = models.BigIntegerField()

BigIntegerField jest przydatne w przypadkach, gdy spodziewasz się obsługi bardzo dużych wartości, które mogą przekroczyć zakresy standardowych całkowitych typów danych. Jeśli oczekujesz, że liczby w Twojej aplikacji będą rosły do bardzo dużych wartości, BigIntegerField jest odpowiednim wyborem.

BinaryField w modelach Django jest używane do przechowywania danych binarnych, takich jak pliki binarne, obrazy, dokumenty lub dowolne dane w formie binarnej. To pole jest przydatne, gdy potrzebujesz przechowywać surowe dane binarne, które nie mają struktury relacyjnej bazy danych, takiej jak pliki binarne.

Przykłady zastosowań BinaryField:

Możesz używać BinaryField, aby przechowywać pliki binarne, takie jak obrazy, dźwięki, filmy itp. To może być przydatne, jeśli chcesz przechowywać te pliki bezpośrednio w bazie danych, a nie na dysku.

from django.db import models
 
class Document(models.Model):
    name = models.CharField(max_length=255)
    file_content = models.BinaryField()

BinaryField może być używane do przechowywania surowych danych binarnych, na przykład w formie obiektu pickle.

import pickle
from django.db import models
 
class PickledObject(models.Model):
    data = models.BinaryField()
 
    def set_data(self, obj):
        self.data = pickle.dumps(obj)
 
    def get_data(self):
        return pickle.loads(self.data)

Możesz użyć BinaryField do przechowywania danych binarnych, takich jak strumienie bajtów.

from django.db import models
 
class BinaryStream(models.Model):
    binary_data = models.BinaryField()

Warto jednak zauważyć, że w niektórych przypadkach może być bardziej efektywne przechowywanie plików binarnych na dysku (a jedynie ścieżki do nich w bazie danych) zamiast bezpośrednio w bazie danych, szczególnie jeśli pliki są duże i wymagają efektywnego zarządzania przestrzenią dyskową. W takich przypadkach można skorzystać z FileField lub ImageField.

BooleanField w modelach Django jest używane do przechowywania wartości logicznych, czyli wartości prawda/fałsz (True/False) w bazie danych. To pole jest przydatne, gdy chcesz reprezentować dane, które mają tylko dwie możliwe wartości - prawda albo fałsz.

Przykłady zastosowań BooleanField:

Możesz używać BooleanField do reprezentowania stanów obiektów, które mogą być aktywowane lub dezaktywowane.

from django.db import models
 
class Task(models.Model):
    name = models.CharField(max_length=255)
    is_completed = models.BooleanField(default=False)

W przypadku systemów autoryzacji, BooleanField może reprezentować uprawnienia użytkowników, na przykład czy użytkownik ma dostęp do określonych funkcji czy nie.

from django.db import models
 
class UserProfile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    can_post_comments = models.BooleanField(default=True)
    can_edit_profile = models.BooleanField(default=False)

Możesz używać BooleanField do przechowywania informacji o zgodach użytkowników lub ich preferencjach.

from django.db import models
 
class UserPreferences(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    receive_newsletter = models.BooleanField(default=True)
    enable_notifications = models.BooleanField(default=False)

BooleanField jest również używane do filtrowania i sortowania danych w zapytaniach do bazy danych, na przykład do pobierania tylko aktywnych rekordów.

active_tasks = Task.objects.filter(is_completed=False)

Czasami BooleanField jest używane jako podstawowe pole dla pól wyboru, takich jak CheckboxInput w formularzach.

class TaskForm(forms.ModelForm):
    class Meta:
        model = Task
        fields = ['name', 'is_completed']
        widgets = {
            'is_completed': forms.CheckboxInput(),
        }

Warto zauważyć, że BooleanField w Django odpowiada typowi boolean w bazie danych (o ile jest obsługiwany przez daną bazę danych), co oznacza, że przechowuje ono wartości True lub False. W bazie danych wartości te mogą być reprezentowane jako 1 (dla True) lub 0 (dla False).

CharField w modelach Django jest używane do przechowywania tekstowych danych o zmiennej długości. To pole jest szeroko stosowane do reprezentowania krótkich i średnich ciągów znaków, takich jak imię, nazwisko, adres email, tytuł, itp. Jest elastyczne, ponieważ można zdefiniować maksymalną długość ciągu znaków, jaką może przechowywać.

Przykłady zastosowań CharField:

CharField jest często używane do przechowywania imion i nazwisk użytkowników.

from django.db import models
 
class UserProfile(models.Model):
    first_name = models.CharField(max_length=50)
    last_name = models.CharField(max_length=50)

CharField może reprezentować pole przechowujące adresy email.

from django.db import models
 
class User(models.Model):
    email = models.CharField(max_length=100)

CharField może być używane do przechowywania tytułów postów na blogu lub nazw autorów.

from django.db import models
 
class BlogPost(models.Model):
    title = models.CharField(max_length=200)
    author = models.CharField(max_length=100)

CharField może reprezentować pole przechowujące krótki opis produktu w katalogu sklepu internetowego.

from django.db import models
 
class Product(models.Model):
    name = models.CharField(max_length=100)
    description = models.CharField(max_length=500)

CharField może być używane do przechowywania kodów pocztowych.

from django.db import models
 
class Address(models.Model):
    street = models.CharField(max_length=200)
    postal_code = models.CharField(max_length=10)

Warto zaznaczyć, że CharField ma ograniczenie długości ciągu znaków, które można zdefiniować za pomocą argumentu max_length. Długość ta musi być dostosowana do rodzaju danych, jakie chcesz przechowywać. W przypadku dłuższych ciągów znaków, takich jak artykuły, komentarze czy treści stron, można rozważyć użycie TextField, które nie ma takiego ograniczenia długości.

DateField w modelach Django jest używane do przechowywania daty. To pole jest przydatne, gdy chcesz reprezentować informacje o dacie w strukturze modelu. DateField przechowuje daty w formie obiektu datetime.date.

Przykłady zastosowań DateField:

DateField może być używane do przechowywania daty urodzenia użytkowników.

from django.db import models
 
class UserProfile(models.Model):
    birth_date = models.DateField()

W przypadku serwisów subskrypcyjnych można użyć DateField do przechowywania daty, kiedy subskrypcja wygasa.

from django.db import models
 
class Subscription(models.Model):
    expiration_date = models.DateField()

W przypadku modelu reprezentującego artykuły na blogu, DateField może przechowywać datę wydania artykułu.

from django.db import models
 
class BlogPost(models.Model):
    title = models.CharField(max_length=200)
    publication_date = models.DateField()

W przypadku modelu reprezentującego projekty, DateField może przechowywać datę rozpoczęcia projektu.

from django.db import models
 
class Project(models.Model):
    name = models.CharField(max_length=100)
    start_date = models.DateField()

DateField może być używane w modelu reprezentującym produkty do przechowywania daty zakupu.

from django.db import models
 
class Product(models.Model):
    name = models.CharField(max_length=100)
    purchase_date = models.DateField()

Warto zauważyć, że DateField przechowuje daty w formie YYYY-MM-DD, co jest formatem zgodnym z normą ISO 8601. Jeśli potrzebujesz również przechowywać informacje o czasie, można rozważyć użycie DateTimeField, który obejmuje datę i czas.

DateTimeField w modelach Django jest używane do przechowywania daty i czasu. To pole reprezentuje kombinację daty i czasu w jednym obiekcie datetime. Jest przydatne, gdy chcesz śledzić informacje zarówno o dacie, jak i czasie w strukturze modelu.

Przykłady zastosowań DateTimeField:

DateTimeField może być używane do reprezentowania daty i czasu utworzenia obiektu w bazie danych.

from django.db import models
 
class MyModel(models.Model):
    created_at = models.DateTimeField(auto_now_add=True)

DateTimeField może być używane do śledzenia daty i czasu ostatniej modyfikacji obiektu.

from django.db import models
 
class MyModel(models.Model):
    updated_at = models.DateTimeField(auto_now=True)

W przypadku modelu reprezentującego artykuły na blogu, DateTimeField może przechowywać datę i czas wydania artykułu.

from django.db import models
 
class BlogPost(models.Model):
    title = models.CharField(max_length=200)
    publication_datetime = models.DateTimeField()

W przypadku modelu reprezentującego zadania do wykonania, DateTimeField może przechowywać datę i czas rozpoczęcia zadania.

from django.db import models
 
class Task(models.Model):
    name = models.CharField(max_length=100)
    start_datetime = models.DateTimeField()

DateTimeField może być używane do reprezentowania daty i czasu zalogowania użytkownika.

from django.db import models
 
class UserLogin(models.Model):
    user = models.ForeignKey(User, on_delete=models.CASCADE)
    login_datetime = models.DateTimeField()

DateTimeField przechowuje daty i czasy w formie obiektów datetime.datetime. Warto zauważyć, że jeśli potrzebujesz jedynie informacji o dacie (bez czasu), możesz użyć DateField.

DecimalField w modelach Django jest używane do przechowywania liczb zmiennoprzecinkowych o stałej precyzji. Jest to szczególnie przydatne, gdy potrzebujesz precyzyjnych obliczeń finansowych lub innych, gdzie dokładność jest ważna. Pole to przechowuje liczby jako obiekty Decimal z modułu decimal w Pythonie.

Przykłady zastosowań DecimalField:

DecimalField może być używane do przechowywania kwot transakcji finansowych, gdzie wymagana jest dokładność do określonej liczby miejsc po przecinku.

from django.db import models
 
class FinancialTransaction(models.Model):
    amount = models.DecimalField(max_digits=10, decimal_places=2)

W przypadku modelu reprezentującego produkty w sklepie internetowym, DecimalField może przechowywać ceny z dokładnością do dwóch miejsc po przecinku.

from django.db import models
 
class Product(models.Model):
    name = models.CharField(max_length=100)
    price = models.DecimalField(max_digits=8, decimal_places=2)

DecimalField może być używane do przechowywania procentów rabatu, na przykład przy tworzeniu systemu promocyjnego.

from django.db import models
 
class Discount(models.Model):
    percentage = models.DecimalField(max_digits=5, decimal_places=2)

W przypadku modelu reprezentującego dane finansowe, DecimalField może przechowywać wartość akcji z wymaganą precyzją.

from django.db import models
 
class Stock(models.Model):
    symbol = models.CharField(max_length=10)
    price_per_share = models.DecimalField(max_digits=10, decimal_places=2)

DecimalField może być używane do przechowywania wag produktów z dokładnością do kilogramów lub gramów.

from django.db import models
 
class GroceryProduct(models.Model):
    name = models.CharField(max_length=100)
    weight = models.DecimalField(max_digits=6, decimal_places=3)

max_digits określa maksymalną liczbę cyfr przed i po przecinku, a decimal_places określa liczbę cyfr po przecinku. Dzięki temu możesz dostosować dokładność zgodnie z wymaganiami danej aplikacji.

DurationField w modelach Django jest używane do przechowywania okresu czasu, czyli ilości czasu trwania, w formie obiektu datetime.timedelta. To pole jest przydatne, gdy chcesz reprezentować różnice czasu lub długość trwania pewnych zdarzeń, na przykład czas trwania konkretnej akcji w systemie.

Przykłady zastosowań DurationField:

DurationField może być używane do przechowywania czasu trwania spotkania lub wydarzenia.

from django.db import models
 
class Meeting(models.Model):
    title = models.CharField(max_length=100)
    duration = models.DurationField()

W przypadku modelu reprezentującego zadania, DurationField może przechowywać planowany czas trwania zadania.

from django.db import models
 
class Task(models.Model):
    name = models.CharField(max_length=100)
    estimated_duration = models.DurationField()

DurationField może być używane do przechowywania czasu trwania podróży lub przejazdu.

from django.db import models
 
class Trip(models.Model):
    destination = models.CharField(max_length=100)
    travel_duration = models.DurationField()

W przypadku modelu reprezentującego filmy, DurationField może przechowywać czas trwania filmu.

from django.db import models
 
class Movie(models.Model):
    title = models.CharField(max_length=100)
    duration = models.DurationField()

DurationField może być używane w różnych kontekstach, gdzie potrzebujesz reprezentować ilość czasu trwania pewnych procesów, operacji lub zdarzeń.

from django.db import models
 
class Process(models.Model):
    name = models.CharField(max_length=100)
    execution_time = models.DurationField()

DurationField pozwala na precyzyjne przechowywanie czasu trwania, takiego jak datetime.timedelta(seconds=…), co jest przydatne w wielu kontekstach, szczególnie w aplikacjach, gdzie dokładność czasu trwania jest ważna.

EmailField w modelach Django jest używane do przechowywania adresów e-mail. Jest to specjalne pole, które sprawdza, czy przekazany ciąg znaków jest poprawnym adresem e-mail zgodnym z formatem RFC 5322.

Przykłady zastosowań EmailField:

EmailField może być używane w modelu reprezentującym użytkowników, aby przechowywać ich adresy e-mail.

from django.db import models
 
class User(models.Model):
    username = models.CharField(max_length=50)
    email = models.EmailField(unique=True)
    # inne pola...

W przypadku systemu CRM (Customer Relationship Management), EmailField może reprezentować adres e-mail klienta lub partnera biznesowego.

from django.db import models
 
class Contact(models.Model):
    name = models.CharField(max_length=100)
    email = models.EmailField()
    # inne pola...

EmailField może być używane do przechowywania adresów e-mail osób subskrybujących newsletter.

from django.db import models
 
class NewsletterSubscription(models.Model):
    email = models.EmailField(unique=True)
    # inne pola...

W przypadku modelu reprezentującego komentarze na blogu, EmailField może przechowywać adresy e-mail autorów komentarzy.

from django.db import models
 
class BlogComment(models.Model):
    author_name = models.CharField(max_length=100)
    author_email = models.EmailField()
    # inne pola...

EmailField samodzielnie wykonuje sprawdzenie, czy podany adres e-mail jest zgodny z formatem RFC 5322, co pomaga w utrzymaniu poprawności danych w bazie danych. Jeśli próba zapisu adresu e-mail o nieprawidłowym formacie zostanie podjęta, zostanie zgłoszony błąd.

FileField w modelach Django jest używane do przechowywania ścieżki do pliku na dysku. To pole pozwala na zapisywanie i pobieranie plików w relacyjnej bazie danych wraz z informacjami o lokalizacji pliku na dysku serwera.

Przykłady zastosowań FileField:

FileField może być używane do przechowywania ścieżki do pliku obrazu profilowego użytkownika.

from django.db import models
 
class UserProfile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    profile_picture = models.FileField(upload_to='profile_pics/')

W przypadku modelu reprezentującego wiadomości e-mail, FileField może przechowywać ścieżki do załączników.

from django.db import models
 
class EmailAttachment(models.Model):
    email = models.ForeignKey(Email, on_delete=models.CASCADE)
    file = models.FileField(upload_to='email_attachments/')

FileField może być używane do przechowywania ścieżek do plików w systemie zarządzania dokumentami.

from django.db import models
 
class Document(models.Model):
    title = models.CharField(max_length=100)
    file_path = models.FileField(upload_to='documents/')

W przypadku modelu reprezentującego utwory muzyczne, FileField może przechowywać ścieżki do plików dźwiękowych.

from django.db import models
 
class MusicTrack(models.Model):
    title = models.CharField(max_length=100)
    audio_file = models.FileField(upload_to='music_tracks/')

FileField może być używane do przechowywania ścieżek do plików konfiguracyjnych lub plików tekstowych.

from django.db import models
 
class ConfigurationFile(models.Model):
    name = models.CharField(max_length=100)
    file_path = models.FileField(upload_to='config_files/')

Warto zauważyć, że upload_to wskazuje na podkatalog, w którym mają być przechowywane pliki. Możesz dostosować to pole w zależności od struktury katalogów, jakiej oczekujesz. W praktyce, pliki są zazwyczaj przechowywane na dysku serwera, a baza danych przechowuje jedynie ścieżki do tych plików.

FilePathField w modelach Django jest używane do przechowywania ścieżki do pliku na dysku. To pole jest podobne do CharField z tym, że dostarcza automatycznego wybierania pliku w formie listy dostępnych plików na danym systemie plików. Jest używane, gdy chcesz, aby użytkownik mógł wybierać plik z określonego zestawu plików w określonym katalogu.

Przykłady zastosowań FilePathField:

FilePathField może być używane, aby pozwolić użytkownikowi wybierać spośród dostępnych szablonów w systemie zarządzania treścią.

from django.db import models
 
class Content(models.Model):
    title = models.CharField(max_length=100)
    template_path = models.FilePathField(path='/path/to/templates/')

W tym przykładzie, path wskazuje na katalog, z którego będą pobierane dostępne pliki. Użytkownik będzie mógł wybrać jedną z dostępnych ścieżek plików.

FilePathField może być używane do wyboru pliku konfiguracyjnego z określonego katalogu.

from django.db import models
 
class Configuration(models.Model):
    name = models.CharField(max_length=100)
    config_file_path = models.FilePathField(path='/path/to/config/files/')

W przypadku modelu reprezentującego zasoby, FilePathField może umożliwić użytkownikowi wybór pliku z określonego katalogu.

from django.db import models
 
class WebResource(models.Model):
    name = models.CharField(max_length=100)
    resource_path = models.FilePathField(path='/path/to/web/resources/')

Warto zauważyć, że FilePathField nie przechowuje samego pliku, ale jedynie ścieżkę do niego. Działa ono jako pole wyboru z dostępnymi ścieżkami wskazanymi w określonym katalogu. Jeśli chcesz przechowywać sam plik, użyj FileField.

FloatField w modelach Django jest używane do przechowywania liczb zmiennoprzecinkowych, czyli liczb rzeczywistych, które mogą mieć wartości dziesiętne lub ułamki. To pole jest przydatne, gdy chcesz przechowywać numeryczne dane zmiennoprzecinkowe, takie jak ceny, współczynniki, oceny itp. Wartości te są przechowywane w formie zmiennoprzecinkowej z podwójną precyzją.

Przykłady zastosowań FloatField: ==== Przechowywanie Cen i Kwot Finansowych ====

Możesz użyć FloatField, aby przechowywać ceny produktów, kwoty transakcji finansowych itp.

from django.db import models
 
class Product(models.Model):
    name = models.CharField(max_length=255)
    price = models.FloatField()

FloatField może być używane do przechowywania różnych współczynników, takich jak współczynniki matematyczne, procenty itp.

from django.db import models
 
class Coefficient(models.Model):
    name = models.CharField(max_length=255)
    value = models.FloatField()

FloatField może być stosowane do przechowywania ocen lub wyników numerycznych zmiennoprzecinkowych.

from django.db import models
 
class ExamResult(models.Model):
    student_name = models.CharField(max_length=255)
    score = models.FloatField()

Warto zauważyć, że przy pracy z pieniędzmi często zaleca się używanie DecimalField zamiast FloatField, ponieważ DecimalField jest bardziej odpowiednie do precyzyjnych operacji finansowych, gdzie wymagane jest dokładne zaokrąglanie. Jednak w przypadku ogólnych liczb zmiennoprzecinkowych FloatField jest powszechnie stosowane.

GenericIPAddressField w modelach Django jest używane do przechowywania adresów IP, ale jest „uniwersalne” (generyczne) w tym sensie, że pozwala na przechowywanie zarówno adresów IPv4, jak i IPv6. Jest to przydatne pole, gdy chcesz przechowywać informacje o adresie IP, a nie decydujesz się na konkretne ograniczenie typu adresu.

Przykłady zastosowań GenericIPAddressField:

Możesz użyć GenericIPAddressField do przechowywania adresów IP klientów, użytkowników lub innych podmiotów w kontekście aplikacji webowej.

from django.db import models
 
class User(models.Model):
    username = models.CharField(max_length=255)
    ip_address = models.GenericIPAddressField()

W przypadku systemów monitoringu lub rejestracji działań, GenericIPAddressField może być używane do przechowywania adresów IP serwerów, z których pochodzą żądania.

from django.db import models
 
class ServerLog(models.Model):
    timestamp = models.DateTimeField()
    server_ip = models.GenericIPAddressField()
    action_description = models.TextField()

GenericIPAddressField może być stosowane do przechowywania adresów IP związanych z logami dostępu lub bezpieczeństwa.

from django.db import models
 
class AccessLog(models.Model):
    timestamp = models.DateTimeField()
    user_ip = models.GenericIPAddressField()
    access_path = models.CharField(max_length=255)
    status_code = models.IntegerField()

Warto zauważyć, że GenericIPAddressField umożliwia specyfikację opcji, takich jak protocol (domyślnie both obsługujący zarówno IPv4, jak i IPv6) oraz unpack_ipv4 (określający, czy adresy IPv4 mają być rozwijane). Domyślnie, GenericIPAddressField nie sprawdza, czy podany adres IP jest rzeczywiście ważnym adresem IP; to sprawdzenie musi być zaimplementowane w warstwie aplikacji, jeśli jest to wymagane.

ImageField w modelach Django jest używane do przechowywania obrazów. To pole umożliwia łatwe zarządzanie i przechowywanie plików graficznych, takich jak zdjęcia, ikony, awatary itp., w bazie danych lub systemie plików.

Przykłady zastosowań ImageField:

Możesz użyć ImageField, aby przechowywać zdjęcia profilowe użytkowników w systemie społecznościowym.

from django.db import models
 
class UserProfile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    profile_picture = models.ImageField(upload_to='profile_pics/')

ImageField może być stosowane do przechowywania zdjęć produktów w sklepie internetowym.

from django.db import models
 
class Product(models.Model):
    name = models.CharField(max_length=255)
    image = models.ImageField(upload_to='product_images/')

ImageField może być używane do przechowywania obrazów, które towarzyszą wpisom w blogu.

from django.db import models
 
class BlogPost(models.Model):
    title = models.CharField(max_length=255)
    content = models.TextField()
    image = models.ImageField(upload_to='blog_images/')

ImageField pozwala na tworzenie galerii zdjęć, przechowując obrazy związane z danymi rekordami.

from django.db import models
 
class PhotoGallery(models.Model):
    title = models.CharField(max_length=255)
    image = models.ImageField(upload_to='gallery_images/')

Ważną opcją dla ImageField jest argument upload_to, który określa podkatalog, do którego będą zapisywane przesłane pliki. Umożliwia to łatwe zarządzanie strukturą katalogów i organizowanie przechowywanych obrazów.

image = models.ImageField(upload_to='profile_pics/')

Warto pamiętać, że przechowywanie obrazów w bazie danych może prowadzić do zwiększenia rozmiaru bazy danych. W niektórych przypadkach, zwłaszcza gdy obrazy są duże i liczne, rozważenie przechowywania obrazów na dysku z odnośnikiem do nich w bazie danych FileField może być bardziej efektywne.

IntegerField w modelach Django jest używane do przechowywania liczb całkowitych. To pole jest przydatne, gdy chcesz przechowywać wartości liczbowe bez części dziesiętnej, takie jak liczba całkowita, liczba identyfikacyjna, liczba produktów w magazynie itp.

Przykłady zastosowań IntegerField:

Możesz użyć IntegerField, aby przechowywać ilość dostępnych produktów w sklepie internetowym.

from django.db import models
 
class Product(models.Model):
    name = models.CharField(max_length=255)
    quantity_available = models.IntegerField()

IntegerField może być stosowane do przechowywania identyfikatora kategorii w modelu bloga.

from django.db import models
 
class BlogCategory(models.Model):
    name = models.CharField(max_length=255)
    category_id = models.IntegerField(unique=True)

IntegerField może być używane do przechowywania liczby ocen danego użytkownika w systemie ocen społecznościowych.

from django.db import models
 
class UserRatings(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    ratings_count = models.IntegerField(default=0)

IntegerField może być stosowane do przechowywania wieku użytkowników w systemie.

from django.db import models
 
class UserProfile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    age = models.IntegerField(null=True, blank=True)

Warto zauważyć, że IntegerField przyjmuje argumenty, takie jak default, null i blank, które pozwalają na określenie wartości domyślnej, czy pole może przyjmować wartość NULL w bazie danych, oraz czy pole może być puste w formularzach Django.

quantity_available = models.IntegerField(default=0)

To ułatwia kontrolowanie i zarządzanie wartościami liczbowymi w modelach Django.

JSONField w modelach Django jest używane do przechowywania danych w formacie JSON. To pole pozwala na elastyczne przechowywanie struktur danych w postaci JSON, co jest przydatne w przypadku, gdy potrzebujesz przechowywać niestandardowe dane, które nie pasują do tradycyjnej relacyjnej struktury bazy danych.

Przykłady zastosowań JSONField:

Możesz użyć JSONField, aby przechowywać niestandardowe ustawienia konfiguracyjne dla aplikacji.

from django.db import models
 
class AppConfig(models.Model):
    app_name = models.CharField(max_length=255)
    config_data = models.JSONField()

JSONField może być stosowane do przechowywania dodatkowych informacji o produkcie w elastycznej formie.

from django.db import models
 
class Product(models.Model):
    name = models.CharField(max_length=255)
    additional_info = models.JSONField()

Możesz użyć JSONField, aby przechowywać niestandardowe dane o zamówieniach, takie jak szczegóły dostawy, dodatkowe informacje itp.

from django.db import models
 
class Order(models.Model):
    order_number = models.CharField(max_length=255)
    order_details = models.JSONField()

JSONField może być używane do przechowywania niestandardowych metadanych lub dodatkowych informacji w modelu wpisu blogowego.

from django.db import models
 
class BlogPost(models.Model):
    title = models.CharField(max_length=255)
    content = models.TextField()
    metadata = models.JSONField()

JSONField umożliwia zapisywanie różnorodnych struktur danych, takich jak listy, obiekty, liczby, ciągi znaków, a nawet zagnieżdżone obiekty JSON. Jest to przydatne, gdy konkretna struktura danych może się zmieniać w czasie lub gdy potrzebujesz przechowywać dane o niestandardowej strukturze bez konieczności tworzenia dodatkowych tabel w bazie danych. Warto jednak pamiętać, że JSONField może ograniczać możliwość wykonywania bardziej zaawansowanych operacji bazodanowych na przechowywanych danych w porównaniu do tradycyjnych pól.

PositiveBigIntegerField w modelach Django jest używane do przechowywania liczb całkowitych większych niż 0 (dodatnich) i o dużej wartości, które są zaklasyfikowane jako bigint. To pole jest przydatne, gdy potrzebujesz przechowywać bardzo duże wartości liczbowe, a jednocześnie chcesz zapewnić, że będą to liczby dodatnie.

Przykłady zastosowań PositiveBigIntegerField:

Możesz użyć PositiveBigIntegerField, aby przechowywać unikalne identyfikatory transakcji lub numerację zleceń.

from django.db import models
 
class Transaction(models.Model):
    transaction_id = models.PositiveBigIntegerField(unique=True)
    amount = models.DecimalField(max_digits=10, decimal_places=2)

PositiveBigIntegerField może być stosowane do numerowania dużej ilości obiektów w systemie, gdzie standardowe pola IntegerField mogą być zbyt małe.

from django.db import models
 
class LargeNumberedObject(models.Model):
    object_number = models.PositiveBigIntegerField(unique=True)
    object_data = models.TextField()

W przypadku aplikacji matematycznych, gdzie przechowujesz duże wartości liczbowe, PositiveBigIntegerField może być używane do przechowywania wyników obliczeń.

from django.db import models
 
class MathematicalResult(models.Model):
    result_value = models.PositiveBigIntegerField()
    calculation_description = models.CharField(max_length=255)

PositiveBigIntegerField zapewnia, że przechowywane liczby są dodatnie, co może być ważne w kontekście wielu zastosowań. Jest to szczególnie przydatne, gdy pracujesz z unikalnymi identyfikatorami lub numeracją, gdzie wartości ujemne nie mają sensu.

Warto zauważyć, że PositiveBigIntegerField jest dostępne od Django w wersji 3.1, więc jeśli korzystasz z wcześniejszych wersji, ta opcja może nie być dostępna.

PositiveIntegerField w modelach Django jest używane do przechowywania liczb całkowitych większych niż 0 (dodatnich). To pole jest przydatne, gdy chcesz przechowywać jedynie wartości dodatnie i uniknąć zapisywania wartości ujemnych w danym polu.

Przykłady zastosowań PositiveIntegerField:

Możesz użyć PositiveIntegerField, aby przechowywać wiek użytkownika w systemie. Wiek jest zawsze wartością nieujemną.

from django.db import models
 
class UserProfile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    age = models.PositiveIntegerField()

PositiveIntegerField może być stosowane do przechowywania liczby „lubię to” pod danym wpisem w systemie społecznościowym. Liczba „lubię to” musi być nieujemna.

from django.db import models
 
class Post(models.Model):
    content = models.TextField()
    likes_count = models.PositiveIntegerField(default=0)

PositiveIntegerField może być używane do numerowania obiektów w określonej kolejności, gdzie numeracja zaczyna się od 1.

from django.db import models
 
class OrderedObject(models.Model):
    order_number = models.PositiveIntegerField()
    object_data = models.TextField()

W przypadku aplikacji matematycznych, gdzie przechowujesz wartości liczbowe, PositiveIntegerField może być używane do przechowywania wartości, które są zawsze nieujemne.

from django.db import models
 
class MathematicalValue(models.Model):
    value = models.PositiveIntegerField()
    description = models.CharField(max_length=255)

PositiveIntegerField zapewnia, że przechowywane liczby są dodatnie, co może być istotne w wielu kontekstach biznesowych. Jest to szczególnie użyteczne, gdy chcesz zapewnić, że w danym polu są przechowywane tylko wartości nieujemne.

PositiveIntegerField w Django jest używane do przechowywania liczb całkowitych większych lub równych zeru. Zakres wartości tego pola obejmuje wszystkie liczby całkowite od zera w górę. Zakres ten wynika z samej nazwy - jest to pole przeznaczone dla wartości dodatnich lub zerowych.

Wartości, które można przechowywać w PositiveIntegerField, zależą od używanej bazy danych i implementacji wewnętrznej, ale teoretycznie zakres obejmuje wszystkie liczby całkowite większe lub równe zeru, które mieszczą się w zakresie dostępnego typu danych liczbowych w danej bazie danych.

Przykładowo, w PostgreSQL PositiveIntegerField może być mapowane na typ integer lub bigint w zależności od wymagań zakresu. W MySQL może być mapowane na UNSIGNED INTEGER lub UNSIGNED BIGINT.

Wartości teoretyczne dla PositiveIntegerField w zależności od implementacji mogą wynosić od 0 do 2^31-1 (dla integer w PostgreSQL) lub 0 do 2^63-1 (dla bigint w PostgreSQL). W przypadku UNSIGNED INTEGER w MySQL zakres wynosi od 0 do 2^32-1, a dla UNSIGNED BIGINT od 0 do 2^64-1.

Pamiętaj, że konkretny zakres wartości w danym przypadku zależy od specyfiki bazy danych, a Django sam w sobie dostarcza abstrakcję, która powinna działać na różnych bazach danych. Jeśli zakres wartości ma kluczowe znaczenie w twoim projekcie, zalecam sprawdzenie dokumentacji konkretnej bazy danych, z którą pracujesz.

PositiveSmallIntegerField w modelach Django jest używane do przechowywania liczb całkowitych dodatnich, przy czym ogranicza zakres wartości do stosunkowo niewielkich liczb. Jest to pole o stałej długości, co oznacza, że przechowuje liczby całkowite 16-bitowe.

Przykłady zastosowań PositiveSmallIntegerField:

Możesz użyć PositiveSmallIntegerField, aby przechowywać numer kategorii w systemie bloga, jeśli zakładasz, że ilość kategorii będzie ograniczona.

from django.db import models
 
class BlogCategory(models.Model):
    name = models.CharField(max_length=255)
    category_number = models.PositiveSmallIntegerField(unique=True)

PositiveSmallIntegerField może być używane do przechowywania ocen wpisów w systemie ocen społecznościowych, gdzie oceny są ograniczone do niewielkiego zakresu.

from django.db import models
 
class UserRatings(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    rating = models.PositiveSmallIntegerField()

Numerowanie Kolejnych Obiektów PositiveSmallIntegerField może być stosowane do numerowania obiektów, gdzie oczekujesz, że liczba obiektów będzie stosunkowo niewielka.

from django.db import models
 
class SmallNumberedObject(models.Model):
    object_number = models.PositiveSmallIntegerField(unique=True)
    object_data = models.TextField()

PositiveSmallIntegerField może być używane do przechowywania numerów kierunków w systemie, gdzie ilość kierunków jest ograniczona.

from django.db import models
 
class Direction(models.Model):
    name = models.CharField(max_length=255)
    direction_number = models.PositiveSmallIntegerField(unique=True)

Warto zauważyć, że PositiveSmallIntegerField ma ograniczony zakres wartości, który wynika z ograniczenia na 16-bitowe liczby całkowite. W PostgreSQL jest to zazwyczaj od 0 do 32767, a w MySQL od 0 do 65535. Jeśli potrzebujesz przechowywać większe wartości, zalecane jest użycie PositiveIntegerField.

SlugField w modelach Django jest używane do przechowywania tzw. slugów, czyli przyjaznych dla ludzi, czytelnych części adresów URL. Jest to często stosowane pole do tworzenia linków do obiektów modelu w witrynie internetowej, ponieważ zawiera tylko znaki alfanumeryczne, myślniki i podkreślenia, a także jest zazwyczaj w formie łacińskiej, bez znaków diakrytycznych.

Przykłady zastosowań SlugField:

Możesz użyć SlugField, aby tworzyć przyjazne URL-e dla artykułów w blogu, zawierające tytuły artykułów zamiast identyfikatorów.

from django.db import models
from django.utils.text import slugify
 
class BlogPost(models.Model):
    title = models.CharField(max_length=255)
    slug = models.SlugField(unique=True)
 
    def save(self, *args, **kwargs):
        self.slug = slugify(self.title)
        super().save(*args, **kwargs)

SlugField może być stosowane do tworzenia przyjaznych URL-i dla kategorii w systemie, gdzie nazwy kategorii są często używane w adresie URL.

from django.db import models
from django.utils.text import slugify
 
class Category(models.Model):
    name = models.CharField(max_length=255)
    slug = models.SlugField(unique=True)
 
    def save(self, *args, **kwargs):
        self.slug = slugify(self.name)
        super().save(*args, **kwargs)

SlugField może być używane do tworzenia przyjaznych URL-i dla profili użytkowników, gdzie użytkownicy mogą mieć niestandardowe nazwy.

from django.db import models
from django.contrib.auth.models import User
from django.utils.text import slugify
 
class UserProfile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    display_name = models.CharField(max_length=255)
    slug = models.SlugField(unique=True)
 
    def save(self, *args, **kwargs):
        self.slug = slugify(self.display_name)
        super().save(*args, **kwargs)

SlugField automatycznie tworzy unikalne slugi na podstawie określonych pól, ale możesz również zdefiniować niestandardową logikę generowania sluga, jak w powyższych przykładach, korzystając z funkcji slugify dostępnej w Django. Warto jednak pamiętać, że należy zadbać o unikalność slugów, zwłaszcza gdy są używane jako klucz główny lub mają być unikalne w obrębie danego modelu.

SmallIntegerField w modelach Django jest używane do przechowywania liczb całkowitych o stosunkowo niewielkich wartościach. To pole ma stałą długość, co oznacza, że przechowuje liczby całkowite 16-bitowe.

Przykłady zastosowań SmallIntegerField:

SmallIntegerField może być używane do przechowywania wieku, szczególnie gdy zakładasz, że użytkownicy nie będą miały bardzo dużego wieku.

from django.db import models
 
class UserProfile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    age = models.SmallIntegerField()

SmallIntegerField może być stosowane do przechowywania liczby komentarzy pod wpisem w systemie blogowym, jeśli zakładasz, że ta liczba nie będzie bardzo duża.

from django.db import models
 
class BlogPost(models.Model):
    title = models.CharField(max_length=255)
    comments_count = models.SmallIntegerField(default=0)

SmallIntegerField może być używane do numerowania kategorii, szczególnie jeśli zakładasz, że ilość kategorii w systemie będzie stosunkowo niewielka.

from django.db import models
 
class BlogCategory(models.Model):
    name = models.CharField(max_length=255)
    category_number = models.SmallIntegerField(unique=True)

SmallIntegerField może być stosowane do przechowywania ocen w systemie społecznościowym, gdzie zakładasz, że oceny mieszczą się w ograniczonym zakresie.

from django.db import models
 
class UserRating(models.Model):
    user = models.ForeignKey(User, on_delete=models.CASCADE)
    rating = models.SmallIntegerField()

SmallIntegerField jest przydatne, gdy chcesz zminimalizować używane miejsce w bazie danych, szczególnie gdy przechowujesz wartości liczbowe, które są z góry ograniczone pod względem zakresu. Pamiętaj jednak, że jest to 16-bitowe pole, co oznacza, że zakres wartości jest ograniczony, zazwyczaj do -32768 do 32767 (lub 0 do 65535, jeśli używane jest PositiveSmallIntegerField). Jeśli zakładasz większy zakres wartości, zaleca się użycie IntegerField.

TextField w modelach Django jest używane do przechowywania długich ciągów znaków, takich jak długie opisy, treści artykułów, komentarze czy inne dane tekstowe o znacznym rozmiarze. W przeciwieństwie do pól CharField, TextField nie ma ograniczenia na długość przechowywanej wartości (lub to ograniczenie jest bardzo wysokie), co sprawia, że jest odpowiednie do przechowywania większych ilości tekstu.

Przykłady zastosowań TextField:

TextField może być używane do przechowywania treści artykułów w systemie blogowym.

from django.db import models
 
class BlogPost(models.Model):
    title = models.CharField(max_length=255)
    content = models.TextField()

TextField może być stosowane do przechowywania długich opisów produktów w sklepie internetowym.

from django.db import models
 
class Product(models.Model):
    name = models.CharField(max_length=255)
    description = models.TextField()

TextField jest odpowiednie do przechowywania długich komentarzy w systemie społecznościowym.

from django.db import models
 
class Comment(models.Model):
    user = models.ForeignKey(User, on_delete=models.CASCADE)
    content = models.TextField()

TextField może być używane do przechowywania długich notatek w aplikacji do zarządzania projektami.

from django.db import models
 
class ProjectTask(models.Model):
    title = models.CharField(max_length=255)
    notes = models.TextField()

Użycie TextField daje elastyczność w przechowywaniu dużych ilości tekstu, ale warto pamiętać, że może to prowadzić do większego zużycia miejsca w bazie danych, zwłaszcza gdy przechowujesz duże ilości danych tekstowych.

TimeField w modelach Django jest używane do przechowywania informacji o czasie, czyli godzinie i minucie, bez daty. To pole jest przydatne, gdy chcesz śledzić konkretne punkty czasowe w ciągu doby, niezależnie od daty.

Przykłady zastosowań TimeField:

TimeField może być używane do przechowywania informacji o godzinie rozpoczęcia wydarzenia.

from django.db import models
 
class Event(models.Model):
    name = models.CharField(max_length=255)
    start_time = models.TimeField()

TimeField może być stosowane do przechowywania informacji o czasie trwania spotkania.

from django.db import models
 
class Meeting(models.Model):
    title = models.CharField(max_length=255)
    duration = models.TimeField()

TimeField może być używane do przechowywania informacji o godzinie otwarcia restauracji.

from django.db import models
 
class Restaurant(models.Model):
    name = models.CharField(max_length=255)
    opening_time = models.TimeField()

TimeField może być stosowane do przechowywania informacji o czasie trwania zadania w aplikacji do zarządzania zadaniami.

from django.db import models
 
class Task(models.Model):
    title = models.CharField(max_length=255)
    duration = models.TimeField()

Użycie TimeField jest przydatne w sytuacjach, gdzie interesuje cię tylko aspekt czasowy, a nie data. Warto jednak pamiętać, że TimeField przechowuje czas bez uwzględniania strefy czasowej, co może być ważne w niektórych przypadkach. Jeśli potrzebujesz uwzględnić strefę czasową, możesz zamiast tego użyć DateTimeField.

URLField w modelach Django jest używane do przechowywania adresów URL (Uniform Resource Locator), czyli odnośników do zasobów dostępnych w internecie. To pole jest przydatne, gdy chcesz przechowywać i operować na linkach do zasobów internetowych.

Przykłady zastosowań URLField:

URLField może być używane do przechowywania adresu URL strony internetowej firmy.

from django.db import models
 
class Company(models.Model):
    name = models.CharField(max_length=255)
    website_url = models.URLField()

URLField może być stosowane do przechowywania linku do profilu użytkownika w społecznościowym serwisie.

from django.db import models
 
class UserProfile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    social_profile_url = models.URLField()

URLField może być używane do przechowywania linku do konkretnego artykułu w serwisie blogowym.

from django.db import models
 
class BlogPost(models.Model):
    title = models.CharField(max_length=255)
    article_url = models.URLField()

URLField może być stosowane do przechowywania linku do repozytorium na platformie GitHub.

from django.db import models
 
class GitHubRepository(models.Model):
    name = models.CharField(max_length=255)
    repository_url = models.URLField()

URLField sprawdza, czy podany tekst jest poprawnym adresem URL, a także pozwala na opcjonalne określenie maksymalnej długości URL-a. Jeśli zależy ci na przechowywaniu odnośników w modelu, URLField jest odpowiednim wyborem.

UUIDField w modelach Django jest używane do przechowywania identyfikatorów UUID (Universally Unique Identifier). UUID to 128-bitowy identyfikator, który jest globalnie unikalny. Jest używany, aby zapewnić, że identyfikatory są unikalne na całym świecie, co jest szczególnie przydatne w rozproszonych systemach i bazach danych.

Przykłady zastosowań UUIDField:

UUIDField może być używane do przechowywania unikalnych identyfikatorów użytkowników.

from django.db import models
import uuid
 
class UserProfile(models.Model):
    user_id = models.UUIDField(default=uuid.uuid4, editable=False, unique=True)
    # inne pola modelu

UUIDField może być stosowane do generowania unikalnych identyfikatorów dla zasobów w aplikacji.

from django.db import models
import uuid
 
class Resource(models.Model):
    resource_id = models.UUIDField(default=uuid.uuid4, editable=False, unique=True)
    # inne pola modelu

UUIDField może być używane do przechowywania unikalnych identyfikatorów sesji w systemie.

from django.db import models
import uuid
 
class UserSession(models.Model):
    session_id = models.UUIDField(default=uuid.uuid4, editable=False, unique=True)
    # inne pola modelu

UUIDField zazwyczaj jest domyślnie generowane przy użyciu funkcji uuid.uuid4(), która generuje losowy identyfikator UUID. Możesz jednak dostarczyć własną funkcję generującą, jeśli chcesz mieć większą kontrolę nad procesem generowania identyfikatorów.

Użycie UUIDField jest szczególnie przydatne w sytuacjach, gdzie wymagane jest zapewnienie unikalności identyfikatorów, a standardowe autoinkrementowane pola mogą być niewystarczające.

ForeignKey w modelach Django jest używane do tworzenia relacji wiele-do-jednego pomiędzy dwoma modelami. To pole umożliwia nawiązanie połączenia między jednym obiektem jednego modelu a wieloma obiektami innego modelu. Relacja wiele-do-jednego oznacza, że wiele obiektów z jednej strony może być powiązanych z jednym obiektem z drugiej strony.

Przykłady zastosowań ForeignKey:

ForeignKey może być używane do ustanawiania relacji między artykułami a autorami w systemie blogowym, gdzie jeden autor może napisać wiele artykułów, ale każdy artykuł ma tylko jednego autora.

from django.db import models
 
class Author(models.Model):
    name = models.CharField(max_length=255)
 
class Article(models.Model):
    title = models.CharField(max_length=255)
    content = models.TextField()
    author = models.ForeignKey(Author, on_delete=models.CASCADE)

ForeignKey może być stosowane do tworzenia relacji między kategoriami a produktami w sklepie internetowym, gdzie jeden produkt może należeć do jednej kategorii, ale jedna kategoria może zawierać wiele produktów.

from django.db import models
 
class Category(models.Model):
    name = models.CharField(max_length=255)
 
class Product(models.Model):
    name = models.CharField(max_length=255)
    price = models.DecimalField(max_digits=10, decimal_places=2)
    category = models.ForeignKey(Category, on_delete=models.CASCADE)

ForeignKey może być używane do ustanawiania relacji między użytkownikami a zadaniami w aplikacji do zarządzania zadaniami, gdzie jeden użytkownik może być przypisany do wielu zadań, ale każde zadanie ma tylko jednego przypisanego użytkownika.

from django.db import models
from django.contrib.auth.models import User
 
class Task(models.Model):
    title = models.CharField(max_length=255)
    description = models.TextField()
    assigned_user = models.ForeignKey(User, on_delete=models.CASCADE)

ForeignKey jest kluczowe do tworzenia skomplikowanych relacji między różnymi modelami w Django. Parametr on_delete=models.CASCADE oznacza, że gdy obiekt powiązany (Author, Category, User w przykładach powyżej) zostanie usunięty, to wszystkie obiekty związane z tym obiektem (Article, Product, Task) również zostaną usunięte. Istnieje także inne opcje, takie jak PROTECT, SET_NULL, SET_DEFAULT itp., które definiują, jak powinno zachować się pole ForeignKey w przypadku usunięcia obiektu związanego.

Opcje PROTECT, SET_NULL, SET_DEFAULT w parametrze on_delete pola ForeignKey definiują, jak zachować się w przypadku usunięcia obiektu powiązanego z polem ForeignKey. Poniżej znajdziesz krótkie wyjaśnienie każdej z tych opcji:

1. PROTECT: Oznacza, że nie można usunąć obiektu powiązanego, dopóki istnieją obiekty, które na niego się odwołują. Jeśli próbujesz usunąć obiekt, który jest obecnie używany przez inne obiekty za pomocą ForeignKey z opcją PROTECT, to operacja usuwania zostanie zablokowana.

Przykład:

class Author(models.Model):
    name = models.CharField(max_length=255)
 
class Article(models.Model):
    title = models.CharField(max_length=255)
    content = models.TextField()
    author = models.ForeignKey(Author, on_delete=models.PROTECT)

2. SET_NULL: Oznacza, że gdy obiekt powiązany zostanie usunięty, pole ForeignKey w obiektach, które na niego się odwołują, zostanie ustawione na NULL (jeśli to możliwe). Pole to musi być zdefiniowane z parametrem null=True.

Przykład:

class Category(models.Model):
    name = models.CharField(max_length=255)
 
class Product(models.Model):
    name = models.CharField(max_length=255)
    category = models.ForeignKey(Category, on_delete=models.SET_NULL, null=True)

3. SET_DEFAULT: Oznacza, że gdy obiekt powiązany zostanie usunięty, pole ForeignKey w obiektach, które na niego się odwołują, zostanie ustawione na domyślną wartość (określoną w definicji pola ForeignKey za pomocą parametru default).

Przykład:

class User(models.Model):
    username = models.CharField(max_length=255)
 
class Task(models.Model):
    title = models.CharField(max_length=255)
    assigned_user = models.ForeignKey(User, on_delete=models.SET_DEFAULT, default=1)

Oprócz tych opcji istnieją także inne, takie jak SET() (ustawia pole na określoną wartość), DO_NOTHING (nie wykonuje żadnej operacji), a także możesz zdefiniować własną funkcję, która zostanie wywołana w przypadku usunięcia obiektu powiązanego (models.SET(function)). Ważne jest, aby wybrać odpowiednią opcję w zależności od wymagań biznesowych i logicznych struktury danych w aplikacji.

ManyToManyField w modelach Django jest używane do tworzenia relacji wiele-do-wielu pomiędzy dwoma modelami. Oznacza to, że obiekt jednego modelu może być powiązany z wieloma obiektami drugiego modelu, a jednocześnie obiekt drugiego modelu może być powiązany z wieloma obiektami pierwszego modelu.

Przykłady zastosowań ManyToManyField:

ManyToManyField może być używane do reprezentowania relacji między użytkownikami a grupami w systemie, gdzie jeden użytkownik może należeć do wielu grup, a jedna grupa może zawierać wielu użytkowników.

from django.db import models
from django.contrib.auth.models import User
 
class Group(models.Model):
    name = models.CharField(max_length=255)
    members = models.ManyToManyField(User)

ManyToManyField może być stosowane do reprezentowania relacji między produktami a tagami w sklepie internetowym, gdzie jeden produkt może mieć wiele tagów, a jeden tag może być przypisany do wielu produktów.

from django.db import models
 
class Tag(models.Model):
    name = models.CharField(max_length=255)
 
class Product(models.Model):
    name = models.CharField(max_length=255)
    tags = models.ManyToManyField(Tag)

ManyToManyField może być używane do reprezentowania relacji między studentami a kursami w systemie edukacyjnym, gdzie jeden student może uczęszczać na wiele kursów, a jeden kurs może mieć wielu studentów.

from django.db import models
 
class Course(models.Model):
    name = models.CharField(max_length=255)
 
class Student(models.Model):
    name = models.CharField(max_length=255)
    courses = models.ManyToManyField(Course)

Warto zauważyć, że ManyToManyField tworzy automatycznie tabelę pośredniczącą w bazie danych, aby obsłużyć tę relację wiele-do-wielu. Ta tabela przechowuje pary kluczy obcych, które łączą obiekty dwóch powiązanych modeli. W praktyce, korzystanie z ManyToManyField pozwala na elastyczne i dynamiczne zarządzanie związkami między różnymi obiektami w bazie danych.

W relacji wiele-do-wielu (ManyToManyField) w Django możesz samodzielnie określić parametry tabeli pośredniczącej. Django automatycznie tworzy tę tabelę pośredniczącą, ale masz możliwość dostosowania jej zachowania i struktury, używając modelu pośredniczącego.

Aby to zrobić, musisz utworzyć własny model dla tabeli pośredniczącej, a następnie użyć go jako wartość dla argumentu through w polu ManyToManyField. Model pośredniczący powinien zawierać co najmniej dwa pola obce (ForeignKey) do modeli powiązanych.

Przykład:

from django.db import models
from django.contrib.auth.models import User
 
class Tag(models.Model):
    name = models.CharField(max_length=255)
 
class Product(models.Model):
    name = models.CharField(max_length=255)
    tags = models.ManyToManyField(Tag, through='ProductTag')
 
class ProductTag(models.Model):
    product = models.ForeignKey(Product, on_delete=models.CASCADE)
    tag = models.ForeignKey(Tag, on_delete=models.CASCADE)
    added_at = models.DateTimeField(auto_now_add=True)

W powyższym przykładzie, ProductTag to model pośredniczący, który zawiera dwa pola obce (product i tag). Dodatkowo, zostało dodane pole added_at, które automatycznie zapisuje aktualną datę i czas dodania produktu do danego tagu.

Następnie, model Product używa ManyToManyField z argumentem through='ProductTag`, aby wskazać, że chce korzystać z własnej tabeli pośredniczącej zdefiniowanej w modelu ProductTag.

Ten sposób dostarcza większej elastyczności, jeśli chodzi o dostosowywanie relacji wiele-do-wielu w Django. Możesz dostosować strukturę tabeli pośredniczącej oraz dodawać własne pola, które są specyficzne dla relacji między danymi modelami.

Możesz swobodnie dodawać dodatkowe pola do modelu pośredniczącego, takie jak pole określające ilość produktów. W przypadku relacji wiele-do-wielu, model pośredniczący może zawierać dowolne pola, które są potrzebne do dodatkowego opisu lub określenia relacji między modelami.

Poniżej znajduje się przykład, w którym dodano pole quantity do modelu ProductTag, które określa ilość produktów dla danego tagu:

from django.db import models
from django.contrib.auth.models import User
 
class Tag(models.Model):
    name = models.CharField(max_length=255)
 
class Product(models.Model):
    name = models.CharField(max_length=255)
    tags = models.ManyToManyField(Tag, through='ProductTag')
 
class ProductTag(models.Model):
    product = models.ForeignKey(Product, on_delete=models.CASCADE)
    tag = models.ForeignKey(Tag, on_delete=models.CASCADE)
    quantity = models.PositiveIntegerField(default=1)  # Nowe pole określające ilość produktów
    added_at = models.DateTimeField(auto_now_add=True)

W tym przypadku, dodano pole quantity jako PositiveIntegerField z domyślną wartością 1. To pole będzie przechowywać ilość produktów związanych z danym tagiem w relacji wiele-do-wielu.

Pamiętaj, że dodanie nowego pola do modelu pośredniczącego może wpłynąć na istniejące dane w bazie danych, zwłaszcza jeśli są już utworzone rekordy w tabeli pośredniczącej. W przypadku zmiany struktury modelu pośredniczącego, być może będziesz musiał dostosować istniejące dane lub zaktualizować je zgodnie z nową strukturą.

Jeśli tabela pośrednicząca została już automatycznie utworzona, możesz sprawdzić jej właściwości, korzystając z narzędzi zarządzania bazą danych dostępnych w Django, takich jak migracje i polecenie inspectdb. Poniżej przedstawiam kroki, które możesz podjąć:

Użyj polecenia inspectdb do generowania modelu na podstawie bazy danych:
Jeśli chcesz szybko uzyskać modele dla istniejącej bazy danych, możesz użyć polecenia inspectdb. Komenda ta wygeneruje modele Django na podstawie struktury bazy danych.

python manage.py inspectdb

Wynikiem będzie kod Pythona, który reprezentuje modele dla istniejącej bazy danych. Możesz skopiować odpowiednie fragmenty kodu i dodać je do pliku models.py w swojej aplikacji.

Po zastosowaniu tych kroków, będziesz mógł zobaczyć, jakie zmiany są wprowadzane do modelu pośredniczącego, a następnie dostosować go do swoich potrzeb, dodając nowe pola lub inne modyfikacje. Po dokonaniu modyfikacji, ponownie uruchom komendę makemigrations i migrate, aby zastosować zmiany do bazy danych.

OneToOneField w modelach Django jest używane do tworzenia relacji jeden-do-jeden pomiędzy dwoma modelami. Oznacza to, że każdy obiekt jednego modelu może być powiązany tylko z jednym obiektem drugiego modelu, i vice versa. Relacja taka jest przydatna, gdy chcesz utworzyć unikalne i szczególne powiązanie między dwoma modelami.

Przykłady zastosowań OneToOneField:

OneToOneField może być używane do ustanawiania relacji między użytkownikami a ich profilami, gdzie każdy użytkownik ma tylko jeden profil, a każdy profil jest przypisany do jednego użytkownika.

from django.db import models
from django.contrib.auth.models import User
 
class UserProfile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    bio = models.TextField()
    profile_picture = models.ImageField(upload_to='profile_pics/')

OneToOneField może być stosowane do reprezentowania relacji między pracownikiem a jego szefem, gdzie każdy pracownik ma tylko jednego szefa, a każdy szef jest przypisany do jednego pracownika.

from django.db import models
 
class Employee(models.Model):
    name = models.CharField(max_length=255)
    position = models.CharField(max_length=255)
 
class Manager(models.Model):
    employee = models.OneToOneField(Employee, on_delete=models.CASCADE)
    department = models.CharField(max_length=255)

OneToOneField może być używane do reprezentowania relacji między zamówieniem a fakturą, gdzie każde zamówienie ma tylko jedną fakturę, a każda faktura jest przypisana do jednego zamówienia.

from django.db import models
 
class Order(models.Model):
    order_number = models.CharField(max_length=255)
    total_amount = models.DecimalField(max_digits=10, decimal_places=2)
 
class Invoice(models.Model):
    order = models.OneToOneField(Order, on_delete=models.CASCADE)
    invoice_number = models.CharField(max_length=255)
    amount_paid = models.DecimalField(max_digits=10, decimal_places=2)

OneToOneField jest przydatne, gdy chcesz utworzyć szczególne, unikalne powiązanie między dwoma modelami, a każdy obiekt jednego modelu powinien mieć tylko jedno przypisanie w drugim modelu.