'''
1. 手动创建数据库
2. 在settings.py里面配置一下数据库的连接信息（告诉Django连接哪一个数据库）
    DATABASES = {
        'default': {
            'ENGINE': 'django.db.backends.mysql',  # 连接数据库的类型
            'NAME': 'day62xiawu',  # 数据库名字
            'HOST': '127.0.0.1',  # IP
            'PORT': 3306,  # 端口
            'USER': 'root',  # 用户名
            'PASSWORD': '123456',  # 密码
        }
    }
3. 在和settings.py同目录下的__init__.py文件中，告诉Django用pymysql代替MySQLdb来连接数据库
    import pymysql
    pymysql.install_as_MySQLdb()
4. 在app/models.py中，定义类，类一定要继承models.Model
    class Book(models.Model):
        id = models.AutoField(primary_key=True)
        title = models.CharField(max_length=32)
5. 执行两条命令
    1. 在哪儿执行？
        在项目的根目录（有manage.py文件的那个目录）
    2. 命令
        python manage.py makemigrations   --> 将models.py文件中的改动记录在小本本（app/migrations/00xx_****.py）上
        
        python manage.py migrate           --> 将改动翻
'''

'''

1.AutoField 
    int自增列，必须填入参数 primary_key=True 没有自增列，则自动会创建一个列名为id的列。
    因此在创建表的时候id不写，也能创建成功，默认创建一个id字段
    id=models.AutoField(primary_key=True)
2.IntegerField(10位的长度）
    整数类型,范围在 -2147483648 to 2147483647。
    使用IntegerField类型不能存手机号，手机号是11位。用来存age
    BigIntegerField（19位）可以用来存手机号

3.CharField：表示varcharage=models.IntegerField()
    字符类型，必须提供max_length参数， max_length表示字符长度。
    name=models.CharField(max_length=255)
4.DecimalField 10进制小数
        参数：max_digits，小数总长度
            decimal_places，小数位长度
5.自定义char类型字段：
    class FixedCharField(models.Field):
        """
        自定义的char类型的字段类
        """
        def __init__(self, max_length, *args, **kwargs):
            self.max_length = max_length
            super(FixedCharField, self).__init__(max_length=max_length, *args, **kwargs)

        def db_type(self, connection):
            """
            限定生成数据库表的字段类型为char，长度为max_length指定的值
            """
            return 'char(%s)' % self.max_length
    class Class(models.Model):
        id = models.AutoField(primary_key=True)
        title = models.CharField(max_length=25)
        # 使用自定义的char类型的字段
        cname = FixedCharField(max_length=25)
6.DateField 日期字段，日期格式  YYYY-MM-DD 相当于Python中的datetime.date()实例
    DateTimeField 日期时间字段，格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]  相当于Python中的datetime.datetime()
    DateField和DateTimeField有两个属性：
    1. auto_now_add=True，创建数据记录的时候会把当前时间添加到数据库。相当于人的生日
    2.auto_now=True，每次更新数据记录的时候会更新该字段
    不能同时用，一般都设置auto_now_add=True
    birthdy=models.DateField(auto_now_add=True)
    在表中添加数据时需要手动添加birthday 在create创建时，不用添加birthday，会自动添加
7.datetime.timedelta类型
    求失效的时间
    import datetime
    now=datetime.datetime.now()
    print(now)
    #有效其七天
    d7=datetime.timedelta(days=7) #也可以weeks，不能years 一年52周
    ret=now+d7
    print(ret)
8.FileField 文件类型
    绑定上传的文件到表单,后台接收request.FIlES
    为了上传文件,需要确保你的<form> 元素正确定义enctype 为"multipart/form-data"：
    <form enctype="multipart/form-data" method="post" action="/foo/">
    avatar = models.FileField(upload_to="avatars/", default="avatars/default.png", verbose_name="头像")
    def upload(request):
        if request.method=="POST":
            file_obj=request.FIlES.get('upload_file')
            filename=file_obj.name
        with open(filename,"wb") as f:
            for line in file_obj:
                 f.write(line)
            return HttpResponse("上传成功")
        return render(request,"upload.html")

'''

一个班级中有多个学生，学生是多的一方
class Classes(models.Model):
    name = models.CharField(max_length=32)
class Student(models.Model):
    name = models.CharField(max_length=32)
    the_class = models.ForeignKey(to="Classes")
正向查询：student_obj=models.Student.objects.filter(pk=1).first()
print(student_obj.the_class.name) 
反向查询：表名_set 查询某个班级关联的所有学生：models.Classes.objects.first().student_set.all() 
在ForeignKey字段中添加了参数 related_name 后 the_class = models.ForeignKey(to="Classes", related_name="students") models.Classes.objects.first().students.all() 
4.on_delete 当删除关联表中的数据时，当前表与其关联的行的行为 
models.CASCADE 删除关联数据，与之关联也删除
publisher = models.ForeignKey(to="Publisher",on_delete=models.CASCADE) 
models.SET_NULL 删除关联数据，与之关联的值设置为null
# 表示外键关联到作者表,当作者表删除了该条数据,图书表中不删除,仅仅是把外键置空 
author = models.ForeignKey(AuthModel, null=True, blank=True, on_delete=models.SET_NULL)

 models.SET_DEFAULT 删除关联数据，与之关联的值设置为默认值 models.SET 删除关联数据，
 a. 与之关联的值设置为指定值，设置：models.SET(值) b. 与之关联的值设置为可执行对象的返回值，
设置：models.SET(可执行对象) publisher = models.ForeignKey(to="Publisher",on_delete=models.SET(10)

class Person(models.Model):
    id=models.AutoField(primary_key=True)
    name=models.CharField(max_length=255)
    detail=models.OneToOneField(to="PersonDetail")
class PersonDetail(models.Model):
    age=models.IntegerField()
    addr=models.TextField()
正向查询：
egon=models.Person.objects.filter(name="egon").first()
print(egon.detail.age)
反向查询：
authorDetail_list=models.PersonDetail.objects.filter(addr="beijing")
for obj in authorDetail_list:
     print(obj.person.name)

class Person(models.Model):
    name = models.CharField(max_length=16)
    friends = models.ManyToManyField("self")

class Person(models.Model):
    name = models.CharField(max_length=16)
    friends = models.ManyToManyField("self", symmetrical=False db_table="表名"

class Author(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=16, null=False, unique=True)
    # 告诉ORM 我这张表和book表是多对多的关联关系,ORM自动帮我生成了第三张表
    book = models.ManyToManyField(to="Book" related_name="books" )
正向查询：
book_obj=Book.objects.filter(title="后来的我们").first()
authors=book_obj.authors.all()
for author_obj in authors:
     print(author_obj.name,author_obj.authorDetail.telephone)
反向查询：
author_obj=Author.objects.get(name="egon")
book_list=author_obj.book_set.all()        #与egon作者相关的所有书籍
book_list=author_obj.books.all() 添加related_name="books"
for book_obj in book_list:
    print(book_obj.title)

1.查询数据:
方式1:get-------Obj 得到具体对象
obj=models.Publisher.objects.get(id=1)
方式2:filter---->Queryset
obj=models.Publisher.objects.filter(id=1).first()
2.添加数据:
方式1:create
    obj=Book.objects.create()
方式2:save
    obj=Book(title="A")
    obj.save()
    或者:obj=Book()
    book.title="A"
    book.save()
3.修改数据:
    queryset=models.Publisher.object.filter(id=1)
    obj=models.Publisher.object.get(id=1)
    方式1：update------->调用的对象必须是queryset
    queryset.update(price=100)
    或者:queryset.update(**{"price":100})
    方式2:Obj---->使用对象
    obj.name=new_name
    obj.save()
4.删除数据：delete
queryset和obj均可使用
    queryset.delete()
    model_obj.delete()
models.Publisher.objects.get(id=1).delete()

改：book_obj=models.Book.objects.get(id)
    book_obj.name 是书的名字。是一个属性
    book_obj.publisher_id 是和书关联的出版社id值，是书的一个自身属性
    book_obj.publisher 是和书关联的出版社对象。是一个对象
    book_obj.publisher.id 出版社的id
    book_obj.publisher.name  出版社的名字

book表中内容：
id   name  publish_id   
 1      A       1
 2      B       2
方法1：绑定关联的id值
book_obj=Book(title="A",publish_id=1)
book.save()
方法2：绑定关联的对象
book_obj=Book(title="A",publish=publish_obj) 
book.save()
方法3:
    book=Book()
    book.title="A"
    book.publish=publish_obj
    book.save()

绑定多对多的关系
book_authors
    id   book_id  author_id   
     1      1        1
     2      1        2
     3      1        3
1.查询id为1的作者写哪些书
    author_obj=models.Author.objects.get(id=1)
    author_obj.books.all() 和作者关联的所有书对象（这些对象包括书的id，书名等信息） 
2.书籍绑定作者:add
    book_obj=Book.objects.filter(pk=1).first()
    方式1：
        book_obj.authors.add(1)
        添加多个作者:
        book_obj.authors.add(1,2,3,4)
        或者:
        book_obj.authors.add(*[1,2,3,4])
    方式2：添加作者对象
        author_obj=Author.objects.get(pk=1)
        book_obj.authors.add(author_obj)
3.书籍移除作者：remove
    方式1：
    book_obj.authors.remove(1)
    移除多个作者：
    book_obj.authors.remove(2,3)
    或者：
    book_obj.authors.remove(*[2,3])
4.书籍清空作者:clear
     book_obj.authors.clear()

1.增加
在为书籍添加作者的时候，书籍已经创建。新建作者，然后显示出书籍列表，为其选择
在处理函数时，获取作者或关联的书籍，书籍是多选的不能用get获取
author=request.POST.get("author")
# 书籍选择是多选的，不能用get，使用getlist
books = request.POST.getlist("book")
# 创建作者
new_author_obj = models.Author.objects.create(name=author)
# 把新作者和书籍建立对应关系,自动提交
new_author_obj.books.set(books)
author_obj.books.set([1,2,3]) 把id是1、2、3的书和我这个作者关联上
2.编辑时，修改完书籍直接使用set赋新值
book_id = request.POST.getlist("books")
author_obj=models.Author.objects.get(id=author_id)
author_obj.name=author_name
author_obj.books.set(book_id)
author_obj.save()

 student_course
    id    student_id      course_id
    1         1              1

 class Student():
         name=....
         courses=models.ManyToManyFiled(to="Course",through="student_course")
     class student_course():
         student
         course
         score

约会网站 记录约会时间
###约会记录##
# 男孩1 女孩1
# 男孩2 女孩2
# 男孩3 女孩3

class Boy(models.Model):
    name=models.CharField(max_length=32)
    def __str__(self):
         return self.name
class Girl(models.Model):
    name=models.CharField(max_length=32)
    #through_fields("field1","field2") 多对多建在建在哪张表，field1就是这个表的名字 field2是目标表的名字
    boys=models.ManyToManyField(to=Boy,through="Info",through_fields=("girl","boy"))  #顺序不能颠倒
    def __str__(self):
         return self.name
class Info(models.Model):
    boy=models.ForeignKey(to=Boy)
    girl= models.ForeignKey(to=Girl)
    date=models.DateField(auto_now_add=True)

class Book(models.Model):
 time_choices = (
        (1, '8:00'),
        (2, '9:00'),
        (3, '10:00'),
        (4, '11:00'),
        (5, '12:00'),
        (6, '13:00'),
        (7, '14:00'),
        (8, '15:00'),
        (9, '16:00'),
        (10, '17:00'),
        (11, '18:00'),
        (12, '19:00'),
        (13, '20:00'),
    )
    time_now = models.IntegerField(choices=time_choices)