SQLAlchemy的简单使用

SQLAlchemy的简单使用

简介

SQLAlchemy是一个Python的数据库操作库，可以操作PostgreSQL, MySQL, 和SQLite 数据库。

安装

pip install SQLAlchemy

执行SQL语句

from sqlalchemy import create_engine

eng = create_engine("sqlite:///test.db") #创建数据库引擎
#create_engine("mysql://testuser:test623@localhost/testdb") mysql连接
#create_engine('postgresql:///testdb') postgresql连接
#create_engine('sqlite:///:memory:') 内存数据

with eng.connect() as con: #连接数据库
    result = con.execute("select * from user")#执行SQL返回结果
    for r in result: #遍历结果
        print(r)
    #也可以使用result.fetchone()获取一条数据，可以不断调用使结果集指向下一条数据，
    #使用result.keys()可以获取列名

执行SQL语句需要进行上面例子中的步骤：
1.创建数据库引擎
2.连接数据库并获取连接
3.执行SQL语句
注意不懂with语句，请阅读python上下文管理器博文http://blog.csdn.net/a540366413/article/details/57416266

参数绑定的SQL语句

from sqlalchemy import create_engine
from sqlalchemy.sql import text
eng = create_engine("sqlite:///test.db")

con = eng.connect()
result = con.execute(text('insert into user values(null,:name,:age)'), name='1',age=1)#使用text包裹SQL语句，语句中使用:name来当占位符，参数使用name可以传入。
con.close()

使用text加占位符可以向其它后端语言一样操作数据库

table的表示（非ORM表示）

from sqlalchemy import Table,Column,Integer,String,MetaData

eng = create_engine("sqlite:///test.db")

meta = MetaData(bind=eng) #里面包含包含数据库操作，引擎和连接相关信息

user = Table('user',#表名
    meta,#上文的meta
    Column('id',Integer,primary_key=True),#一列，名称为id，数字类型，主键
    Column('name',String,nullable=False,default='a')#列名为name，字符串类型，不允许为空，默认值为a
    )

列的使用，形式为表名.colmuns.定义的列名或者表名.c.定义的列名
如：访问user的id列，user.columns.id或者user.c.id

使用定义的表进行数据库操作

创建表：

from sqlalchemy import create_engine,Table,Column,Integer,String,MetaData
from sqlalchemy import select,and_,or_,asc,desc eng = create_engine("sqlite:///test.db") meta = MetaData(bind = eng) #里面包含包含数据库操作，引擎和连接相关信息 user = Table('user1',meta, Column('id',Integer, primary_key=True), Column('name', String,nullable=False), Column('age', Integer, default=18)) user.create() #创建表

查询操作：

from sqlalchemy import create_engine,Table,Column,Integer,String,MetaData
from sqlalchemy import select,and_,or_,asc,desc

eng = create_engine("sqlite:///test.db")#创建和sqlite的引擎

meta = MetaData()

user = Table('user',meta,#定义一个表
    Column('id',Integer, primary_key=True),
    Column('name', String,nullable=False))

with eng.connect() as con:#连接数据库并获取连接
    s = select([user]).where(and_(user.columns.id > 1,user.columns.name.like(r'%1'))).limit(3).order_by(desc(user.columns.id))
    #s = select([user]).where(user.c.id.in_([1,2,4])) in_查找包含在列表中的数据
    #s = select([user.join(user1)]) join操作
    #select，where,limit,order_by会帮你生成一个SQL，where如果有多个条件是需要使用and_或者or_,asc和desc控制排序,和SQL一致，看一下就懂了，这里用到了列操作，如user.column.id等
    print s

    rs = con.execute(s)
    for r in rs:
        print r

插入操作：

from sqlalchemy import create_engine,Table,Column,Integer,String,MetaData
from sqlalchemy import select,and_,or_,asc,desc eng = create_engine("sqlite:///test.db") meta = MetaData(bind = eng) user = Table('user',meta, Column('id',Integer, primary_key=True), Column('name', String,nullable=False), Column('age', Integer, default=18)) with eng.connect() as con: sql = user.insert().values(name='aaaa') print sql con.execute(sql)

更新操作：

from sqlalchemy import create_engine,Table,Column,Integer,String,MetaData
from sqlalchemy import select,and_,or_,asc,desc

eng = create_engine("sqlite:///test.db")

meta = MetaData(bind = eng)

user = Table('user',meta,
    Column('id',Integer, primary_key=True),
    Column('name', String,nullable=False),
    Column('age', Integer, default=18))

#user.create()

with eng.connect() as con:
    sql = user.update().where(user.c.id>2).values(name='ddd') #更新操作
    print sql
    rs = con.execute(sql)

ORM

现代的SQLAlchemy使用对象关系映射系统来进行数据库操作,使用对象关系映射需要如下几步：
1.创建引擎
2.创建映射关系对象类，在创建映射关系类时使用declarative_base()函数来创建基类。
3.创建session并绑定引擎，session是使用ORM来操作持久化的接口。
4.操作数据库
5.如果是插入更新操作的恶化需要提交数据

from sqlalchemy import create_engine,Column,Integer,String
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker #导入sessionmaker

eng = create_engine("sqlite:///test.db")#创建引擎

Base = declarative_base()#创建ORM基类

class User(Base): #创建映射对象
    __tablename__ = 'User' #表名
    id = Column( 'id', Integer, primary_key=True) #列名，第一个参数为数据库中的列名，如果和属性名相同可以省略，不传列名时在创建时使用属性名
    name = Column( 'name', String(10), nullable = False)
    age = Column( 'age', Integer, default=10)

Base.metadata.bind = eng #绑定引擎
Base.metadata.create_all()#创建表

Session = sessionmaker(bind = eng ) #session绑定引擎

s = Session() 创建session
s.add_all([User(name='123'), User(name='345'), User(name='567')]) #添加数据
#添加一条使用s.add(User(name='123'))
s.commit() #提交
s.close()#关闭会话

更复杂的例子：

from sqlalchemy import create_engine,Column,Integer,String,ForeignKey
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
#from sqlalchemy import select,and_,or_,asc,desc

eng = create_engine("sqlite:///test.db")

Base = declarative_base()

class User(Base):
    __tablename__ = 'User'
    id = Column(Integer, primary_key=True)
    name = Column( 'name', String(10), nullable = False)
    age = Column( 'age', Integer, default=10)

class Book(Base):
    __tablename__ = 'Book'
    id = Column('id', Integer, primary_key = True)
    name = Column('name', String, default='Book')
    user = Column('user', ForeignKey('User.id'), index=True, nullable=False)



Base.metadata.bind = eng
Base.metadata.create_all()

Session = sessionmaker(bind = eng)

s = Session()
user = User(name='asdfsdf')
s.add(user)
s.flush()#使上面添加的user和数据库交互，产生id，但是不commit也是不会生效的，只是配合Book外键生成id使用
book = Book(name='aaa',user=user.id)
s.add(book)
s.commit()

rs = s.query(User,Book).filter(User.id == Book.user).all()#查找这两个表，条件是user.id==book.id的所有数据结果是user和book的元组的列表
#读取结果，方式1
for u,b in rs:
    print( u.id,b.name )
#方式3
for r in rs:
    print(r.User.id, r.Book.name)
s.close()#关闭会话

关于外键

#除了上面在column上设置ForeignKey之外如果添加了relationship在查询时可以直接查找出外键相关的数据，不需要再query中查找两个表
...
from sqlalchemy.orm import ...,relationship
...
class A(Base):
    ...
    b = Column(Integer, ForeignKey('B.id'))
    B = relationship('B') #table name
class B(Base):
    ...
...
result = session.query(A).filter(...)#只需要查询符合条件的A就能找到B
for r in result:
    print(r.B.name) #可以直接获取对应外键B的信息

参考：
http://zetcode.com/db/sqlalchemy
http://docs.sqlalchemy.org
http://www.codexiu.cn/python