1. 安装

pip install SQLAlchemy

2. 执行SQL语句

执行SQL语句需要进行上面例子中的步骤：
1.创建数据库引擎
2.连接数据库并获取连接
3.执行SQL语句

from sqlalchemy import create_engine

eng = create_engine("sqlite:///test.db") #创建数据库引擎
#create_engine("mysql+pymysql://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()可以获取列名

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

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

一、建表

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)

4. ORM

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

例子1

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()#关闭会话

例子2

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的信息