Django 数据库查询集合(双下划线连表操作)

 Django是一款优秀的web框架，有着自己的ORM数据库模型。在项目中一直使用django数据库，写一篇文章专门记录一下数据库操作。略写django工程创建过程，详写查询过程。可以和sqlalchemy对比来看，会发现有很多相同的地方，例如外键，外键关联关系等。上一篇sqlalchemy查询文章

目录：

1.Django环境搭建

2.数据库建表

3.写入数据

4.查询语句

Django环境搭建

1.安装django

pip install django

2.创建工程

django.admin project myself

3.创建app

python manage.py create sql_train

4.设置setting文件

将应用sql_train加入到app中

修改数据库连接方式

将默认的sqlite3数据库修改成mysql数据库

如果没有安装过mysql数据库，先安装mysql，然后安装mysqldb驱动

添加url映射

2 创建表结构

from __future__ import unicode_literals

from django.db import models

class Student(models.Model):
     id = models.IntegerField(primary_key=True)
     name = models.CharField(max_length=20)

class Family(models.Model):
    id = models.IntegerField(primary_key=True)
    member = models.CharField(max_length=20)
    stu_id = models.ForeignKey(Student,related_name='student')

class House(models.Model):
    id = models.IntegerField(primary_key=True)
    location = models.CharField(max_length=100)
    family_id = models.ForeignKey(Family,related_name='family')


class Cars(models.Model):
    id = models.IntegerField(primary_key=True)
    name = models.CharField(max_length=100)
    Family = models.ForeignKey(Family,related_name='family_to_car')

表结构：

Student是主表

Family是从表，有一个外键stu_id连接到Student

House是Family的从表 有一个外键family_id连接到Family

Cars是Family的从表，有一个外键Family连接到Family

 

在应用sql_train中的models.py中创建四张表结构，分别是：Student,Family,House,Cars。使用如下命令将表结构创建在mysql数据库中

python manage.py migrate

写入数据

#coding:utf-8

from django.shortcuts import render
from django.http import HttpResponse
from models import Student,Family,House,Cars
from django.db import models
from django.db.models import Q

def sql(request):

    create_value()
    #select_compex()

    return HttpResponse('hello')


def create_value():


    # Student.objects.create(id=1,name='悟空')
    # Student.objects.create(id=2,name='贝吉塔')
    # Student.objects.create(id=3,name='比克')
    # Student.objects.create(id=4,name='天津饭')

    # Student.objects.create(id=6,name='库林')
    # Student.objects.create(id=7,name='18号')
    # Student.objects.create(id=8,name='饺子')


   
    # Family.objects.create(id=1,member=4,stu_id=Student.objects.get(id=1))
    # Family.objects.create(id=2,member=6,stu_id=Student.objects.get(id=2))
    # Family.objects.create(id=3,member=9,stu_id=Student.objects.get(id=3))
    # Family.objects.create(id=4,member=5,stu_id=Student.objects.get(id=4))

    # House.objects.create(id=1,location='地球',family_id=Family.objects.get(id=1))
    # House.objects.create(id=2,location='贝吉塔星',family_id=Family.objects.get(id=2))
    # House.objects.create(id=3,location='那美克星',family_id=Family.objects.get(id=3))
    # House.objects.create(id=4,location='地球',family_id=Family.objects.get(id=4))

    Cars.objects.create(id=1,name='筋斗云',Family=Family.objects.get(id=1))
    Cars.objects.create(id=2,name='引力',Family=Family.objects.get(id=2))
    Cars.objects.create(id=3,name='意念',Family=Family.objects.get(id=3))
    Cars.objects.create(id=4,name='翅膀',Family=Family.objects.get(id=4))

有外键关联的数据，插入数据时是插入整个外键的对象。例如：Family的外键关联到Student，Family表中的stu_id要填入对应的Student的对象。

查询语句

def select_compex():
    
    #普通查询语句
    # result_one = Student.objects.all()

    #过滤
    # result_two = House.objects.filter(id=3)

    
    #related_name,外键字段使用
    #通过Student查询到Family的数据
    # result_three = Student.objects.get(id=2)
    # result_four = result_three.student.all()

    # result_three = Student.objects.get(id=2)
    # result_four = result_three.student.all()

    django数据库双下划线操作。
    django数据库中没有连表的操作，没有sqlalchemy中的join操作，它使用了一种更简洁的操作‘__’ ,双下划线。
    使用双下划线可以完成连表操作，可以正向查询，也可以反向查询。
    
    # Student <----- Family <------ House
                       |
                       |----------- Cars 

    #正向查询一层
    #查询Family表，约束条件是Student表中的姓名是 ‘悟空’
    # result_seven = Family.objects.filter(stu_id__name='悟空')
    
   
    #正向查询两层
    #查询House表，约束条件是Student表中的name是 悟空
    # result_eight = House.objects.filter(family_id__stu_id__name='悟空')

    #反向查询一层
    #查询Student表，约束关系是Family表中的 id 是 1
    # result_five = Student.objects.filter(student__id=1)
    # for x in result_five:
    #     print x.id,x.name


    #反向查询两层
    #查询student表，约束关系是House表中的 id 是 3
    #  Student  <----- Family  <------ House 
    #  两个技巧，一、反向查询  二、两层操作
    # result_six = Student.objects.filter(student__family__id=3)
    # for x in result_six:
    #     print x.id,x.name

    '''


    #正反向混合查询 
    House表和Car表的外键同时指定到Family；查询House表，约束条件是car表中的name字段为 筋斗云。
    # result_fiveteen = House.objects.filter(family_id__family_to_car__name='筋斗云') 


    # result_six = Student.objects.filter(id=3)
    # result_eight = Student.objects.get(id=3)
    # result_nine = Student.objects.all()

    #and和or查询

    #and查询
    #与查询，并列查询，直接将条件全部都写在查询括号中就可
    # result_ten = House.objects.filter(location='地球',id=1)
    
    #or查询
    #django的查询语句的或运算没有sqlalchemy中的or关键字，这里是使用了关键字Q，使用Q将查询语句包裹，然后使用 | 连接，完成或查询。
    # result_eleven = House.objects.filter(Q(location='地球')|Q(id=1))

    #or查询
    # result_twenty = House.objects.filter(Q(location='地球')|Q(id=1)|Q(id=3))


    #排除字段
    #exclude不等于，即排除这个条件其他都查询出来。例如：查询Family中id不等于1的
    # result_thirteen = Family.objects.exclude(id=1)


    #offset和limit
    #Django中没有sqlalchemy里切片的关键字offset和limit。可以直接使用类似python中切片的操作[]。
    # result_foutteen = Student.objects.all()[2:4]


    #精确查询
    #exact精确匹配，区分大小写
    #iexact精确匹配，不区分大小写
    result_sixteen = Student.objects.filter(name__iexact='空')

    #模糊查询
    #contains模糊查询码，区分大小写
    #icontains模糊查询，不区分大小写
    result_seventeen = Student.objects.filter(name__contains='K')
    result_seventeen = Student.objects.filter(name__contains='K')



    filter和all查询出来都是列表，QuerySet类型的数据。QuerySet是一个可遍历结构，包含一个或多个元素，每个元素都是一个Model 实例 QuerySet类似于Python中的list 
    get查询出来是对象。


    for x in result_seventeen:
        print x.id,x.name

    print '查询长度'
    print result_seventeen.count()