Python_mysql增删改查

Django ORM操作数据库常用API
官方文档
https://docs.djangoproject.com/en/1.11/topics/db/queries/

1.models中构造数据表
每个字段定义时，都会有自己的一些特殊的选项指定
在大部分项目中，还会涉及到多表关联操作

class Play(models.Model):
date = models.CharField(max_length=255)
ischeck = models.TextField()
content = models.TextField()
userno = models.TextField()

    def __str__(self):              # __unicode__ on Python 2
        return self.name
class Blog(models.Model):
    name = models.CharField(max_length=100)
    tagline = models.TextField()

    def __str__(self):              # __unicode__ on Python 2
        return self.name

class Author(models.Model):
    name = models.CharField(max_length=200)
    email = models.EmailField()

    def __str__(self):              # __unicode__ on Python 2
        return self.name

class Entry(models.Model):
    blog = models.ForeignKey(Blog, on_delete=models.CASCADE)
    headline = models.CharField(max_length=255)
    body_text = models.TextField()
    pub_date = models.DateField()
    mod_date = models.DateField()
    authors = models.ManyToManyField(Author)
    n_comments = models.IntegerField()
    n_pingbacks = models.IntegerField()
    rating = models.IntegerField()

    def __str__(self):              # __unicode__ on Python 2
        return self.headline

2.执行命令就可生成数据库表

 python manage.py makemigrations
 python manage.py migrate

3.view中调用

def testModel(request):
     b = Blog(name='Beatles Blog',tagline='All the lastest Beatles news')
     b.save()
     return HttpResponse("hello world")

4.改变对象的值

 b5.name = 'New name'
 b5.save()

5.保存 ForeignKey 和 ManyToManyField 字段
现在，我们数据已经保存了，并已经建立了关联
在model中，Entry关联了外键Blog（ForeignKey ）
所以在创建Entry的时候，要先获取一个Blog对象，给Entry赋值之后，才执行保存数据库的操作

from blog.models import Blog, Entry
 entry = Entry.objects.get(pk=1)
 cheese_blog = Blog.objects.get(name="Cheddar Talk")
 entry.blog = cheese_blog
 entry.save()

6.更新ManyToManyField的工作方式略有不同，在字段上使用add()方法将记录添加到关系中。这个示例将Author实例joe添加到条目对象

from blog.models import Author
 joe = Author.objects.create(name="Joe")
 entry.authors.add(joe)

7.要一次性向ManyToManyField添加多条记录，请在add()调用中包含多个参数，如下所示

 john = Author.objects.create(name="John")
 paul = Author.objects.create(name="Paul")
 george = Author.objects.create(name="George")
 ringo = Author.objects.create(name="Ringo")
 entry.authors.add(john, paul, george, ringo)

8.取回数据
要从数据库检索对象，请通过模型类上的管理器构造一个QuerySet。QuerySet表示数据库中的对象集合。它可以有0个，1个或多个过滤器。过滤器根据给定的参数缩小查询结果。在SQL术语中，QuerySet等同于SELECT语句，过滤器是一个限制子句，例如WHERE或LIMIT。通过使用model s管理器可以获得一个查询集。每个模型至少有一个管理器，在默认情况下称为对象。直接通过model类访问它，如下所示

     Blog.objects
    
     b = Blog(name='Foo', tagline='Bar')
     b.objects
    Traceback:
        ...
    AttributeError: "Manager isn't accessible via Blog instances."
   # data = entry.authors.iterator()

注意：只有通过模型类才能访问管理器，而不是从模型实例访问管理器，以强制表级操作和记录级操作之间的分离。
9.查询所有数据

all_entries = Entry.objects.all()

10.按条件查询

filter(**kwargs) 返回一个新的匹配查询参数后的QuerySet

exclude(**kwargs) 返回一个新的不匹配查询参数后的QuerySet

Entry.objects.filter(pub_date__year=2006)

q2 = q1.exclude(pub_date__gte=datetime.date.today())

11.链接查询

Entry.objects.filter(headline__startswith='What')
.exclude(pub_date__gte=datetime.now())
.filter(pub_date__gte=datetime(2005, 1, 1))

12.延迟查询

创建QuerySets不会触及到数据库操作，你可以多个过滤合并到一起，直到求值的时候django才会开始查询

q = Entry.objects.filter(headline__startswith="What")
q = q.filter(pub_date__lte=datetime.now())
q = q.exclude(body_text__icontains="food")

13.检索单个对象

one_entry = Entry.objects.get(pk=1)

14.限制查询：分页/排序查询

Entry.objects.all()[:5]

Entry.objects.order_by('headline')[0:1].get()

15.字段查询

Entry.objects.filter(pub_date__lte='2006-01-01')

转换成SQL：

SELECT * FROM blog_entry WHERE pub_date <= '2006-01-01';

16.exact

Entry.objects.get(headline__exact="Man bites dog")

转换成SQL:

SELECT ... WHERE headline = 'Man bites dog';

17.iexact——忽略大小写

Blog.objects.get(name__iexact="beatles blog")

18.contains——包含查询，区分大小写

Entry.objects.get(headline__contains='Lennon')

转换成SQL:

SELECT ... WHERE headline LIKE '%Lennon%';

icontains 不区分大小写

startswith，endswith，istartswith，iendswith

19.连接查询

查询blog__name匹配的，返回Entry

Entry.objects.filter(blog__name__exact='Beatles Blog')

查询entry__headline匹配的，返回Blog

Blog.objects.filter(entry__headline__contains='Lennon')

如果跨越多层关系查询，中间模型没有值，django会作为空对待不会发生异常

Blog.objects.filter(entry__author__name='Lennon');
Blog.objects.filter(entry__author__name__isnull=True);
Blog.objects.filter(
entry__author__isnull=False,
entry__author__name__isnull=True);

20.F对象，对字段进行操作。就像SQL中，A列+B列。F对象很少用

from django.db.models import F
Entry.objects.filter(n_pingbacks__lt=F('n_comments'))

列加减乘除都可以

Entry.objects.filter(n_pingbacks__lt=F('n_comments') * 2) 
Entry.objects.filter(rating__lt=F('n_comments') + F('n_pingbacks')) 
Entry.objects.filter(author__name=F('blog__name'))
16.like语句转义百分号

Entry.objects.filter(headline__contains='%')

转义为：

SELECT ... WHERE headline LIKE '%\%%';

21.删除

q = Entry.objects.filter(headline__startswith="What")

q.delete()

22.批量修改

Entry.objects.filter(pub_date__year=2007).update(headline='Everything is the same')

一次性修改所有的Entry的blog属性指向

b = Blog.objects.get(pk=1)

Entry.objects.all().update(blog=b)

update也可以使用F()

Entry.objects.update(headline=F('blog__name'))

23.One-to-many关系

    e = Entry.objects.get(id=2)
    print e.blog # Hits the database to retrieve the associated Blog
    
    e = Entry.objects.select_related().get(id=2)
    print e.blog # 不会在向数据库取; 使用缓存中的值.
    
    b = Blog.objects.get(id=1)
    b.entry_set.all() # 返回所有blog的关联对象.
 b.entry_set is a Manager that returns QuerySets.
b.entry_set.filter(headline__contains='Lennon')
b.entry_set.count()

b = Blog.objects.get(id=1)
b.entries.all() # 返回所有blog的关联对象
 b.entries is a Manager that returns QuerySets.
b.entries.filter(headline__contains='Lennon')
b.entries.count()

 
add(obj1, obj2, ...) 把多个对象建立连接

create(**kwargs) 建立新对象

remove(obj1, obj2, ...) 移除多个关系对象

clear() 清理所有关系对象

24.Many-to-many关系

e = Entry.objects.get(id=3)
e.authors.all() # 返回Entry所有authors 
e.authors.count()
e.authors.filter(name__contains='John')

a = Author.objects.get(id=5)
a.entry_set.all() # 返回Author所有entry

25.One-to-one关系

要在定义模型的时候设置

class EntryDetail(models.Model):
entry = models.OneToOneField(Entry)
details = models.TextField()

ed = EntryDetail.objects.get(id=2)
ed.entry # 返回 Entry 对象.