2：django models Making queries

这是后面要用到的类

class Blog(models.Model):

    name = models.CharField(max_length=100)

    tagline = models.TextField()



    def __unicode__(self):

        return self.name



class Author(models.Model):

    name = models.CharField(max_length=50)

    email = models.EmailField()



    def __unicode__(self):

        return self.name



class Entry(models.Model):

    blog = models.ForeignKey(Blog)

    headline = models.CharField(max_length=255)

    body_text = models.TextField()

    pub_date = models.DateTimeField()

    mod_date = models.DateTimeField()

    authors = models.ManyToManyField(Author)

    n_comments = models.IntegerField()

    n_pingbacks = models.IntegerField()

    rating = models.IntegerField()



    def __unicode__(self):

        return self.headline

 

Creating objects

>>> from blog.models import Blog

>>> b = Blog(name='Beatles Blog', tagline='All the latest Beatles news.')

>>> b.save()

 

Saving ForeignKey and ManyToManyField fields

>>> from blog.models import Entry

>>> entry = Entry.objects.get(pk=1)

>>> cheese_blog = Blog.objects.get(name="Cheddar Talk")

>>> entry.blog = cheese_blog

>>> entry.save()

>>> from blog.models import Author

>>> joe = Author.objects.create(name="Joe")

>>> entry.authors.add(joe)

>>> 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)

 

Retrieving objects

>>> Blog.objects

<django.db.models.manager.Manager object at ...>

>>> b = Blog(name='Foo', tagline='Bar')

>>> b.objects

Traceback:

    ...

AttributeError: "Manager isn't accessible via Blog instances."

 

Retrieving all objects

>>> all_entries = Entry.objects.all()

 

filter(**kwargs)

Returns a new QuerySet containing objects that match the given lookup parameters.

exclude(**kwargs)

Returns a new QuerySet containing objects that do not match the given lookup parameters.

Entry.objects.filter(pub_date__year=2006)

Chaining filters

>>> Entry.objects.filter(

...     headline__startswith='What'

... ).exclude(

...     pub_date__gte=datetime.now()

... ).filter(

...     pub_date__gte=datetime(2005, 1, 1)

... )

 

get,get 方法会返回符合条件的那个元素，当没有符合筛选条件的元素是get方法会抛出一个 DoesNotExist的异常，所以要慎用

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

 

Field lookups

筛选属性的时候的一些限制条件，基本格式是 field__lookuptype=value，注意是双下划线，下面是lookuptype

exact：Exact match，准确匹配，可以匹配到null（None） iexact： 不区分大小写的准确匹配

contains：包含                                                        icontains：不区分大小写的包含

in：在（一个筛选的列表）里面

gt ：Greater than                                                    gte：Greater than or equal to.

lt：Less than.                                                          lte：Less than or equal to.

startswith，istartswith，endswith，iendswith

range：pub_date__range=(start_date, end_date))

year，month，day，weekday，

regex:正则表达式匹配，iregex，不区分大小写的

Aggregation functions

聚合函数，针对查询集合的一些操作

Avg：计算平均值，返回值类型float

Count：计算集合的元素个数，返回值类型int

Max，Min，Sum

高级操作

F类：我的理解是返回特定字段的值

例如我想找到所有评论比广播次数多的entry，就可以按照下面这样写

>>> from django.db.models import F

>>> Entry.objects.filter(n_comments__gt=F('n_pingbacks'))

 

F类返回的是该字段的值，当值是数值的是，可以做算术运算，当时字符串是，可以比较是否相等等运算

pk ：代表primary key

Q类：封装查询已形成更复杂的查询，每个Q查询之间可以用&（and）或者|（or）相连，用逗号相隔表示关系and，Q查询也可以使用~（not）

Poll.objects.get(

    Q(question__startswith='Who'),

    Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6))

)

#roughly translates into the SQL:

SELECT * from polls WHERE question LIKE 'Who%'

    AND (pub_date = '2005-05-02' OR pub_date = '2005-05-06')

 

注意：Q查询一定要在关键字查询之前，否则查询可能无效

关系查询

1：外键查询，一个类可以通过属性的方法来访问外键的类

>>> e = Entry.objects.get(id=2)

>>> e.blog = some_blog

>>> e.save()

 

2：一个被外键的类可以通过FOO_set的方法来访问源类，其中Foo是源类

>>> b = Blog.objects.get(id=1)

>>> b.entry_set.all() # Returns all Entry objects related to Blog.



# b.entry_set is a Manager that returns QuerySets.

>>> b.entry_set.filter(headline__contains='Lennon')

>>> b.entry_set.count()

 

3：其他的多对一，一对多，一对一的情况可以类比上面这两种情况

 如果你不想使用django提供的api接口，那么你可以通过下面两种方式直接运行sql语句

第一种，通过Manager.raw(raw_query, params=None, translations=None)的方法运行sql语句

class Person(models.Model):

    first_name = models.CharField(...)

    last_name = models.CharField(...)

    birth_date = models.DateField(...)

>>> Person.objects.raw('SELECT id, first_name, last_name, birth_date FROM myapp_person')

...

>>> Person.objects.raw('SELECT last_name, birth_date, first_name, id FROM myapp_person')

...

>>> Person.objects.raw('''SELECT first AS first_name,

...                              last AS last_name,

...                              bd AS birth_date,

...                              pk as id,

...                       FROM some_other_table''')

 

第二种：完全不用django提供的api，自己建立数据库连接，运行sql查询

def my_custom_sql():

    from django.db import connection, transaction

    cursor = connection.cursor()



    # Data modifying operation - commit required

    cursor.execute("UPDATE bar SET foo = 1 WHERE baz = %s", [self.baz])

    transaction.commit_unless_managed()



    # Data retrieval operation - no commit required

    cursor.execute("SELECT foo FROM bar WHERE baz = %s", [self.baz])

    row = cursor.fetchone()



    return row

 

 

 

 

 

 

 

 

 

 

p