django-orm学习

orm数据库操作

ORM是什么？：(在django中，根据代码中的类自动生成数据库的表也叫--code first)

ORM：Object Relational Mapping(关系对象映射)

类名对应------》数据库中的表名

类属性对应---------》数据库里的字段

类实例对应---------》数据库表里的一行数据

obj.id obj.name.....类实例对象的属性

orm参数文档

首先创建数据库：

create database devops10 default character set utf8 collate utf8_general_ci;

2.修改setting配置文件:

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'devops',
        'HOST': '127.0.0.1',
        'USER': 'root',
        'PASSWORD': '123456',
        'PORT': 3306
    }
}

3.生成数据库迁移文件:

(.venv) [vagrant@51Reboot devops2020]$ python manage.py makemigrations

4.生成数据库：

(.venv) [vagrant@51Reboot devops2020]$ python manage.py migrate

修改表之后常见报错：

这个报错：因为表创建好之后，新增字段没有设置默认值，或者原来表中字段设置了不能为空参数，修改后的表结构和目前的数据冲突导致；

orm操作前的准备：

orm使用方式：

orm操作可以使用类实例化，obj.save的方式，也可以使用create（）的形式

QuerySet数据类型介绍

QuerySet与惰性机制

所谓惰性机制：Publisher.objects.all()或者.filter()等都只是返回了一个QuerySet（查询结果集对象），它并不会马上执行sql，而是当调用QuerySet的时候才执行。

QuerySet特点：

<1> 可迭代的

<2> 可切片

<3>惰性计算和缓存机制

(devops9) root@django:/opt/devops9# python manage.py shell
Python 3.6.9 (default, Nov  7 2019, 10:44:02) 
Type 'copyright', 'credits' or 'license' for more information
IPython 7.13.0 -- An enhanced Interactive Python. Type '?' for help.

In [1]: from books.models import Book,Publish,Author                                                                                                                       
In [2]: book = Book.objects.all()[:2]        #切片操作                                                                                                                              
In [3]: book                                                                                                                                                               
Out[3]: <QuerySet [<Book: laowang>, <Book: 平凡的世界1>]>
    
In [4]: book = Book.objects.all()[2]     #索引                                                                                                                                  
In [5]: book                                                                                                                                                               
Out[5]: <Book: django2019>

In [6]: book.name                                                                                                                                                          
Out[6]: 'django2019'
    

In [7]: books = Book.objects.all()  ##惰性计算--->等于一个生成器，不应用books不会执行任何SQL操作 # query_set缓存机制1次数据库查询结果query_set都会对应一块缓存，再次使用该query_set时，不会发生新的SQL操作；
#这样减小了频繁操作数据库给数据库带来的压力;                                          
In [8]: book                                                                                                                                                               
Out[8]: <QuerySet [<Book: laowang>, <Book: 平凡的世界1>, <Book: django2019>, <Book: django2020>, <Book: 《心迹》>, <Book: python>, <Book: laowang>]>

增加数据：

 Obj.create()
In [12]: p = Publish.objects.create(**{'name':'人民出版社', 'address': '北京'}) 
In [14]: Publish.objects.all()                                                                                                                                        
Out[14]: <QuerySet [<Publish: 南京大学出版社>, <Publish: 西安大学出版社>, <Publish: 读者>, <Publish: aaa>, <Publish: reboot>, <Publish: 人民出版社>]>

 Obj.save()


In [40]: obj.name = '人安'                                                                                                                                          

In [41]: obj.name = 'qingan'                                                                                                                                               

In [42]: obj.address = 'qingan'                                                                                                                                            

In [43]: obj.save()    
    也可以写成一行:
        obj=Book(
        title="Python",
        price=99,
        publication_date="2019-05-06",
        publisher_id=1,
    )
    obj.save()

总结起来就是：

# 增
    #
    models.Tb1.objects.create(c1='xx', c2='oo')  #增加一条数据，可以接受字典类型数据 **kwargs

    obj = models.Tb1(c1='xx', c2='oo')
    obj.save()

    # 查
    #
    models.Tb1.objects.get(id=123)         # 获取单条数据，不存在则报错（不建议）
    models.Tb1.objects.all()               # 获取全部
    models.Tb1.objects.filter(name='seven') # 获取指定条件的数据

    # 删
    #
    models.Tb1.objects.filter(name='seven').delete() # 删除指定条件的数据

    # 改
    models.Tb1.objects.filter(name='seven').update(gender='0')  # 将指定条件的数据更新，均支持 **kwargs
    obj = models.Tb1.objects.get(id=1)
    obj.c1 = '111'
    obj.save()                                                 # 修改单条数据

基本操作

进阶操作：（利用下划线）：

# 获取个数
        #
        models.Tb1.objects.filter(name='seven').count()

        # 大于，小于
        #
        models.Tb1.objects.filter(id__gt=1)              # 获取id大于1的值
        models.Tb1.objects.filter(id__gte=1)              # 获取id大于等于1的值
        models.Tb1.objects.filter(id__lt=10)             # 获取id小于10的值
        models.Tb1.objects.filter(id__lte=10)             # 获取id小于10的值
        models.Tb1.objects.filter(id__lt=10, id__gt=1)   # 获取id大于1 且 小于10的值

        # in
        #
        models.Tb1.objects.filter(id__in=[11, 22, 33])   # 获取id等于11、22、33的数据
        models.Tb1.objects.exclude(id__in=[11, 22, 33])  # not in

        # isnull
        Entry.objects.filter(pub_date__isnull=True)

        # contains
        #
        models.Tb1.objects.filter(name__contains="ven")
        models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感
        models.Tb1.objects.exclude(name__icontains="ven")

        # range
        #
        models.Tb1.objects.filter(id__range=[1, 2])   # 范围bettwen and

        # 其他类似
        #
        startswith，istartswith, endswith, iendswith,

        # order by
        #
        models.Tb1.objects.filter(name='seven').order_by('id')    # asc
        models.Tb1.objects.filter(name='seven').order_by('-id')   # desc

        # group by
        #
        from django.db.models import Count, Min, Max, Sum
        models.Tb1.objects.filter(c1=1).values('id').annotate(c=Count('num'))
        SELECT "app01_tb1"."id", COUNT("app01_tb1"."num") AS "c" FROM "app01_tb1" WHERE "app01_tb1"."c1" = 1 GROUP BY "app01_tb1"."id"

        # limit 、offset
        #
        models.Tb1.objects.all()[10:20]

        # regex正则匹配，iregex 不区分大小写
        #
         Entry.objects.get(title__regex=r'^(An?|The) +')
        Entry.objects.get(title__iregex=r'^(an?|the) +')

        # date
        #
        Entry.objects.filter(pub_date__date=datetime.date(2005, 1, 1))
        Entry.objects.filter(pub_date__date__gt=datetime.date(2005, 1, 1))

        # year
        #
        Entry.objects.filter(pub_date__year=2005)
        Entry.objects.filter(pub_date__year__gte=2005)

        # month
        #
        Entry.objects.filter(pub_date__month=12)
        Entry.objects.filter(pub_date__month__gte=6)

        # day
        #
        Entry.objects.filter(pub_date__day=3)
        Entry.objects.filter(pub_date__day__gte=3)

        # week_day
        #
        Entry.objects.filter(pub_date__week_day=2)
        Entry.objects.filter(pub_date__week_day__gte=2)

        # hour
        #
        Event.objects.filter(timestamp__hour=23)
        Event.objects.filter(time__hour=5)
        Event.objects.filter(timestamp__hour__gte=12)

        # minute
        #
        Event.objects.filter(timestamp__minute=29)
        Event.objects.filter(time__minute=46)
        Event.objects.filter(timestamp__minute__gte=29)

        # second
        #
        Event.objects.filter(timestamp__second=31)
        Event.objects.filter(time__second=2)
        Event.objects.filter(timestamp__second__gte=31)

进阶操作

ORM连表操作

我们在学习django中的orm的时候，我们可以把一对多，多对多，分为正向和反向查找两种方式。

正向查找：ForeignKey在 UserInfo表中，如果从UserInfo表开始向其他的表进行查询，这个就是正向操作，反之如果从UserType表去查询其他的表这个就是反向操作。

一对多：models.ForeignKey(其他表)
多对多：models.ManyToManyField(其他表)
一对一：models.OneToOneField(其他表)

正向连表操作总结：

所谓正、反向连表操作的认定无非是Foreign_Key字段在哪张表决定的，

Foreign_Key字段在哪张表就可以哪张表使用Foreign_Key字段连表，反之没有Foreign_Key字段就使用与其关联的小写表名；

1对多：对象.外键.关联表字段，values(外键字段__关联表字段)

多对多：外键字段.all()

反向连表操作总结：

通过value、value_list、fifter 方式反向跨表：小写表名__关联表字段

通过对象的形式反向跨表：小写表名_set().all()

应用场景：

一对多：当一张表中创建一行数据时，有一个单选的下拉框（可以被重复选择）

例如：创建用户信息时候，需要选择一个用户类型【普通用户】【金牌用户】【铂金用户】等。

多对多：在某表中创建一行数据是，有一个可以多选的下拉框

例如：创建用户信息，需要为用户指定多个爱好

一对一：在某表中创建一行数据时，有一个单选的下拉框（下拉框中的内容被用过一次就消失了

例如：原有含10列数据的一张表保存相关信息，经过一段时间之后，10列无法满足需求，需要为原来的表再添加5列数据

一.一对多

如果A表的1条记录对应B表中N条记录成立，两表之间就是1对多关系；在1对多关系中 A表就是主表，B表为子表，ForeignKey字段就建在子表；

　　首先来设计两张简单的表格，并在其中一张表中设置一个另外一张表的外键值　　　

publish:　　

class Publish(models.Model):
    """
    出版商
    """

    name = models.CharField(max_length=30, verbose_name='出版商名称', help_text="出版商名")
    city = models.CharField(max_length=60, verbose_name='出版商城市', null=True, blank=True, help_text="出版商城市")
    address = models.CharField(max_length=60, verbose_name='出版商地址', help_text="出版商地址")

    class Meta:
        verbose_name = '出版商信息'
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.name

book:

class Book(models.Model):
    """
    图书
    """

    name = models.CharField("书名", max_length=100, help_text="书名")
    # 作者和书是多对多的关系
    authors = models.ManyToManyField(Author, verbose_name="作者", help_text="作者")
    # 一本书只能被一家出版，出版商可以出版多本书
    publisher = models.ForeignKey(Publish, verbose_name="出版社", help_text="出版商", on_delete=models.CASCADE)
    publication_date = models.DateField("出版时间", null=True, blank=True, help_text="出版日前")

    class Meta:
        verbose_name = '图书信息'
        verbose_name_plural = verbose_name
        ordering = ['-publication_date']

    def __str__(self):
        return self.name

1.1 添加新数据：

A：传id的方式—— 外健字段要注意（不常用）给Publisherz增加id

from book.models import Book, Publish
data = {"name": "goland", "publication_date": "2020-06-23", "publisher_id": 4}
Book.objects.create(**data)
Out[47]: <Book: goland>

B：传对象的方式（常用）

d = Publish.objects.get(pk=1)
data = {"name": "goland", "publication_date": "2020-06-23", "publisher": d}
Book.objects.create(**data)
Out[51]: <Book: goland>

备注：
在我们写的models类时，外键的字段是”publiser",而django在数据库中保存字段时默认会在后面加“_id”，所以可以直接通过传id的方式。
在表中的外键字段“publisher_id”又代表的是字典表中的一行数据对象。于是同样可以传对象的方式来传参。

1.2、删除数据

pk_1 = Book.objects.get(pk=1)
pk_1
Out[9]: <Book: 平凡的世界>
pk_1.delete()
Out[10]: (2, {'book.Book_authors': 1, 'book.Book': 1})

1.3、修改数据（同上)

Book.objects.filter(pk=2).update(name="laowang", publisher_id=4)
Out[20]: 1

1.4 查询数据

django的get方法是从数据库的取得一个匹配的结果，返回一个对象，如果记录不存在的话，它会报错。
django的filter方法是从数据库的取得匹配的结果，返回一个对象列表，如果记录不存在的话，它会返回[]。

ORM的一对多：

我们在设计表结构的时候什么时候使用一对多呢？

比如我们在建立用户的时候有个菜单让我们选择用户类型的时候，使用一对多！！

1、一对多的正向查找：

正向查：ForeignKeyBook表里，如果根据UserInfo这张表去查询这两张关联的表的合起来的内容就是正向查

反向查：ForeignKey不在Publush里,如果根据Publisher_name这张表去查询这两张关联的表的合起来的内容就是反向查

正向铭记于心的两条：
在联表操作过滤/查找数据时用双下划线 "__"，即外键__外键列
在取数据时用点 "."

跨表取值：

In [56]: q = Book.objects.all().first()                                                                                                                                 
In [57]: q.publisher.name                                                                                                                                                  
Out[57]: '读者'

这本书的出版社：()

b = Book.objects.get(pk=6)
b.publisher.name
Out[15]: '北京大学出版社'

Book.objects.get(pk=6).publisher.name
Out[16]: '北京大学出版社'

在django中外键就相当于简单的使用__连表，在外键那个对象中封装了publish表中的所有字段
我们要查询所有出版社为北京大学出版社的书，如果是跨表查询使用“双下划线” + 属性

Book.objects.filter(publisher__name="北京大学出版社")
Out[26]: <QuerySet [<Book: goland>, <Book: laowang>, <Book: devops2021>, <Book: devops2024>, <Book: devops2021>]>bash

反向查找：

反向操作无非2种方式：

1、通过对象的形式反向跨表：小写表面_set().all()

2、通过value和value_list方式反向跨表：小写表名__字段

二、多对多
首先设计好多对多的表结构：一台主机可以有多个管理员，一个管理员可以管理多台主机

class Author(models.Model):
    """
    作者
    """

    name = models.CharField(max_length=40, verbose_name='作者名', help_text="作者名")
    email = models.EmailField(verbose_name='作者邮箱', help_text="作者邮箱")
    phone = models.CharField(max_length=11, verbose_name='手机号码', null=True, blank=True, help_text="作者电话")
    address = models.CharField(max_length=128, verbose_name='作者地址', null=True, blank=True, help_text="作者地址")

    class Meta:
        verbose_name = '作者信息'
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.name

class Book(models.Model):
    """
    图书
    """

    name = models.CharField("书名", max_length=100, help_text="书名")
    # 作者和书是多对多的关系
    authors = models.ManyToManyField(Author, verbose_name="作者", help_text="作者")
    # 一本书只能被一家出版，出版商可以出版多本书
    publisher = models.ForeignKey(Publish, verbose_name="出版社", help_text="出版商", on_delete=models.CASCADE)
    publication_date = models.DateField("出版时间", null=True, blank=True, help_text="出版日前")

    class Meta:
        verbose_name = '图书信息'
        verbose_name_plural = verbose_name
        ordering = ['-publication_date']

    def __str__(self):

1、增加数据

正向添加（基于存在外键字段表的查找为正向）：
　　

from book.models import Author, Book #导入数据

#查询一本书的作者
b = Book.objects.get(pk=6)
b.authors.all()
Out[37]: <QuerySet [<Author: 路遥>]>
b.authors.all().count()
Out[38]: 1

#添加作者
a = Author.objects.get(pk=1)
Out[40]: <Author: pingping>
b.authors.add(a)
b.authors.all()
Out[52]: <QuerySet [<Author: pingping>, <Author: 路遥>]>

# # add是追加，set是重置
aa = Author.objects.filter(pk=2)
aa
Out[54]: <QuerySet [<Author: 贾凹平>]>
b.authors.set(aa)
b.authors.all()
Out[56]: <QuerySet [<Author: 贾凹平>]>

2.查询数据

多对多关系表数据查找思路

1、找到该对象
2.通过该对象 反向操作 找到第三张关系表
3.通过第三张关系表 正向操作 找到 和该对象有关系对象总结（只要对象1和对象2 中间有关系表建立了关系； 对象1反向操作 到关系表 ,关系表正向操作到对象2,反之亦然

posted @ 2020-07-18 23:21 wangsk 阅读(43) 评论(0) 收藏举报

刷新页面返回顶部

KangKang闲事杂谈

django-orm学习

orm数据库操作

ORM连表操作

1.1 添加新数据：

1.2、删除数据

1.3、修改数据（同上)

1.4 查询数据

ORM的一对多：

1、一对多的正向查找：

1、增加数据

公告

KangKang闲事杂谈

django-orm学习

orm数据库操作

ORM连表操作

1.1 添加新数据：

1.2、删除数据

1.3、修改数据 （同上)

1.4 查询数据

ORM的一对多：

1、一对多的正向查找：

1、增加数据

公告

1.3、修改数据（同上)