F与Q查询

在models.py中创建表

from django.db import models

# Create your models here.

class Book(models.Model):
    title = models.CharField(max_length=32, verbose_name='书名')
    price = models.DecimalField(max_digits=8, decimal_places=2, verbose_name='价格')

    # 跟Publish表建立一对多关系
    publish = models.ForeignKey(to='Publish')

    # 跟Auhtor表建立多对多关系
    authors = models.ManyToManyField(to='Author')

    maichu = models.IntegerField(default=1000)
    kucun = models.IntegerField(default=1000)

    def __str__(self):
        return self.title

class Publish(models.Model):
    title = models.CharField(max_length=32, verbose_name='出版社名称')
    addr = models.CharField(max_length=32, verbose_name='出版社地址')

class Author(models.Model):
    name = models.CharField(max_length=32, verbose_name='作者姓名')
    age = models.IntegerField(verbose_name='作者年龄')

    # 跟AuthorDetail建立一对一关系
    detail = models.OneToOneField(to='AuthorDetail')

class AuthorDetail(models.Model):
    phone = models.IntegerField(verbose_name='作者的电话号码')
    email = models.EmailField(verbose_name='作者的邮箱')

在test.py中

import os
import sys

if __name__ == "__main__":
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "django05.settings")
    import django
    django.setup()
    from app01 import models

# F查询
    from django.db.models import F
    1 查询卖出数大于库存数的书籍
    res = models.Book.objects.filter(maichu__gt=F('kucun'))
    print(res)
    当在django中两个表字段进行比较的时候需要导入F模块

    2 将所有书籍的价格提升500块
    models.Book.objects.update(price=F('price')+500)
    当在django中给某个表数据增加数字（int类）时需要导入F模块

    3 将所有书的名称后面加上爆款两个字
    from django.db.models import Value
    from django.db.models.functions import Concat
    models.Book.objects.update(title=Concat(F('title'), Value('爆款')))
    当在django中想要给表名添加一个字符串的时候需要导入以上两个模块

# Q查询
    1 查询卖出数大于100或者价格小于600的书籍
    from django.db.models import Q
    res = models.Book.objects.filter(Q(maichu__gt=100) | Q(price__lt=600))
    print(res)
    print(res.query)
    在django中想要查询表用或者，取反的关系，需要导入Q模块，将做逻辑判断的双方分别放到Q()中
    """
        1.当Q()与Q()用 , 连接时，表示and关系
        2.当Q()与Q()用 | 连接时，表示or关系
        3.在Q()前面加上 ~ 表示取反。 eg: ~Q()
    """

开启事务

四大特性

(1) 原子性(Atomicity)

事务的原子性指的是，事务中包含的程序作为数据库的逻辑工作单位，它所做的对数据修改操作要么全部执行，要么完全不执行。这种特性称为原子性。

例如银行取款事务分为2个步骤(1)存折减款(2)提取现金。不可能存折减款，却没有提取现金。2个步骤必须同时完成或者都不完成。

(2)一致性(Consistency)    

事务的一致性指的是在一个事务执行之前和执行之后数据库都必须处于一致性状态。这种特性称为事务的一致性。假如数据库的状态满足所有的完整性约束，就说该数据库是一致的。

例如完整性约束a+b=10，一个事务改变了a，那么b也应随之改变。

(3)分离性(亦称独立性Isolation)

分离性指并发的事务是相互隔离的。即一个事务内部的操作及正在操作的数据必须*起来，不被其它企图进行修改的事务看到。假如并发交叉执行的事务没有任何控制，操纵相同的共享对象的多个并发事务的执行可能引起异常情况。

(4)持久性(Durability)

持久性意味着当系统或介质发生故障时，确保已提交事务的更新不能丢失。即一旦一个事务提交，DBMS保证它对数据库中数据的改变应该是永久性的，即对已提交事务的更新能恢复。持久性通过数据库备份和恢复来保证。

 

start transaction　　开启事物

start commit　　提交事物

start rollback　　回滚事物

 

eg：　　

from django.db import transaction

try:
    with transaction.atomic():
        pass
        # sql1
        # sql2
        """
            在事务中，尽量只写SQL语句， 业务逻辑代码写在事务外面(代码与SQL语句放在一起会增加查询时间)
            在with代码块中，写的所有的SQL语句都属于同一个事务
        """
except Exception as e:
    print(e)

 

ORM中常用的字段或者是方法

1. AutoFiled(primary_key=True, verbose_name='对字段进行解释，所有字段都有的')
2. CharField(max_length=32)
3. IntegerField()
4. DateField(auto_now=True, auto_now_add=True)
auto_now: 修改记录的时间
auto_now_add：第一次入库的时间
5. DataTimeField(auto_now=True, auto_now_add=True)
6. BooleanField()
7. EmailField()
8. ForeignKey()
9. OneToOneField()
10 ManyToMany()
11. DecamilField(max_digit=8, decimal_place=2)

 参数
unique： 唯一
db_index： 添加索引
default： 默认值
to：要关联的表
to_field:指定关联的字段
db_constraint：不再创建外键约束（当两个以外键相关联的表中，删除其中一张表的数据，对应另一个表的数据不受影响）

 

choices参数

就是针对可能列举完的数据，都适用于choices
eg：
　　gender:
　　　　男　　     1
　　　　女 　        2
　　　　其他 　　 3
　　学历：
　　　　小学　　      A
　　　　初中　     　 B
　　　　高中 　　     C
　　　　专科 　　     D
　　　　本科 　　     E
　　　　研究生 　　 F

 

实例：

在models.py中创建一个表

class User(models.Model):
    gender_choice = (
        (1, '男'),
        (2, '女'),
        (3, '其他'),
    )

    gender = models.IntegerField(choices=gender_choice, default=1)

搭建测试环境test.py,增加表数据，并利用choices参数查询使用

import os
import sys
if __name__ == "__main__":
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "day56.settings")
    import django
    django.setup()
    from app01 import models
# 创建四条数据
    models.User.objects.create(gender=1)
    models.User.objects.create(gender=2)
    models.User.objects.create(gender=3)
    models.User.objects.create(gender=4)
# 得到表主键值为4的对象
    res = models.User.objects.filter(pk=4).first()
# 调用方法得到表中的gender的值
    print(res.gender)

    """
        在获取值的时候，固定句式：get_字段名_display() => 
    """
# 固定语法取得gender值对应的数据
    print(res.get_gender_display())
# 上述实现方法也可以用下面方法
    # if res.gender == 1:
    #     gender = '男'
    # elif res.gender == 2:
    #     gender = '女'
    # else:
    #     gender = '其他'

多对多的三种创建方式

    1.全自动
    多对对的第一种创建方式
    优点：
        可以利用正反向查询概念，还可以利用 add, set, remove, clear()
    缺点：
        扩展性差
class Book(models.Model):
    title = models.CharField(max_length=32)
    authors = models.ManyToManyField(to='Author')


class Author(models.Model):
    name = models.CharField(max_length=32)

    2.纯手动
    多对对的第二种创建方式
    缺点：
        add, set, remove, clear()不能用
        不可以利用正反向查询概念
　　 优点：
        扩展性强

class Book(models.Model):
    title = models.CharField(max_length=32)
    authors = models.ManyToManyField(to='Author')


class Author(models.Model):
    name = models.CharField(max_length=32)


class Book2Author(models.Model):
    book_id = models.ForeignKey(to='Book')
    author_id = models.ForeignKey(to='Author')    

    3.半自动
    多对对的第三种创建方式
    特点：
        可以利用正反向的概念，但是不能用add, set, remove, clear()
　　 优点：
　　　　　扩展性强

class Book(models.Model):
    title = models.CharField(max_length=32)
    authors = models.ManyToManyField(to='Author',
                                     through='Book2Author', # 指定哪个表为第三张表
                                     through_fields=('book','author')  # 指定第三张表中所要关联的字段（注意：顺序是在哪张表中创建，哪个表所关联字段放在前面）
                                     )

class Author(models.Model):
    name = models.CharField(max_length=32)

　　# 在Author表中关联
    book = models.ManyToManyField(to='Book',
                                  through='Book2Author',  # 指定哪个表为第三张表
                                  through_fields=('author', 'book')
                                  )

class Book2Author(models.Model):
    book = models.ForeignKey(to='Book')
    author = models.ForeignKey(to='Author')
    create_time = models.DateField()

        特点：扩展性强

Ajax简介

特点，精髓：
　　1. 局部刷新，异步提交
eg:
　　github注册页面

AJAX 不是新的编程语言，而是一种使用现有标准的新方法。
AJAX 最大的优点是在不重新加载整个页面的情况下，可以与服务器交换数据并更新部分网页内容

AJAX使用JavaScript技术向服务器发送异步请求；
AJAX请求无须刷新整个页面；
因为服务器响应内容不再是整个页面，而是页面中的部分内容，所以AJAX性能高；

两个关键点:1.局部刷新，2.异步请求