SQLAlchemy

随着项目越来越大，采用写原生SQL的方式在代码中会出现大量的SQL语句，那么问题就出现了：

  1. SQL语句重复利用率不高，越复杂的SQL语句条件越多，代码越长。会出现很多相近的SQL语句。
  2. 很多SQL语句是在业务逻辑中拼出来的，如果有数据库需要更改，就要去修改这些逻辑，这会很容易漏掉对某些SQL语句的修改。
  3. 写SQL时容易忽略web安全问题，给未来造成隐患。

ORM，全称Object Relational Mapping，中文叫做对象关系映射，通过ORM我们可以通过类的方式去操作数据库，而不用再写原生的SQL语句。通过把表映射成类，把行作实例，把字段作为属性，ORM在执行对象操作的时候最终还是会把对应的操作转换为数据库原生语句。使用ORM有许多优点：

  1. 易用性：使用ORM做数据库的开发可以有效的减少重复SQL语句的概率，写出来的模型也更加直观、清晰。
  2. 性能损耗小：ORM转换成底层数据库操作指令确实会有一些开销。但从实际的情况来看，这种性能损耗很少（不足5%），只要不是对性能有严苛的要求，综合考虑开发效率、代码的阅读性，带来的好处要远远大于性能损耗，而且项目越大作用越明显。
  3. 设计灵活：可以轻松的写出复杂的查询。
  4. 可移植性：SQLAlchemy封装了底层的数据库实现，支持多个关系数据库引擎，包括流行的MySQL、PostgreSQL和SQLite。可以非常轻松的切换数据库。

    使用SQLAlchemy：

    要使用ORM来操作数据库，首先需要创建一个类来与对应的表进行映射。现在以User表来做为例子，它有自增长的id、name、fullname、password这些字段，那么对应的类为：
    1. from sqlalchemy import Column,Integer,String
    2.  from constants import DB_URI
    3.  from sqlalchemy import create_engine
    4.  from sqlalchemy.ext.declarative import declarative_base
    5.  engine = create_engine(DB_URI,echo=True)
    6.  # 所有的类都要继承自`declarative_base`这个函数生成的基类
    7.  Base = declarative_base(engine)
    8.  class User(Base):
    9.      # 定义表名为users
    10.      __tablename__ = 'users'
    11.      # 将id设置为主键，并且默认是自增长的
    12.      id = Column(Integer,primary_key=True)
    13.      # name字段，字符类型，最大的长度是50个字符
    14.      name = Column(String(50))
    15.      fullname = Column(String(50))
    16.      password = Column(String(100))
    17.      # 让打印出来的数据更好看，可选的
    18.      def __repr__(self):
    19.          return "<User(id='%s',name='%s',fullname='%s',password='%s')>" % (self.id,self.name,self.fullname,self.password)
    SQLAlchemy会自动的设置第一个Integer的主键并且没有被标记为外键的字段添加自增长的属性。因此以上例子中id自动的变成自增长的。以上创建完和表映射的类后，还没有真正的映射到数据库当中，执行以下代码将类映射到数据库中：
    1. Base.metadata.create_all()
    在创建完数据表，并且做完和数据库的映射后，接下来让我们添加数据进去：
    1. ed_user = User(name='ed',fullname='Ed Jones',password='edspassword')
    2. # 打印名字
    3. print ed_user.name
    4. > ed
    5. # 打印密码
    6. print ed_user.password
    7. > edspassword
    8. # 打印id
    9. print ed_user.id
    10. > None
    可以看到，name和password都能正常的打印，唯独id为None，这是因为id是一个自增长的主键，还未插入到数据库中，id是不存在的。接下来让我们把创建的数据插入到数据库中。和数据库打交道的，是一个叫做Session的对象：
    1. from sqlalchemy.orm import sessionmaker
    2. Session = sessionmaker(bind=engine)
    3. # 或者
    4. # Session = sessionmaker()
    5. # Session.configure(bind=engine)
    6. session = Session()
    7. ed_user = User(name='ed',fullname='Ed Jones',password='edspassword')
    8. session.add(ed_user)
    现在只是把数据添加到session中，但是并没有真正的把数据存储到数据库中。如果需要把数据存储到数据库中，还要做一次commit操作：
    1. session.commit()
    2. # 打印ed_user的id
    3. print ed_user.id
    4. > 1
    这时候，ed_user就已经有id。 说明已经插入到数据库中了。有人肯定有疑问了，为什么添加到session中后还要做一次commit操作呢，这是因为，在SQLAlchemy的ORM实现中，在做commit操作之前，所有的操作都是在事务中进行的，因此如果你要将事务中的操作真正的映射到数据库中，还需要做commit操作。既然用到了事务，这里就并不能避免的提到一个回滚操作了，那么看以下代码展示了如何使用回滚（接着以上示例代码）：
    1. # 修改ed_user的用户名
    2. ed_user.name = 'Edwardo'
    3. # 创建一个新的用户
    4. fake_user = User(name='fakeuser',fullname='Invalid',password='12345')
    5. # 将新创建的fake_user添加到session中
    6. session.add(fake_user)
    7. # 判断`fake_user`是否在`session`中存在
    8. print fake_user in session
    9. > True
    10. # 从数据库中查找name=Edwardo的用户
    11. tmp_user = session.query(User).filter_by(name='Edwardo')
    12. # 打印tmp_user的name
    13. print tmp_user
    14. # 打印出查找到的tmp_user对象，注意这个对象的name属性已经在事务中被修改为Edwardo了。
    15. > <User(name='Edwardo', fullname='Ed Jones', password='edspassword')>
    16. # 刚刚所有的操作都是在事务中进行的，现在来做回滚操作
    17. session.rollback()
    18. # 再打印tmp_user
    19. print tmp_user
    20. > <User(name='ed', fullname='Ed Jones', password='edspassword')>
    21. # 再看fake_user是否还在session中
    22. print fake_user in session
    23. > False
    接下来看下如何进行查找操作，查找操作是通过session.query()方法实现的，这个方法会返回一个Query对象，Query对象相当于一个数组，装载了查找出来的数据，并且可以进行迭代。具体里面装的什么数据，就要看向session.query()方法传的什么参数了，如果只是传一个ORM的类名作为参数，那么提取出来的数据就是都是这个类的实例，比如：
    1. for instance in session.query(User).order_by(User.id):
    2.  print instance
    3. # 输出所有的user实例
    4. > <User (id=2,name='ed',fullname='Ed Json',password='12345')>
    5. > <User (id=3,name='be',fullname='Be Engine',password='123456')>
    如果传递了两个及其两个以上的对象，或者是传递的是ORM类的属性，那么查找出来的就是元组，例如：
    1. for instance in session.query(User.name):
    2.  print instance
    3. # 输出所有的查找结果
    4. > ('ed',)
    5. > ('be',)
    以及：
    1. for instance in session.query(User.name,User.fullname):
    2.  print instance
    3. # 输出所有的查找结果
    4. > ('ed', 'Ed Json')
    5. > ('be', 'Be Engine')
    或者是：
    1. for instance in session.query(User,User.name).all():
    2.  print instance
    3. # 输出所有的查找结果
    4. > (<User (id=2,name='ed',fullname='Ed Json',password='12345')>, 'Ed Json')
    5. > (<User (id=3,name='be',fullname='Be Engine',password='123456')>, 'Be Engine')
    另外，还可以对查找的结果（Query）做切片操作：
    1. for instance in session.query(User).order_by(User.id)[1:3]
    2.  instance
    如果想对结果进行过滤，可以使用filter_by和filter两个方法，这两个方法都是用来做过滤的，区别在于，filter_by是传入关键字参数，filter是传入条件判断，并且filter能够传入的条件更多更灵活，请看以下例子：
    1. # 第一种：使用filter_by过滤：
    2. for name in session.query(User.name).filter_by(fullname='Ed Jones'):
    3.  print name
    4. # 输出结果：
    5. > ('ed',)
    6. # 第二种：使用filter过滤：
    7. for name in session.query(User.name).filter(User.fullname=='Ed Jones'):
    8.  print name
    9. # 输出结果：
    10. > ('ed',)