Detaillierte Erläuterung des ORM Mysql Django Models-Modells

Django-Modelle

ORM ist die Abkürzung für „Object-Relational-Mapping“ und seine Hauptfunktion besteht darin, Modellklassen und -attribute zu definieren. Jedes Modell kann als Datentabelle in der Datenbank abgebildet werden und Klassenattribute werden als Datenfelder abgebildet.

Codierungsstil der Modelle

from django.db import models
class ModelName(models.Model):
  field1 = models.xxfield(..)
  field2 = models.xxfield(..)
  ...
  class Meta:
    db_table  = ...
    other_metas = ...

ORM-Instanzzuordnung

erstellen

# 创建表sql
CREATE TABLE employee(
id INT PRIMARY KEY auto_increment ,
name VARCHAR (20),
gender BIT default 1,
birthday DATA ,
department VARCHAR (20),
salary DECIMAL (8,2) unsigned,
);

# 创建表ORM
class Employee(models.Model):
id=models.AutoField(primary_key=True)
name=models.CharField(max_length=32)
gender=models.BooleanField()
birthday=models.DateField()
department=models.CharField(max_length=32)
salary=models.DecimalField(max_digits=8,decimal_places=2)

CRUD

# 添加表数据sql
INSERT employee (name,gender,birthday,salary,department)
VALUES ("alex",1,"1985-12-12",8000,"保洁部");
# 添加表数据ORM
emp=Employee(name="alex",gender=True,birthday="1985-12-12",epartment="保洁部")
emp.save()

# 查询表数据sql
SELECT * FROM employee WHERE age=24;
# 查询表数据ORM
Employee.objects.filter(age=24)

# 更新表数据sql
UPDATE employee SET birthday="1989-10-24" WHERE id=1;
# 更新表数据ORM
Employee.objects.filter(id=1).update(birthday="1989-10-24")

# 删除表数据sql
DELETE FROM employee WHERE name="alex"
# 删除表数据ORM
Employee.objects.filter(name="alex").delete()

Hinweis
1. Der Tabellenname wird automatisch generiert. Wenn Sie den Tabellennamen anpassen müssen, müssen Sie den Parameter db_table in der Metaklasse des Modells angeben. Es wird empfohlen, Tabellennamen in Kleinbuchstaben zu verwenden, insbesondere wenn MySQL als Hintergrund verwendet wird -End-Datenbank.
2. Das ID-Feld wird automatisch hinzugefügt. Wenn Sie einen benutzerdefinierten Primärschlüssel angeben möchten, müssen Sie nur Primary_key=True in einem der Felder angeben. Wenn Django feststellt, dass Sie Field.primary_key explizit festgelegt haben, wird die automatische ID-Spalte nicht hinzugefügt.
3. Django generiert entsprechende SQL-Anweisungen entsprechend dem in der Konfigurationsdatei angegebenen Datenbank-Backend-Typ und unterstützt MySQL5.5 und höhere Versionen.

ORM-Viele-zu-Eins-Beziehung

Angenommen, ein Unternehmen hat mehrere Mitarbeiter und mehrere Mitarbeiter gehören zu einem Unternehmen.
Sie können einen Fremdschlüssel verwenden, um eine Viele-zu-Eins-Beziehung anzugeben

# models.py
class Department(models.Model): # 主表
    dep_name = models.CharField(max_length=20,verbose_name='部门名称')
    desc = models.CharField(max_length=20,verbose_name='部门描述')

    class Meta: # 从表
        verbose_name = "部门表"
        verbose_name_plural = verbose_name
        db_table = 'department'
    def __str__(self):
        return self.dep_name

class Employee(models.Model):
    emp_name = models.CharField(max_length=20,verbose_name='姓名')
    job = models.CharField(max_length=20,verbose_name='职位')
    salary = models.IntegerField(verbose_name='工资')
    dapartment = models.ForeignKey(to=Department, on_delete=models.CASCADE, verbose_name='部门')

    class Meta:
        verbose_name = "员工表"
        verbose_name_plural = verbose_name
        db_table = 'employee'
    def __str__(self):
        return self.emp_name

# views.py
class DepartmentView(View):
    def get(self,request):
        department = Department.objects.all()
        return render(request,'department.html',{
    
    'department':department})
       <以下代码为增加操作，上面的代码为方便写路由>
    def post(self,request):
        emp_name = request.POST.get('emp_name')
        job = request.POST.get('job')
        salary = request.POST.get('salary')
        dapartment = request.POST.get('dapartment')
        try:
            Employee.objects.create(
                emp_name=emp_name,
                job=job,
                salary=salary,
                dapartment_id=dapartment)
        except Exception as e:
            print(e)
            return HttpResponse("添加失败")
        return redirect('/dep/')
        
# url路由
path('dep/',views.DepartmentView.as_view()),
 

# 删

class DelEmployeeView(View):
    def get(self,request,id):
        employee_data = Employee.objects.get(id=id)
        dep_id = employee_data.dapartment_id
        employee_data.delete()
        return redirect(f'/emp/{
      
      dep_id}')
        
# url路由
path('delemp/<int:id>/',views.DelEmployeeView.as_view()),

# 改

class UpdateEmployeeView(View):
    def get(self,request,id):
        try:
            employee_data = Employee.objects.get(id=id)
        except Exception as e:
            print(e)
            return HttpResponse("页面不存在")
        return render(request,'index.html',{
    
    'employee':employee_data})
    def post(self,request,id):
        emp_name = request.POST.get('emp_name')
        job =  request.POST.get('job')
        salary = request.POST.get('salary')
        dapartment = request.POST.get('dapartment')
        try:
            Employee.objects.filter(id=id).update(
                emp_name = emp_name,
                job = job,
                salary = salary,
                dapartment_id = dapartment
            )
        except Exception as e:
            print(e)
            return HttpResponse('修改数据失败')
        return redirect('/dep/')

# url路由
path('updateemp/<int:id>/',views.UpdateEmployeeView.as_view())

# 点击主表某字段以获取从表对应信息
class EmployeeView(View):
    def get(self,request,id):
        employee = Employee.objects.filter(dapartment_id=id)
        return render(request,'employee.html',{
    
    'employee':employee})

# url路由
    path('emp/<int:id>/',views.EmployeeView.as_view()),

ORM Eins-zu-Eins-Beziehung

Angenommen, eine Person kann nur ein Objekt haben und eine Person kann nicht mehrere Objekte haben.
Verwenden Sie OneToOneField, um eine Eins-zu-Eins-Beziehung zu definieren.
Die Haupttabelle überprüft die Untertabelle und schreibt den Namen der Untertabelle in Kleinbuchstaben. Die
Untertabelle überprüft die Haupttabelle und direkt verwendet die verbundenen Felder zur Überprüfung.

ORM-Viele-zu-Viele-Beziehung

Angenommen, ein Musiker gehört mehreren Bands an und eine Band besteht aus mehreren Musikern.
Verwenden Sie die Felddefinition ManyToManyField

数据的添加
模型类.objects.create(需要添加的字段=‘’)
乐队 = 表名.objects.create(表名小写_name=“Jack”)
数据的删除
乐队.表名.remove(音乐家)
数据的查询
主表查子表
主表.band_set.all()
子表查主表
子表.主表字段.all()

gemeinsames Feld

Feldname	Ausführliche Erklärung
AutoField	Int Auto-Inkrement-Spalte muss der Parameter „primary_key=True“ ausgefüllt sein. Wenn im Modell keine Spalte für die automatische Inkrementierung vorhanden ist, wird automatisch eine Spalte mit dem Namen „id“ erstellt.
IntegerField	Ein ganzzahliger Typ im Bereich von -2147483648 bis 2147483647. (Im Allgemeinen wird es nicht zum Speichern der Mobiltelefonnummer verwendet (die Anzahl der Ziffern reicht nicht aus). Verwenden Sie zum Speichern direkt die Zeichenfolge
CharField	Für den Zeichentyp muss der Parameter max_length angegeben werden, und max_length gibt die Zeichenlänge an. Das CharField in Django entspricht dem Varchar-Typ in der MySQL-Datenbank, und es gibt kein Feld, das dem Char-Typ entspricht
Datumsfeld	Datumsfeld, das Datumsformat ist JJJJ-MM-TT, was der datetime.date()-Instanz in Python entspricht.
DateTimeField	Datums- und Uhrzeitfeld, das Format ist JJJJ-MM-TT HH:MM[:ss[.uuuuuu]][TZ], was der datetime.datetime()-Instanz in Python entspricht.
Feldparameter
Null	Wird verwendet, um anzuzeigen, dass ein Feld leer sein kann.
einzigartig	Wenn es auf „unique=True“ gesetzt ist, muss das Feld in dieser Tabelle eindeutig sein.
db_index	Wenn db_index=True, bedeutet dies, dass ein Index für dieses Feld festgelegt wird.
Standard	Legen Sie einen Standardwert für dieses Feld fest.
auto_now_add	DateField und DateTimeField, konfigurieren Sie auto_now_add=True, beim Erstellen von Datensätzen wird die aktuelle Uhrzeit zur Datenbank hinzugefügt.
auto_now	Konfigurieren Sie auto_now=True, und dieses Feld wird jedes Mal aktualisiert, wenn der Datensatz aktualisiert wird.
Beziehungsfeld
Unbekannter Schlüssel	Der Fremdschlüsseltyp wird im ORM verwendet, um die Fremdschlüsselzuordnungsbeziehung darzustellen. Im Allgemeinen wird das ForeignKey-Feld auf die „viele“-Seite von „eins-zu-viele“ eingestellt. ForeignKey kann mit anderen Tabellen und auch mit sich selbst verknüpft werden.
Feldparameter
Zu	Stellen Sie die verknüpfte Tabelle ein.
to_field	Legen Sie die zuzuordnenden Felder fest
on_delete	Das Verhalten der mit der aktuellen Tabelle verknüpften Zeilen, wenn Daten in der zugehörigen Tabelle gelöscht werden. (siehe Beispiel oben)
ManyToManyField	Wird verwendet, um eine Viele-zu-Viele-Beziehung darzustellen. Stellen Sie eine Assoziationsbeziehung über die dritte Tabelle in der Datenbank her
verwandter_Name	Identisch mit dem ForeignKey-Feld
verwandter_Abfragename	Identisch mit dem ForeignKey-Feld.
symmetrisch	Wird nur für die Viele-zu-Viele-Selbstzuordnung verwendet und gibt an, ob intern ein Umkehroperationsfeld erstellt werden soll. Der Standardwert ist True.
durch	Bei Verwendung des ManyToManyField-Felds generiert Django automatisch eine Tabelle zur Verwaltung der Viele-zu-Viele-Beziehung. Wir können aber auch manuell eine dritte Tabelle erstellen, um die Viele-zu-Viele-Beziehung zu verwalten. In diesem Fall müssen wir den Tabellennamen der dritten Tabelle durchgehend angeben.
through_fields	Legen Sie die zugehörigen Felder fest.
db_table	Der Name der Tabelle in der Datenbank, wenn die dritte Tabelle standardmäßig erstellt wird.

Die in der Datenbank gespeicherte Zeit von CreatedTime und uLastUpdatedTime ist immer die Zeit in der UTC-Zeitzone (8 Stunden langsamer als die Pekinger Zeit). Wenn Sie sich im Programm nicht mit der Zeitzone (zeitzonenbewusst) befassen und diese als Pekinger Zeit anzeigen müssen, müssen Sie die Zeitzone deaktivieren:

Ändern Sie USE_TZ = True in global settings.py in USE_TZ = False, um die Zeitzone auszuschalten

Wenn Sie USE_TZ=True beibehalten möchten, können Sie CreatedTime = models.DateTimeField(default=datetime.now().replace(tzinfo=utc)) festlegen.

Meta-Klasse

Die Meta-Klasse kapselt einige Datenbankinformationen

Feldname	Ausführliche Erklärung
db_table	Der Tabellenname von ORM in der Datenbank lautet standardmäßig app_class name, und der Tabellenname kann über db_table umgeschrieben werden.
index_together	Gelenkindex
unique_together	Gemeinsamer eindeutiger Index, unique_together Diese Option wird verwendet, wenn Sie die Eindeutigkeit über zwei Felder hinweg aufrechterhalten müssen. Angenommen, Sie möchten, dass die Kombination aus Vorname und Nachname einer Person eindeutig ist, dann müssen Sie sie wie folgt festlegen: unique_together = (("first_name", "last_name"),) Ein ManyToManyField kann nicht in unique_together enthalten sein. Wenn Sie die eindeutige Validierung im Zusammenhang mit dem Feld ManyToManyField validieren müssen, versuchen Sie es mit signal (signal) oder geben Sie explizit das Attribut „through“ an.
Bestellung	指定默认按什么字段排序。ordering=[‘order_date’] # 按订单升序排列ordering=[‘-order_date’] # 按订单降序排列，-表示降序ordering=[‘?order_date’] # 随机排序，？表示随机ordering=[‘-pub_date’,‘author’] # 以pub_date为降序，在以author升序排列
verbose_name	verbose_name的意思很简单，就是给你的模型类起一个更可读的名字一般定义为中文，我们：verbose_name = “学校”
verbose_name_plural	这个选项是指定，模型的复数形式是什么，比如：verbose_name_plural = "学校"如果不指定Django会自动在模型名称后加一个’s’
abstract	Options.abstract 这个属性是定义当前的模型是不是一个抽象类。所谓抽象类是不会对应数据库表的。一般我们用它来归纳一些公共属性字段，然后继承它的子类可以继承这些字段。如果abstract = True 这个model就是一个抽象类
app_label	这个选型只在一种情况下使用，就是你的模型不在默认的应用程序包下的models.py文件中，这时候需要指定你这个模型是哪个应用程序的。如果一个model定义在默认的models.py，例如如果你的app的models在myapp.models子模块下，你必须定义app_label让Django知道它属于哪一个app，app_label = ‘myapp’
db_teblespace	定义这个model所使用的数据库表空间。如果在项目的settin中定义那么它会使用这个值
get_latest_by	在model中指定一个DateField或者DateTimeField。这个设置让你在使用model的Manager上的lastest方法时，默认使用指定字段来排序
managed	Der Standardwert ist True, was bedeutet, dass Django die Befehle syncdb und reset verwenden kann, um die entsprechende Datenbank zu erstellen oder zu entfernen. Der Standardwert ist True. Wenn Sie dies nicht möchten, können Sie den Wert von manage auf False setzen
order_with_respect_to	Diese Option wird im Allgemeinen in einer Viele-zu-Viele-Beziehung verwendet und zeigt auf ein zugehöriges Objekt. Dies bedeutet, dass das zugehörige Objekt nach dem Auffinden dieses Objekts sortiert wird. Nach Angabe dieser Eigenschaft erhalten Sie die Methoden get_xxx_order() und set_xxx_order(), mit denen Sie das sortierte Objekt festlegen oder zurückgeben können
Berechtigungen	Berechtigungen dienen hauptsächlich zur Verwendung im Django Admin-Verwaltungsmodul. Wenn Sie dieses Attribut festlegen, kann die Beschreibung der angegebenen Methodenberechtigungen klarer und lesbarer gemacht werden. Django erstellt automatisch Berechtigungen zum Hinzufügen, Löschen und Ändern für jedes Objekt, das auf „Admin“ gesetzt ist.
Proxy	Dies wird verwendet, um das Proxy-Modell zu implementieren. Wenn Proxy = True, bedeutet dies, dass das Modell das Proxy-Modell seines übergeordneten Modells ist