python sqlalchemy 和django orm 对比

表和表的之间关系，往往通过外键建立关系，那简单介绍下外键。

一：DB角度上的上外键含义：

主键：主键是唯一标识一条记录，不能重复，有唯一性约束，不可以为空。用来保证数据的完整性，我们常用自增id来创建主键。

外键：是另一张表的主键或者带有唯一性约束的列，外键可以重复，可以为空，主要作用：用他来和其他的表建立逻辑关系。所以当我们谈到外键的时候最少涉及到2张表。

比如：

部门表dept 和员工表emp。emp表中的Dept_id就是外键，和dept表单的主键id关联。

因为一个部门多个员工，所以员工需要在知道自己归属的部门，所以emp是子表而dept是父表。

外键一定是从表中建立的，从而和主表建立关系，从表维护二者的关系。

使用外键的条件：

• 1、两张表必须都是InnodeDB表，并且没有临时表。
• 注：InnodDB是数据库引擎。mysql常见的数据库引擎：innodeDBhe 和MySIAM,而MySIM不支持外键约束！！！
• 2、建立外键关系的对应列必须有具有相似的InnoDB内部数据类型。
• 3、建立外键关系的对应列必须建立了索引，

二：从python角度理解：

在python中通过关系映射（orm），调用底层dbapi来实现数据库的操作。通过定义类和对象，（类是表，类的对象是数据库的一行数据。）来操作数据库，通过底层的转换，最终形成sql，在相应的数据库中执行。

notice：

1. 无论是python通过orm（sqlalchemy和django的orm）来创建表，通过定义字段使表与表建立关系，比如外键。python层面定义的外键作用到数据库中，也是形成相应的外键。
2. 所以无论哪种的orm建立的表结构，外键都是在子表中，可以理解成外键在多对一中“多”的字段中。
3. 在数据库中，外键是建立在子表中。建立外键的列是另一张的表的主键。所以python设置外键的表是固定的。对应的“一对多”的“多”表中建立外键。

A：django的orm：

一对多：

比如说：作者和书籍的关系，一个作者有多本书，构成一对多的关系。

modles结构：

class Author(models.Model):
    username=models.CharField(max_length=32)
class Book(models.Model):
    name=models.CharField(max_length=32)
    b_author=models.ForeignKey('Author')

 

插入数据：通过访问相应的url插入数据

def insert(request):
    models.Author.objects.create(username="tom")
    return HttpResponse('ok')

def insert(request):
    models.Book.objects.create(name='唐吉坷德',b_author_id=1)
    return HttpResponse('ok')

数据库本质的插入。

查询：

1、正向查询：

通过双下划线来操作。

比如：百年孤独的作者的名字是谁？

def insert(request):
    ret=models.Book.objects.filter(name="百年孤独").values("b_author__username")
    print(ret)
    return HttpResponse('ok')
<QuerySet [{'b_author__username': 'tom'}]>

反向查询：一对多也支持反向查询。方法有2个。一个是通过双下划线，一个通过tablename_set字段哎查询，查询的方式不一样，方法也不一样！！！

• 通过tablename_set来反向查询，但是在这种查询，方法和manytomany 操作第三章表类似。

需求：查看tom都出 那些书，书的名字是什么？

def insert(request):
    obj=models.Author.objects.filter(username='tom').first()
    ret=obj.book_set.all()
    for i in ret:
        print(i.name)
    return HttpResponse('ok')

百年孤独
唐吉坷德

• 通过双下滑线反向查询：

def insert(request):
    booklist=models.Author.objects.filter(username='tom').values('book__name')
    print(booklist)
    return HttpResponse('ok')
<QuerySet [{'book__name': '百年孤独'}, {'book__name': '唐吉坷德'}]>

notice：

• 无论正向查询还是反向查询，都可以用双下划线。
• 反向查询的时候，因为对应的是“一”，所以查询的结果需要单个对象，然后查询对应“多”的表的对象集合。而使用set的字段的时候，需要注意使用的方法都是all、filter等。

对于多对多情况，正向查询的时候，使用的的是双下划线，反向查询是用含有manytomany的字段的“表”名的隐藏的列的进行反向查询。也是利用双下划线。

表结构：一个服务器有多个用户，一个用户在存在于多个服务器中。

class Host(models.Model):
    ip=models.CharField(max_length=32)
    hostname=models.CharField(max_length=32)

class User(models.Model):
    username=models.CharField(max_length=32)
    password=models.CharField(max_length=32)
    user_host=models.ManyToManyField('Host')#注意引号的作用，如果没有引号的话，关联的表必须在当前表的前面，否则报错。

插入数据：

def insert(request):
    for i in range(4):
        models.Host.objects.create(ip='172.17.33.'+str(i),hostname=str(i)+'.com')
    return HttpResponse('ok')

def insert(request):
    for i in range(4):
        models.User.objects.create(username='evil'+str(i),password=str(i)+'123')
    return HttpResponse('ok')

• 需要注意：当我们在给含有ManyToMany的表进行插值的时候，对于字段：user_host=models.ManyToManyField('Host')，不需要插值。该列只是关联第三张关系表：mod_user_user_host。实质该列在数据库并不存在该列。

第三张表（mod_user_user_host）进行插值：第三张表存储在django层面来看是对象，实际在数据库中存储的是这2张表（host、user）的主键值。所以插入值的方法也有2种。

正向插入值：

def insert(request):
    res=models.User.objects.filter(id=3).first()
    ret=models.Host.objects.filter(id__gt=2)
    res.user_host.add(*ret)
    return HttpResponse('ok')

 

反向插入值，反向插入值，用另一张表名_set.add()方法来操作。

def insert(request):
    res=models.Host.objects.filter(id=1).first()
    ret=models.User.objects.filter(id__lt=4)
    res.user_set.add(*ret)
    return HttpResponse('ok')

 

当然相应的查询方法，也可以 用_set字段或者表名进行查询，和一对多是一样的。唯一区别是：更新第三张表的时候，最好用原生sql进行更新。

B：sqlalchemy的orm

• 对于一对多或者多对多的情况下,在sqlalchemy中使用的是relationship()来创建一个数据库中并不存在的列来构建2个表之间的关系。
• 需要注意的：在django中建立外键，直接类的名字既可，在sqlalchemy中需要写：表的名字.主键列的名字。

表结构：比如主机和主机用户来构建多对多表结构

class Host(Base):
    __tablename__='host'
    nid=Column(Integer,autoincrement=True,primary_key=True)
    hostname=Column(String(32))
    ip=Column(String(32))

class system_User(Base):
    __tablename__='system_user'
    nid=Column(Integer,autoincrement=True,primary_key=True)
    username=Column(String(32))
    password=Column(String(32))

class Host_to_system_User(Base):
    __tablename__='host_to_system_user'
    nid=Column(Integer,primary_key=True,autoincrement=True)
    host_nid=Column(Integer,ForeignKey('host.nid'))
    system_user_nid=Column(Integer,ForeignKey('system_user.nid'))#需要注意这个和django不一样，django直接写类名字既可。
    host=relationship('Host',backref='ho')
    system_user=relationship('system_User',backref='sys_u')
Base.metadata.create_all(engine)##执行该函数，他就会执行所有Base所有的子类。调用我们定义类并创建相应的表结构。
Session=sessionmaker(engine)
session=Session()#创建数据库连接。可以理解为django的db模块中connection。

 

插入数据：2张表正常插入值和django一样，不需要关注第三张表，当需要建立关系的时候，直接给第三张表插入相应的id值既可。

Session=sessionmaker(engine)
session=Session()#创建数据库连接。可以理解为django的db模块中connection。
host_obj=Host(hostname='c1.com',ip='172.17.22.12')
host_obj_1=Host(hostname='c2.com',ip='172.17.22.13')
host_obj_2=Host(hostname='c3.com',ip='172.17.22.14')
session.add_all(
        [
            host_obj,
            host_obj_1,
            host_obj_2
        ]
)
system_user_obj=system_User(username='evil',password='123')
system_user_obj_1=system_User(username='tom',password='123')
system_user_obj_2=system_User(username='jack',password='123')
session.add_all(
        (
            system_user_obj,
            system_user_obj_1,
            system_user_obj_2
        )
)
#
host_to_system_user_obj=Host_to_system_User(host_nid=1,system_user_nid=1)
host_to_system_user_obj_1=Host_to_system_User(host_nid=1,system_user_nid=2)
host_to_system_user_obj_2=Host_to_system_User(host_nid=1,system_user_nid=3)
host_to_system_user_obj_3=Host_to_system_User(host_nid=2,system_user_nid=1)
host_to_system_user_obj_7=Host_to_system_User(host_nid=2,system_user_nid=2)
host_to_system_user_obj_4=Host_to_system_User(host_nid=2,system_user_nid=3)
host_to_system_user_obj_5=Host_to_system_User(host_nid=3,system_user_nid=1)
host_to_system_user_obj_6=Host_to_system_User(host_nid=3,system_user_nid=2)
session.add_all(
    [
        host_to_system_user_obj,
        host_to_system_user_obj_1,
        host_to_system_user_obj_2,
        host_to_system_user_obj_3,
        host_to_system_user_obj_4,
        host_to_system_user_obj_5,
        host_to_system_user_obj_6,
        host_to_system_user_obj_7
    ]
)
session.commit()

 

mysql> select * from  host;
+-----+----------+--------------+
| nid | hostname | ip           |
+-----+----------+--------------+
|   1 | c1.com   | 172.17.22.12 |
|   2 | c2.com   | 172.17.22.13 |
|   3 | c3.com   | 172.17.22.14 |
+-----+----------+--------------+
3 rows in set (0.00 sec)

mysql> select * from  system_user;
+-----+----------+----------+
| nid | username | password |
+-----+----------+----------+
|   1 | evil     | 123      |
|   2 | tom      | 123      |
|   3 | jack     | 123      |
+-----+----------+----------+
3 rows in set (0.00 sec)

mysql> select * from host_to_system_user;
+-----+----------+-----------------+
| nid | host_nid | system_user_nid |
+-----+----------+-----------------+
|   1 |        1 |               1 |
|   2 |        1 |               2 |
|   3 |        1 |               3 |
|   4 |        2 |               1 |
|   5 |        2 |               3 |
|   6 |        3 |               1 |
|   7 |        3 |               2 |
|   8 |        2 |               2 |
+-----+----------+-----------------+
8 rows in set (0.00 sec)

 

查询：

需求：用户evil 都在哪些服务器上？

分析：首先通过system_user查到evil的对象，通过该对象获取sys_u的列，这个列是第三张表的对象的集合，通过循环该列获取每列的我们建立的host关系列来获取对应的host表的属性值。也就是说先反向查询在正向查询。

ret=session.query(system_User).filter(system_User.username=='evil').first()
for i in ret.sys_u:
    print(i.host.ip)

 

172.17.22.12
172.17.22.13
172.17.22.14

 

django orm和sqlalchemy的orm的对比：

• 在django中orm中插入和查询的时候，使用是类中定义数据库的列的名字，而在sqlalchemy中使用的调用数据库的字段是对象的属性字段。

django：

modle：

class Person(models.Model):
    username=models.CharField(max_length=32)

class Fav(models.Model):
    name=models.CharField(max_length=32)
    per_fav=models.ForeignKey('Person')

查询语句：

比如查询名字为evil的爱好都有哪些：

def insert(request):
    ret=models.Fav.objects.filter(per_fav__username='evil').values('name')
    print(ret)
    return HttpResponse('ok')

其中查询的字段并没有对象.字段属性。而sqlalchemy在调用表的字段的字段的时候，需要使用类.字段(其中字段属于类的静态字段。)

sqlalchemy：

from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index#导入列数据类型字段。
from sqlalchemy.orm import sessionmaker, relationship#导入会话函数、
from sqlalchemy import create_engine
engine = create_engine("mysql+pymysql://root:@192.168.31.222:3306/django", max_overflow=15)#创建数据库引擎，通过连接池获取数据库的连接。数据库连接池数量为：15，默认值是5.
#创建sqlorm基类。（为声明的类定义基类。）
Base = declarative_base()
class User(Base):
    __tablename__='user'
    nid=Column(Integer,primary_key=True,autoincrement=True)
    username=Column(String(32))

    def __repr__(self):
        temp='%s-%s'%(self.nid,self.username)
        return temp
Base.metadata.create_all(engine)##执行该函数，他就会执行所有Base所有的子类。调用我们定义类并创建相应的表结构。

插入数据：

Session=sessionmaker(engine)
session=Session()#创建数据库连接。可以理解为django的db模块中connection。
user_obj=User(username='evil')#创建类的对象。
user_obj1=User(username='tom')
user_obj2=User(username='jack')
session.add_all(
        (
            user_obj,
            user_obj1,
            user_obj2
        )
)
session.commit()#提交数据库事务。

 

mysql> select *from user;
+-----+----------+
| nid | username |
+-----+----------+
|   1 | evil     |
|   2 | tom      |
|   3 | jack     |
+-----+----------+
3 rows in set (0.00 sec）

查询数据库：

Session=sessionmaker(engine)
session=Session()#创建数据库连接。可以理解为django的db模块中connection。
ret=session.query(User).filter(User.nid>1).all()
print(ret)
[2-tom, 3-jack]

对比：

• 数据库连接：django在创建项目的时候在setting配置文件中需要配置数据库的连接串，默认使用数据库是sqlite。

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
    }
}

• sqlalchemy 需要导入相应的模块，然后建立相应的连接引擎和数据库的连接池。每次执行数据库操作的时候都需要创建连接对象。而django默认帮我们做数据库连接。

from sqlalchemy import create_engine
engine = create_engine("mysql+pymysql://root:@192.168.31.222:3306/django", max_overflow=15)#创建数据库引擎，通过连接池获取数据库的连接。 

• django在创建数据库的时候，创建表的类的时候需要继承(models.Model)而sqlalchemy需要继承一个基类：Base = declarative_base()
• 在django如果不指定主键的时候，django默认会创建一个名为:id的自增列。而sqlalchemy需要手动指定自增列和主键。
• 默认在django中表明是类名的小写，而在sqlalchemy中必须要指定__tablename__字段，指定数据库的表的名字否则报如下错误信息。

sqlalchemy.exc.InvalidRequestError: Class <class '__main__.User'> does not have a __table__ or __tablename__ specified and does not inherit from an existing table-mapped class.

django：

from django.db import models

# Create your models here.
class Person(models.Model):
    username=models.CharField(max_length=32)

 sqlalchemy：

from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index  # 导入列数据类型字段。
from sqlalchemy.orm import sessionmaker, relationship  # 导入会话函数、
from sqlalchemy import create_engine

engine = create_engine("mysql+pymysql://root:@192.168.147.129:3306/sqlalchemy",
                       max_overflow=15)  # 创建数据库引擎，通过连接池获取数据库的连接。数据库连接池数量为：15，默认值是5.
# 创建sqlorm基类。（为声明的类定义基类。）
Base = declarative_base()

class   User(Base):
    __tablename__='user'
    nid=Column(Integer,primary_key=True,autoincrement=True)
    name=Column(String(32))
    def __repr__(self):
        return self.name

• django 默认情况不需要指定表名，而sqlalchemy需要指定表名否则报错。
• 2者在查询返回的结果都是对象的列表（django是Queryset对象，而sqlalchemy返回的是相应的类对象），django可以用__unicode__方法 输出对象的时候我们可以自定义输出的我们自定义的字段(django版本Django 1.10中是__str__方法)，而sqlalchemy是__repr__方法来输出对象的自定义字段。

sqlalchemy：

class User(Base):
    __tablename__='user'
    nid=Column(Integer,primary_key=True,autoincrement=True)
    username=Column(String(32))
Session=sessionmaker(engine)
session=Session()#创建数据库连接。可以理解为django的db模块中connection。
ret=session.query(User).filter(User.nid>1).all()
print(ret)
[<__main__.User object at 0x03708210>, <__main__.User object at 0x03708250>]

 django：

from django.db import models

# Create your models here.
class Person(models.Model):
    username=models.CharField(max_length=32)

class Fav(models.Model):
    name=models.CharField(max_length=32)
    per_fav=models.ForeignKey('Person')

def insert(request):
    ret=models.Fav.objects.filter(per_fav__username='evil').all()
    print(ret)
    return HttpResponse('ok')

<QuerySet [<Fav: Fav object>, <Fav: Fav object>]>

 sqlalchemy：

class User(Base):
    __tablename__='user'
    nid=Column(Integer,primary_key=True,autoincrement=True)
    username=Column(String(32))

    def __repr__(self):
        temp='%s-%s'%(self.nid,self.username)
        return temp
 [2-tom, 3-jack]

 django：

from django.db import models

# Create your models here.
class Person(models.Model):
    username=models.CharField(max_length=32)
    def __str__(self):
        temp='%s-%s'%(self.id,self.username)
        return temp

class Fav(models.Model):
    name=models.CharField(max_length=32)
    per_fav=models.ForeignKey('Person')
    def __str__(self):
        temp='%s-%s'%(self.id,self.name)
        return temp

输出函数：

from django.shortcuts import render,HttpResponse
from mod  import models
# Create your views here.
def insert(request):
    ret=models.Fav.objects.filter(per_fav__username='evil').all()
    for i in ret:
        print(i)
    return HttpResponse('ok')
1-bak
2-foot

•  在sqlalchemy中对数据库进行增删改的时候，最后需要提交事务(session.commit())，数据库才能保存我们的数据修改，在低版本的django中也需要save()进行提交事务在版本：Django 1.10中不需要提交事务。

User_obj=User(name='evil')
User_obj_1=User(name='tom')
User_obj_2=User(name='jack')

Session=sessionmaker(engine)
session=Session()
session.add_all(
    [
        User_obj,
        User_obj_1,
        User_obj_2
    ]
)
session.commit()

 

mysql> select * from  user;
+-----+------+
| nid | name |
+-----+------+
|   1 | evil |
|   2 | tom  |
|   3 | jack |
+-----+------+
3 rows in set (0.00 sec)

• 插入数据：在一对多的情况下，django可以有两种方式进行数据的插入，包括：django层面，对外键列插入关联表的对象，在数据库层面：实际数据库中存储的是：另一个列的主键id值。可以直接插入数字。

表结构：

class Author(models.Model):
    username=models.CharField(max_length=32)
class Book(models.Model):
    name=models.CharField(max_length=32)
    b_author=models.ForeignKey('Author')

给b_author插入值，默认情况下，book表（注意是小写）中的b_author列在数据库中的列为：b_author_id.

所以我们在插入b_author列插入author表的对象，也可以直接插入author主键列里的id值。插入对象：

from django.shortcuts import render,HttpResponse
from mod import models
# Create your views here.
def insert(request):
    author_obj=models.Author.objects.filter(id=1).first()
    models.Book.objects.create(b_author=author_obj,name="罗兵逊漂流记")
    return HttpResponse('ok')

 

插入id值：

from django.shortcuts import render,HttpResponse
from mod import models
# Create your views here.
def insert(request):
    models.Book.objects.create(b_author_id=2,name="陈二狗的妖孽人生")
    return HttpResponse('ok')

需要注意的是：需要使用实际数据库存在的列（b_author_id）而不是django定义字段的列名字：b_author。

• 在sqlalchemy中，插入的时候可以直接入相应类的对象（add()），或者可迭代对象集合（addall(元组、或者列表)），存在foreign key 列需要特别注意： 插入该列的值不是对象，而是关联表的主键nid值，不是对象！！！区别于django 插入外键的时候可以是对象或者id值。而且sqlalchemy定义的列名字就是数据库存储的名字。区别于django中在数据库层次的实际存储的列名字是django定义列的名字加上_id.

表结构：一个作者有多本书。book表示子表，相对author表为父表。

class Author(Base):
    __tablename__='author'
    username=Column(String(32))
    nid=Column(Integer,primary_key=True,autoincrement=True)
    def __repr__(self):
        temp='%s--%s'%(self.nid,self.username)
        return temp

class Book(Base):
    __tablename__ = 'book'
    nid = Column(Integer, primary_key=True, autoincrement=True)
    name = Column(String(32))
    b_a=Column(Integer,ForeignKey('author.nid'))
    book=relationship('Author',backref='auth')

    def __repr__(self):
        temp = '%s-%s' % (self.nid, self.name)
        return temp
Base.metadata.create_all(engine)##执行该函数，他就会执行所有Base所有的子类。调用我们定义类并创建相应的表结构。

 插入值：

author1=Author(username='evil')
author2=Author(username='tom')
author3=Author(username='jack')

Session=sessionmaker(bind=engine)
session=Session()
session.add_all(
    [
        author1,
        author2,
        author3
    ]
)
session.commit()

mysql> select * from author;
+----------+-----+
| username | nid |
+----------+-----+
| evil     |   1 |
| tom      |   2 |
| jack     |   3 |
+----------+-----+
3 rows in set (0.00 sec)

插入语句：注意外键的列插入的不是对象，而是相应的关联表的主键的值。即主表的主键nid值。

book1=Book(name='百年孤独',b_a=3)
book2=Book(name='陈二狗的妖孽人生',b_a=3)
book3=Book(name='海贼王',b_a=3)

session.add_all(
    (
        book1,
        book2,
        book3
    )
)
session.commit()

mysql> select * from book;
+-----+--------------------------+------+
| nid | name                     | b_a  |
+-----+--------------------------+------+
|   2 | 百年孤独                 |    2 |
|   3 | 陈二狗的妖孽人生         |    2 |
|   4 | 海贼王                   |    2 |
|   5 | 百年孤独                 |    1 |
|   6 | 陈二狗的妖孽人生         |    1 |
|   7 | 海贼王                   |    1 |
|   8 | 百年孤独                 |    3 |
|   9 | 陈二狗的妖孽人生         |    3 |
|  10 | 海贼王                   |    3 |
+-----+--------------------------+------+
9 rows in set (0.00 sec)

• 出现的问题： 编码问题，如果我们在sqlalchemy中不指定编码的时候，底层dbapi采用的编码：latin-1进行编码，如果你插入的数据含有中文的话，由于latin-1在解码的时候，不支持中文会报错：

UnicodeEncodeError: 'latin-1' codec can't encode characters in position 38-41: ordinal not in range(256)

解决方法：在数据连接引擎处指定编码，让sql语句中的中文部分按指定的编码进行解码。使用dbname?charset=utf8来指定相应的编码。

http://firefish.blog.51cto.com/298258/112794/

engine = create_engine("mysql+pymysql://root:@192.168.147.129:3306/sqlalchemy?charset=utf8",
                       max_overflow=15)  # 创建数据库引擎，通过连接池获取数据库的连接。数据库连接池数量为：15，默认值是5.

所以以后再写引擎的时候，需要注意：直接写上面的连接串。

在mysql中修改编码的方法：在/etc/my.cnf 中添加入下语句，如果不添加client字段的话，在数据库中中文字段显示是?问号。但是程序查询的时候，还会正常显示中文。

[mysqld]
default-storage-engine=INNODB
default-character-set=utf8
[client]
default-character-set=utf8

因为有的版本mysql不支持参数：default-character-set=utf8 需要使用：character_set_server=utf8。

•  建立外键的区别：django 中在一对多的情况下，使用的foreign key 。 在多对多，不创建第三张表的时候，使用ManyToMany字段。如果手动创建第三张表的时候使用foreign key来构建关系。sqlalchemy中，一对多、多对多的情况下，

都是用foreign key来构建关系。而且在多对多的情况下，需要手动构建表结构关系，创建第三张表，

• 对外键列的插入方法的不同：在django中对于外键列插入值，可以是插入关联表的对象或者关联表的对应的主键列即id列2种方法，但是在sqlalchemy对于外键列只能插入父表中的定义的主键列的值比如：nid值，而不是对象。
• 对于查询建立关系的区别：在django中，默认给咱们创建相应的查询的虚拟列比如一对多，反向查询：tablename_set  和tablename2种虚拟关系列。前者不能使用双下划线，后者可以使用双下划线。在sqlalchemy中需要我们手动创建一个不存在数据库的虚拟机列，使用（本表和关联表的虚拟关系列）=relationship（'classname',backref='另一张表的虚拟关系列'）进行查询。正向查询用：用等号的左边的列，反向查询的时候，用等号的右边的backref定义的虚拟关系列。

sqlalchemy：

表结构：

class Author(Base):
    __tablename__='author'
    username=Column(String(32))
    nid=Column(Integer,primary_key=True,autoincrement=True)
    def __repr__(self):
        temp='%s--%s'%(self.nid,self.username)
        return temp

class Book(Base):
    __tablename__ = 'book'
    nid = Column(Integer, primary_key=True, autoincrement=True)
    name = Column(String(100))
    b_a=Column(Integer,ForeignKey('author.nid'))
    book=relationship('Author',backref='auth')
    def __repr__(self):
        temp = '%s-%s' % (self.nid, self.name)
        return temp 

反向查询：使用子表中定义的列：book=relationship('Author',backref='auth') 建立的虚拟关系列：auth需要注意的是auth是另一个表的对象的集合。

需求场景：作者为：evil，都出那些书籍？

Session=sessionmaker(bind=engine)
session=Session()
res=session.query(Author).filter(Author.username=='evil').first()
for i in res.auth:
    print(i.name)
百年孤独
陈二狗的妖孽人生
海贼王

正向查询：

需求场景：book表中nid=2的书作者是谁？

Session=sessionmaker(bind=engine)
session=Session()
ret=session.query(Book).filter(Book.nid==2).first()
print(ret.book.username)

tom

•  在django中对于大于、小于、等于、包含、不包含等使用的双下滑线：id__lt=2...    在sqlalchemy中直接使用  > < ==等。
• 在django和sqlalchemy中如果查询条件为并的时候，都是用逗号。

Session=sessionmaker(bind=engine)
session=Session()
ret=session.query(Book).filter(Book.nid.in_((2,3,7)) ).all()
for i in ret:
    print(i.name)
百年孤独
陈二狗的妖孽人生
海贼王