SQLAlchemy -- Python的SQLAlchemy和ORM

Posted 2020-10-09

Python的SQLAlchemy和ORM(object-relational mapping:对象关系映射）

web编程中有一项常规任务就是创建一个有效的后台数据库。以前，程序员是通过写sql语句，发送到数据库引擎，解析并返回一个记录的数组。现在，程序员可以写ORM程序来取代之前那种不灵活、难以维护的冗长、易出错的sql语句。

ORM是面向对象编程语言中用来在不兼容的类型系统(incompatible type systems)之间转换数据的一种编程技术。通常在OO语言中的类型系统，比如python包含的类型是非标量的，也就是说这些类型不能使用原始的类型比如(integer、string)来表达。比如，一个person对象可能含有一个address对象的列表，和一个phonenumber对象的列表。同理，一个address对象可能包含一个postcode对象，一个streetname对象和一个streetnumber对象。尽管简单对象比如postcode、streetname可以用字符串来表示，但是更复杂的对象比如address、person就不能仅仅用字符串、整形数字来表示了。此外，这些复杂的对象还会具有实例或类方法，这些就更不能简单用字符串或整形数字来表示了。

为了处理这些复杂的对象管理问题，人们设计了ORM。上面我们的示例可以用一个ORM系统表示出来：设计一个person类、address类、phonenumber类，每个类映射到数据库中的一张表。这样就不再需要编写各种冗长的数据接口程序，而可以更加专注于系统的逻辑设计。

 

python中写数据库的代码(旧的方式)

使用pymysql创建两张表：

编写python脚本pymysql_ex.py并执行：

$ python pymysql_ex.py

#!/usr/bin/env python
# _*_ coding:utf-8 _*_

import pymysql

#创建链接
conn = pymysql.connect(host=‘127.0.0.1‘, port=3306, user=‘abce‘, passwd=‘abce‘, db=‘abce‘, charset=‘utf8‘)

#创建游标
c = conn.cursor()

#执行sql建表,插入内容
c.execute(‘‘‘
          create table person
          (id integer primary key, name varchar(250) not null)
          ‘‘‘)
c.execute(‘‘‘
          create table address
          (id integer primary key, street_name varchar(250), street_number varchar(250),
           post_code varchar(250) not null, person_id integer not null,
           foreign key(person_id) references person(id))
          ‘‘‘)
 
c.execute(‘‘‘
          insert into person values(1, ‘pythoncentral‘)
          ‘‘‘)
c.execute(‘‘‘
          insert into address values(1, ‘python road‘, ‘1‘, ‘00000‘, 1)
          ‘‘‘)

#提交
conn.commit()

#关闭游标
c.close()

#关闭连接
conn.close()

编写脚本pymysql_q.py查看数据库表的内容：

#!/usr/bin/env python
# _*_ coding:utf-8 _*_

import pymysql

#创建连接
conn = pymysql.connect(host=‘127.0.0.1‘, port=3306, user=‘abce‘, passwd=‘abce‘, db=‘abce‘, charset=‘utf8‘)

#创建游标
c = conn.cursor()

#执行sql查看表内容
c.execute(‘select * from person‘)
print(c.fetchall())
c.execute(‘select * from address‘)
print(c.fetchall())

#关闭游标
c.close()

#关闭连接
conn.close()

$ python pymysql_q.py 
((1, u‘pythoncentral‘),)
((1, u‘python road‘, u‘1‘, u‘00000‘, 1),)

例子中我们使pymysql连接提交对数据库的修改，并使用pymysql的游标来执行各种sql语句。尽管这些sql语句完成了相关的工作，但是维护sql语句的本身也不是件容易的事。下面，我们来看看sqlalchemy在Python得类和表之间是如何映射的。

　　

Python‘s SQLAlchemy and Declarative

写SQLAlchemy代码有三个重要组件：
--数据库中的表
--mapper：将python的类映射到数据库中的表
--类对象，定义如何将数据库的记录映射到一个python对象

不需要在不同的地方写表、mapper、class的代码，SQLAlchemy的declarative支持将表、mapper和类对象定义到一个类中。

 

下面创建一个declarative (sqlalchemy_declarative.py)

#!/usr/bin/env python
# _*_ coding:utf-8 _*_
import pymysql
import os
import sys
from sqlalchemy import Column, ForeignKey, Integer, String
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import relationship
from sqlalchemy import create_engine
 
Base = declarative_base()
 
class Person(Base):
    __tablename__ = ‘person‘
    # Here we define columns for the table person
    # Notice that each column is also a normal Python instance attribute.
    id = Column(Integer, primary_key=True)
    name = Column(String(250), nullable=False)
 
class Address(Base):
    __tablename__ = ‘address‘
    # Here we define columns for the table address.
    # Notice that each column is also a normal Python instance attribute.
    id = Column(Integer, primary_key=True)
    street_name = Column(String(250))
    street_number = Column(String(250))
    post_code = Column(String(250), nullable=False)
    person_id = Column(Integer, ForeignKey(‘person.id‘))
    person = relationship(Person)
 
# 连接数据库采用pymysq模块做映射，后面参数是最大连接数5
engine = create_engine(‘mysql+pymysql://abce:[email protected]:3306/abce?charset=utf8‘, max_overflow=5)
 
# Create all tables in the engine. This is equivalent to "Create Table"
# statements in raw SQL.
Base.metadata.create_all(engine)

执行脚本，就会创建了相应的数据库表

$ python sqlalchemy_declarative.py

　　

接下来，我们插入一些数据(sqlalchemy_insert.py)

#!/usr/bin/env python
# _*_ coding:utf-8 _*_
import pymysql
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
 
from sqlalchemy_declarative import Address, Base, Person
 
engine = create_engine(‘mysql+pymysql://abce:[email protected]:3306/abce?charset=utf8‘)
# Bind the engine to the metadata of the Base class so that the
# declaratives can be accessed through a DBSession instance
Base.metadata.bind = engine
 
DBSession = sessionmaker(bind=engine)
# A DBSession() instance establishes all conversations with the database
# and represents a "staging zone" for all the objects loaded into the
# database session object. Any change made against the objects in the
# session won‘t be persisted into the database until you call
# session.commit(). If you‘re not happy about the changes, you can
# revert all of them back to the last commit by calling
# session.rollback()
session = DBSession()
 
# Insert a Person in the person table
new_person = Person(name=‘new person‘)
session.add(new_person)
session.commit()
 
# Insert an Address in the address table
new_address = Address(post_code=‘00000‘, person=new_person)
session.add(new_address)
session.commit()

 从数据库后台可以直接看到数据：

mysql> select * from person;
+----+------------+
| id | name       |
+----+------------+
|  1 | new person |
+----+------------+
1 row in set (0.00 sec)

mysql> select * from address;
+----+-------------+---------------+-----------+-----------+
| id | street_name | street_number | post_code | person_id |
+----+-------------+---------------+-----------+-----------+
|  1 | NULL        | NULL          | 00000     |         1 |
+----+-------------+---------------+-----------+-----------+
1 row in set (0.00 sec)

mysql>

　　

当然我们得重点是从python中查看插入的数据：

>>> from sqlalchemy_declarative import Person, Base, Address
>>> from sqlalchemy import create_engine
>>> engine = create_engine(‘mysql+pymysql://abce:[email protected]:3306/abce?charset=utf8‘)
>>> Base.metadata.bind = engine
>>> from sqlalchemy.orm import sessionmaker
>>> DBSession = sessionmaker()
>>> DBSession.bind = engine
>>> session = DBSession()
>>> # Make a query to find all Persons in the database
>>> session.query(Person).all()
[<sqlalchemy_declarative.Person object at 0x21c7390>]
>>>
>>> # Return the first Person from all Persons in the database
>>> person = session.query(Person).first()
>>> person.name
u‘new person‘
>>>
>>> # Find all Address whose person field is pointing to the person object
>>> session.query(Address).filter(Address.person == person).all()
[<sqlalchemy_declarative.Address object at 0x22b08d0>]
>>>
>>> # Retrieve one Address whose person field is point to the person object
>>> session.query(Address).filter(Address.person == person).one()
<sqlalchemy_declarative.Address object at 0x22b08d0>
>>> address = session.query(Address).filter(Address.person == person).one()
>>> address.post_code
u‘00000‘

　　

 

总结
以上就是如何使用sqlalchemy的declaratives来编写数据库代码。和传统的sql语句相比，显得更面向对象、更易于理解和维护。

 

参考原文地址：http://pythoncentral.io/introductory-tutorial-python-sqlalchemy/