这五张表有些有联系,使用关系对象映射进行数

作者:美狮美高梅官方网站

知识要点:

Date:2016-03-27
Title:20.Python笔记之SqlAlchemy使用
Tags:python
Category:Python

一、简介

  flask本身没有内置orm框架,需要依赖第三方模块,这里介绍flask-sqlalchemy,而flask-sqlalchemy是一个flask的扩展,本质上是对sqlalchemy的进一步封装,当然也需要sqlalchemy的支持,使用起来和本来的sqlalchemy的orm是一样的。本文主要介绍sqlalchemy的使用以及如何在flask中是用orm。

1.多表查询

作者:刘耀
博客:www.liuyao.me

二、sqlalchemy

  SQLAlchemy是Python编程语言下的一款ORM框架,该框架建立在数据库API之上,使用关系对象映射进行数据库操作,简言之便是:将对象转换成SQL,然后使用数据API执行SQL并获取执行结果。图示:

美狮美高梅官方网站 1

2.原生SQL的查询

一、SQLAlchemy

SQLAlchemy是Python编程语言下的一款ORM框架,该框架建立在数据库API之上,使用关系对象映射进行数据库操作,简言之便是:将对象转换成SQL,然后使用数据API执行SQL并获取执行结果。

美狮美高梅官方网站 2

ORM方法论基于三个核心原则:

简单:以最基本的形式建模数据。

传达性:数据库结构被任何人都能理解的语言文档化。

精确性:基于数据模型创建正确标准化了的结构。

Dialect用于和数据API进行交流,根据配置文件的不同调用不同的数据库API,从而实现对数据库的操作,如:

基本使用

安装:

pip3 install sqlalchemy

注:SQLAlchemy无法修改表结构,如果需要可以使用SQLAlchemy开发者开源的另外一个软件Alembic来完成,官网doc:

原生SQL

使用 Engine/ConnectionPooling/Dialect 进行数据库操作,Engine使用ConnectionPooling连接数据库,然后再通过Dialect执行SQL语句

#!/usr/bin/env python3#_*_ coding:utf-8 _*_#Author:wdfrom sqlalchemy import create_engineengine=create_engine("mysql+pymysql://stu:1234qwer@10.0.0.241:3307/student", max_overflow=5)#创建连接,允许溢出5个连接result = engine.execute('select * from student')#使用excute执行原生sqlprint(result.fetchall#获取所有结果,与pymyql类似

事务

#!/usr/bin/env python3#_*_ coding:utf-8 _*_#Author:wdfrom sqlalchemy import create_engineengine=create_engine("mysql+pymysql://stu:1234qwer@10.0.0.241:3307/student", max_overflow=5)#创建连接,允许溢出5个连接result = engine.execute('select * from student')#使用excute执行原生sqlwith engine.begin() as conn: #事务操作    conn.execute("insert into student (name, age, res_date) values ('weikang', 33, '1992-11-11')")    print(result.fetchall#获取所有结果,与pymyql类似

多表查询

'数据库类型+数据库驱动名称://用户名:口令@机器地址:端口号/数据库名'

MySQL-Python

mysql+mysqldb://<user>:<password>@<host>[:<port>]/<dbname>

pymysql

mysql+pymysql://<username>:<password>@<host>/<dbname>[?<options>]

MySQL-Connector

mysql+mysqlconnector://<user>:<password>@<host>[:<port>]/<dbname>

cx_Oracle

oracle+cx_oracle://user:pass@host:port/dbname[?key=value&key=value...]

更多详见:

新美高梅网站,美狮美高梅官方网站,注:

2.7版本使用mysqldb
3.5版本使用pymysql
请用pip或者源码包安装,确保环境可以正常使用。**
确保远程数据库服务器可以正常使用,并且拥有全新可以远程登录,
例如:
登录数据库:mysql -uroot  -p
创建数据库:create database liuyao;
授权库:grant all on liuyao.* to liuyao@"%" identified by 'liuyao';
更新:flush privileges;

建表

  定义数据表,才能进行sql表达式的操作,毕竟sql表达式的表的确定,是sqlalchemy制定的,如果数据库已经存在了数据表还需要定义么?当然,这里其实是一个映射关系,如果不指定,查询表达式就不知道是附加在那个表的操作,当然定义的时候,注意表名和字段名,代码和数据的必须保持一致。定义好之后,就能创建数据表,一旦创建了,再次运行创建的代码,数据库是不会创建的。

  sqlalchemy内部组件调用顺序为:使用 Schema Type/SQL Expression Language/Engine/ConnectionPooling/Dialect 进行数据库操作。Engine使用Schema Type创建一个特定的结构对象,之后通过SQL Expression Language将该对象转换成SQL语句,然后通过ConnectionPooling 连接数据库,再然后通过Dialect 执行SQL,并获取结果。

TIPS:使用类的方式和使用metadata方式创建表时候区别在于metadata可以不指定主键,而是用class方式必须要求有主键。

demo1:

from sqlalchemy import create_engine,Table,Column,Integer,String,ForeignKey,MetaDataengine=create_engine("mysql+pymysql://stu:1234qwer@10.0.0.241:3307/student?charset=gbk",                     encoding="utf-8",                     echo=True,                      max_overflow=5                     )#?charset是字符集编码,echo=True打印输出信息和执行的sql语句默认Flase,max_overflow=5允许溢出连接池连接数量meta=MetaData()#生成源类#定义表结构user=Table('user',meta,           Column('id',Integer,nullable=Table,autoincrement=True,primary_key=True),           Column('name',String,nullable=True),           Column('age',Integer,nullable=True)           )host=Table('host',meta,            Column('ip',String,nullable=True),            Column('hostname',String,nullable=True),)meta.create_all#创建表,如果存在则忽视

demo2:

使用orm基类创建

#!/usr/bin/env python3#_*_ coding:utf-8 _*_#Author:wdfrom sqlalchemy import create_engine,Table,Column,Integer,String,ForeignKey,MetaData,Datefrom sqlalchemy.ext.declarative import declarative_baseengine=create_engine("mysql+pymysql://stu:1234qwer@10.0.0.241:3307/student?charset=gbk",                     encoding="utf-8",                     echo=True,                      max_overflow=5                     )#?charset是字符集编码,echo=True打印输出信息和执行的sql语句默认Flase,max_overflow=5允许溢出连接池连接数量base=declarative_base()#生成ORM基类#定义表结构class User:    __tablename__='book' #表明    id = Column(Integer, primary_key=True)    name=Column(String(32))    date=Columnbase.metadata.create_all#创建表,如果存在则忽视

在MySQL中我们讲了多表查询,在SQLAlchemy中也有多表查询的概念

1.基本操作:

1)链接数据库:create_engine()

engine = create_engine("mysql+mysqldb://liuyao:liuyao@121.42.195.15:3306/liuyao", max_overflow=5)

create_engine() 会返回一个数据库引擎,
mysql+mysqldb”指定了使用 MySQL-Python 来连接,
使用用户名‘liuyao’和密码‘liuyao’来链接数据库
121.42.195.15是数据库链接地址可以是localhost,127.0.0.1
‘liuyao’是数据库名
max_overflow是最大连接数
其他方法:
“charset”指定了连接时使用的字符集(可省略)=utf8
 echo 参数为 True 时,会显示每条执行的 SQL 语句,生产环境下可关闭。

2)字段和数据类型及操作方法

在sqlalchemy.schema包里有数据库关系的描述,列举几个最常用的:

字段:Column

索引:Index

表:Table

数据类型在sqlalchemy.types包,列举几个最常用的:

二进制:BIGINT

布尔:BOOLEAN

字符:CHAR

可变字符:VARCHAR

日期:DATETIME

其他方法 execute,update,insert,select,delete,join等 自行补脑

3)创建表结构

使用 Schema Type/SQL Expression Language/Engine/ConnectionPooling/Dialect 进行数据库操作。Engine使用Schema Type创建一个特定的结构对象,之后通过SQL Expression Language将该对象转换成SQL语句,然后通过 ConnectionPooling 连接数据库,再然后通过 Dialect 执行SQL,并获取结果。

from sqlalchemy import create_engine, Table, Column, Integer, /
String, MetaData, ForeignKey
import MySQLdb
#创建数据库连接
engine = create_engine("mysql+mysqldb://liuyao:liuyao@121.42.195.15:3306/liuyao", max_overflow=5)
# 获取元数据
metadata = MetaData()
# 定义表
user = Table('user', metadata,
    Column('id', Integer, primary_key=True),
    Column('name', String(20)),
    )

color = Table('color', metadata,
    Column('id', Integer, primary_key=True),
    Column('name', String(20)),
    )
# 创建数据表,如果数据表存在,则忽视
metadata.create_all(engine)
结果:
mysql> show tables;
+------------------+
| Tables_in_liuyao |
+------------------+
| color            |
| user             |
+------------------+
2 rows in set (0.00 sec)

3)插入一条数据

使用 Engine/ConnectionPooling/Dialect 进行数据库操作,Engine使用ConnectionPooling连接数据库,然后再通过Dialect执行SQL语句。

#!/usr/bin/env python3
#coding:utf8
from sqlalchemy import create_engine

engine = create_engine("mysql+mysqldb://liuyao:liuyao@121.42.195.15:3306/
liuyao", max_overflow=5)
engine.execute(
    "INSERT INTO liuyao.color(id, name) VALUES ('1', 'liuyao');"
)
result = engine.execute('select * from color')
print(result.fetchall())
结果:
[(1L, 'liuyao'), (2L, 'v1')]

4) 增删改查

先创建数据库

#!/usr/bin/env python3
#coding:utf8
from sqlalchemy import create_engine, Table, Column, Integer, String,MetaData, ForeignKey
metadata = MetaData()   
#创建数据库引擎
engine = create_engine("mysql+mysqldb://liuyao:liuyao@121.42.195.15:3306/
liuyao", max_overflow=5)
conn = engine.connect()
#创建一个表叫做user 在liuyao库里
user = Table('user', metadata,
    Column('id', Integer, primary_key=True),
    Column('name', String(20)),
)
color = Table('color', metadata,
    Column('id', Integer, primary_key=True),
    Column('name', String(20)),
)       
metadata.create_all(engine)

增加

# 创建SQL语句,INSERT INTO "user" (id, name) VALUES (:id, :name)
conn.execute(user.insert(),{'id':7,'name':'seven'})
conn.close()
# 或者按照下面的方式创建
# sql = user.insert().values(id=123, name='wu')
# conn.execute(sql) 
# conn.close()
结果:
mysql> show tables;
+------------------+
| Tables_in_liuyao |
+------------------+
| color            |
| user             |
+------------------+
2 rows in set (0.00 sec)

mysql> select * from user;
+----+-------+
| id | name  |
+----+-------+
|  7 | seven |
+----+-------+
1 row in set (0.00 sec)

删除

#删除一条user表里的 条件是id大于1的
sql = user.delete().where(user.c.id > 1)
#执行
conn.execute(sql)
#关闭链接
conn.close()
结果:
mysql> select * from user;
Empty set (0.00 sec)

mysql> 
#因表里只有一条数据,删除之后,没有任何数据存在

修改/更新

先创建几条数据步骤略
显示如下:
mysql> select * from user;
+----+--------+
| id | name   |
+----+--------+
|  1 | liuyao |
|  2 | liuyao |
|  3 | yaoyao |
|  4 | yao    |
+----+--------+
4 rows in set (0.00 sec)
#更新
#把名字为liuyao的修改为no1
sql = user.update().where(user.c.name == 'liuyao').values(name='no1')
conn.execute(sql)
conn.close()
结果:
mysql> select * from user;
+----+--------+
| id | name   |
+----+--------+
|  1 | no1    |
|  2 | no1    |
|  3 | yaoyao |
|  4 | yao    |
+----+--------+
4 rows in set (0.00 sec)

查询

注:请导入查询模块

from sqlalchemy import select 其他模块同上
#查询user表里的内容
sql = select([user, ])
res =conn.execute(sql)
print res.fetchall()
conn.close()
结果:
[(1L, 'no1'), (2L, 'no1'), (3L, 'yaoyao'), (4L, 'yao')]
#查询user表下的id
sql = select([user.c.id, ])
res =conn.execute(sql)
print res.fetchall()
conn.close()
结果:
[(1L,), (2L,), (3L,), (4L,)]
#查询user表和color表的name,条件是user表的id1=color的id1
sql = select([user.c.name, color.c.name]).where(user.c.id==color.c.id)
结果:
[('no1', 'liuyao'), ('no1', 'v1')]
#查询user表的name,并按照条件排序
#按照名字排序 
sql = select([user.c.name]).order_by(user.c.name)
res =conn.execute(sql)
print res.fetchall()
conn.close()
结果:
[('no1',), ('no1',), ('yao',), ('yaoyao',)]
#按照id排序
sql = select([user.c.name]).order_by(user.c.id)
res =conn.execute(sql)
print res.fetchall()
conn.close()
结果:
[('no1',), ('no1',), ('yaoyao',), ('yao',)]
#查询user表的name,并按照条件分组
sql = select([user]).group_by(user.c.name)
res =conn.execute(sql)
print res.fetchall()
conn.close()
结果:
[(1L, 'no1'), (4L, 'yao'), (3L, 'yaoyao')]
#按照id
结果:
[(1L, 'no1'), (2L, 'no1'), (3L, 'yaoyao'), (4L, 'yao')]

5)继承SqlORM类来操作数据库

#!/usr/bin/env python3
#coding:utf8
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String
from  sqlalchemy.orm import sessionmaker
Base = declarative_base() #生成一个SqlORM 基类
engine = create_engine("mysql+mysqldb://liuyao:liuyao@121.42.195.15:3306/liuyao",echo=True)
#echo如果为True,那么当他执行整个代码的数据库的时候会显示过程
#创建一个类继承Base基类
class Host(Base):
    #表名为hosts
    __tablename__ = 'hosts'
    #表结构
    #primary_key等于主键
    #unique唯一
    #nullable非空
    id = Column(Integer,primary_key=True,autoincrement=True)
    hostname = Column(String(64),unique=True,nullable=False)
    ip_addr = Column(String(128),unique=True,nullable=False)
    port = Column(Integer,default=22)

Base.metadata.create_all(engine) #创建所有表结构

if __name__ == '__main__':
    SessionCls = sessionmaker(bind=engine)
    #bind绑定
    #创建与数据库的会话session class 
    #注意,这里返回给session的是个class,不是实例 
    session = SessionCls()
    #插入字段
    h1 = Host(hostname='qd115',ip_addr='115.29.51.8')
    h2 = Host(hostname='ubuntu',ip_addr='139.129.5.191',port=80)
    h3 = Host(hostname='mysql',ip_addr='121.42.195.15',port=3306)
    #添加一个
    #session.add(h3)
    #可以添加多个字段
    session.add_all( [h1,h2,h3])
    #修改字段名字,只要没提交,此时修改也没问题
    #h2.hostname = 'ubuntu_test'
    #支持数据回滚
    #session.rollback()
    #提交
    session.commit()

结果:
mysql> select * from hosts;
+----+----------+---------------+------+
| id | hostname | ip_addr       | port |
+----+----------+---------------+------+
|  1 | qd115    | 115.29.51.8   |   22 |
|  2 | ubuntu   | 139.129.5.191 |   80 |
|  4 | mysql    | 121.42.195.15 | 3306 |
+----+----------+---------------+------+
3 rows in set (0.00 sec)

注:SQLAlchemy无法修改表结构,如果需要可以使用SQLAlchemy开发者开源的另外一个软件Alembic来完成。

6.继承类式增删改查:

使用 ORM/Schema Type/SQL Expression Language/Engine/ConnectionPooling/Dialect 所有组件对数据进行操作。根据类创建对象,对象转换成SQL,执行SQL。

Query对象可以返回可迭代的值(iterator value),然后我们可以通过for in来查询。不过Query对象的all()、one()以及first()方法将返回非迭代值(non-iterator value),比如说all()返回的是一个列表first()方法限制并仅作为标量返回结果集的第一条记录:

1)先创建相关数据库

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String
from sqlalchemy.orm import sessionmaker
from sqlalchemy import create_engine
#创建数据库
engine = create_engine("mysql+mysqldb://liuyao:liuyao@121.42.195.15:3306/liuyao", max_overflow=5)
#生成一个SqlORM 基类
Base = declarative_base()   
#定义表结构
class User(Base):
    #表名
    __tablename__ = 'users'
    #定义id,主键唯一,
    id = Column(Integer, primary_key=True)
    name = Column(String(50))
#寻找Base的所有子类,按照子类的结构在数据库中生成对应的数据表信息
Base.metadata.create_all(engine)
#创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例
Session = sessionmaker(bind=engine)
session = Session()
#获取session,然后把对象添加到session,
#最后提交并关闭。Session对象可视为当前数据库连接。

2.增加

########### 增 ##########
#定义一个字段
zengjia = User(id=2, name='sbliuyao')
#添加字段
session.add(zengjia)
#添加多个字段
session.add_all([
    User(id=3, name='sbyao'),
    User(id=4, name='liuyao')
])
#提交以上操作
session.commit()

结果:
mysql> select * from users;
+----+----------+
| id | name     |
+----+----------+
|  2 | sbliuyao |
|  3 | sbyao    |
|  4 | liuyao   |
+----+----------+
3 rows in set (0.00 sec)

3.删除

# ########## 删除 ##########
#删除user表,id大于2的字段
session.query(User).filter(User.id > 2).delete()
session.commit()
结果:
mysql> select * from users;
+----+----------+
| id | name     |
+----+----------+
|  2 | sbliuyao |
+----+----------+
1 row in set (0.00 sec)

4.修改

因上次操作已经删除好多数据
请重新执行插入字段操作
session.add_all([
    User(id=3, name='sbyao'),
    User(id=4, name='liuyao'),
    User(id=5, name='mayun')
])
session.commit()
结果:
mysql> select * from users;
+----+----------+
| id | name     |
+----+----------+
|  2 | sbliuyao |
|  3 | sbyao    |
|  4 | liuyao   |
|  5 | mayun    |
+----+----------+
4 rows in set (0.00 sec)

在执行以下操作
#user表里的id等于2的字段修改为id=6
session.query(User).filter(User.id == 2).update({'id' : 6})
session.commit()
结果:
mysql> select * from users;
+----+----------+
| id | name     |
+----+----------+
|  3 | sbyao    |
|  4 | liuyao   |
|  5 | mayun    |
|  6 | sbliuyao |
+----+----------+
4 rows in set (0.00 sec)
其他方法:
#把user表里id大于2的name全部换成woshiyaoge
session.query(User).filter(User.id > 2).update({'name' :'woshiyaoge'})
session.commit()

mysql> select * from users;
+----+------------+
| id | name       |
+----+------------+
|  3 | woshiyaoge |
|  4 | woshiyaoge |
|  5 | woshiyaoge |
|  6 | woshiyaoge |
+----+------------+
4 rows in set (0.00 sec)

5.查询

数据库如下:
mysql> select * from users;
+----+------------+
| id | name       |
+----+------------+
|  3 | woshiyaoge |
|  4 | woshiyaoge |
|  5 | woshiyaoge |
|  6 | woshiyaoge |
|  7 | sbyao      |
|  8 | liuyao     |
|  9 | mayun      |
+----+------------+
7 rows in set (0.00 sec)

方式1:

#查询user表下面name=liuyao的字段
ret = session.query(User).filter_by(name='liuyao').all()
#打印实例
print ret
for i in ret:
#打印结果
print(i.id,i.name,)
结果:
[<__main__.User object at 0x0000000002F55860>]
(8L, 'liuyao')
这种查询方法可以返回一个User对象以及它的name属性字段的值。

方式2:
#查询user表里字段是name=liuyao的第一条数据
ret = session.query(User).filter_by(name='liuyao').first()
print ret.name
print ret.id
结果:
liuyao
8

方式3:
#查询user表里字段是name是liuyao或者mayun的信息打印出来
ret = session.query(User).filter(User.name.in_(['liuyao','mayun'])).all()
print ret
for i in ret:
    print(i.name,i.id)
结果:
[<__main__.User object at 0x00000000030F1E48>, <__main__.User object at 0x000000000311D8D0>]
('liuyao', 8L)
('mayun', 9L)

方式4:
#可以给返回的结果起一个别名,或者叫标签:可有可无
ret = session.query(User.name.label('')).all()
print ret,type(ret)
这里的关键是label方法,它的意思是把User的name字段改个名字叫name_label,
其相当于执行以下的SQL语句:
SELECT users.name AS name_label
FROM users
结果:
[('woshiyaoge',), ('woshiyaoge',), ('woshiyaoge',), ('woshiyaoge',), ('sbyao',), ('liuyao',), ('mayun',)] <type 'list'>

方式5:
#查询User表根据id排序
ret = session.query(User).order_by(User.id).all()
print ret
for i in ret:
print(i.name)
结果:
[<__main__.User object at 0x00000000031978D0>, <__main__.User object at 0x0000000003197978>, <__main__.User object at 0x00000000031979E8>, <__main__.User object at 0x0000000003197A58>, <__main__.User object at 0x000000000316BE10>, <__main__.User object at 0x000000000316BE48>, <__main__.User object at 0x0000000003197940>]
woshiyaoge
woshiyaoge
woshiyaoge
woshiyaoge
sbyao
liuyao
mayun

方式6:
#查询user表里根据id排序输入0到3的字段
ret = session.query(User).order_by(User.id)[0:3]
print ret
for i in ret:
print(i.name)
结果:
[<__main__.User object at 0x00000000030F59E8>, <__main__.User object at 0x00000000030C9E80>, <__main__.User object at 0x00000000030C9C88>]
woshiyaoge
woshiyaoge
woshiyaoge
方式7:
# 创建Query查询,filter是where条件,最后调用one()返回唯一行,如果调用all()则返回所有行:
user = session.query(User).filter(User.id=='5').one()
#打印类型和对象的name属性:
print 'type:', type(user)
print 'name:', user.name

7.外键关联

由于关系数据库的多个表还可以用外键实现一对多、多对多等关联,相应地,ORM框架也可以提供两个对象之间的一对多、多对多等功能。

1)一对多(一个User可以有多个Address)
美狮美高梅官方网站 3

外键引用relationship()

例:
#!/usr/bin/env python3
#coding:utf8
#导入所需模块
from sqlalchemy import create_engine,func
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String,ForeignKey
from  sqlalchemy.orm import sessionmaker,relationship
#生成sqlorm基类
Base = declarative_base()
#创建数据库连接 
engine = create_engine("mysql+mysqldb://liuyao:liuyao@121.42.195.15:3306/liuyao", max_overflow=5)
#目的是一个人可以拥有多本书,那么在数据库里的一对多关系
class User(Base):
    #表名
    __tablename__ = 'user'
    #id字段
    id = Column(String(20), primary_key=True)
    #名字字段
    name = Column(String(20))
    # 一对多:#内容不是表名而是定义的表结构名字
    books = relationship('Book')
class Book(Base):
    #表面
    __tablename__ = 'book'
    #id字段
    id = Column(String(20), primary_key=True)
    #名字字段
    name = Column(String(20))
    # “多”的一方的book表是通过外键关联到user表的:
    #ForeignKey是外键 关联user表的id字段
    user_id = Column(String(20), ForeignKey('user.id'))
#创建所需表
Base.metadata.create_all(engine)

if __name__ == '__main__':
    #绑定,生成回话
    SessionCls = sessionmaker(bind=engine)
    session = SessionCls()
    #创建用户
    liuyao = User(id='1',name='liuyao')
    ali=User(id='2',name='ali')
    #添加字段
    session.add_all([liuyao,ali])
    #提交
    session.commit()
    #创建白鹿原这本书,指定谁是拥有者
    Whitedeer = Book(id='1',name='White_deer',user_id = '1')
    #创建三体这本书,指定谁是拥有者
    Threebody = Book(id='2',name='Three_body',user_id = '2')
    #添加字段
    session.add_all([Whitedeer,Threebody])
    #提交
    session.commit()

结果:

表:
mysql> show tables;
+------------------+
| Tables_in_liuyao |
+------------------+
| book             |
| user             |
+------------------+
 rows in set (0.00 sec)

user表:
mysql> select * from user;
+----+--------+
| id | name   |
+----+--------+
| 1  | liuyao |
| 2  | ali    |
+----+--------+
2 rows in set (0.00 sec)

book表#已经显示关联哪个user表id
mysql> select * from book;
+----+------------+---------+
| id | name       | user_id |
+----+------------+---------+
| 1  | White_deer | 1       |
| 2  | Three_body | 2       |
+----+------------+---------+
2 rows in set (0.00 sec)

2)多对多

建立一个双向一对多关系,“反向”是一个许多人,指定一个额外的relationship()函数
并连接两个使用relationship.back_populates参数
简单来说, relationship函数是sqlalchemy对关系之间提供的一种便利的调用方式, backref参数则对关系提供反向引用的声明。在最新版本的sqlalchemy中对relationship引进了back_populates参数。

美狮美高梅官方网站 4

先创建数据库:

#!/usr/bin/env python3
#coding:utf8
from sqlalchemy import Column, Sequence, String, Integer, ForeignKey
from sqlalchemy import create_engine # 导入创建连接驱动
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
from sqlalchemy.orm import relationship, backref
# 这个url可以用urlparse解析, 其中echo=True表示执行时显示sql语句
engine = create_engine("mysql+mysqldb://liuyao:liuyao@121.42.195.15:3306/liuyao", max_overflow=5)
#生成了declarative基类, 以后的model继承此类
Base = declarative_base()
class Parent(Base):
    __tablename__ = 'parent'
    id = Column(Integer, primary_key=True)
    name = Column(String(64),unique=True,nullable=False)
    children = relationship("Child", back_populates="parent")
class Child(Base):
    __tablename__ = 'child'
    id = Column(Integer, primary_key=True)
    name = Column(String(64),unique=True,nullable=False)
    parent_id = Column(Integer, ForeignKey('parent.id'))
    parent = relationship("Parent", back_populates="children")
Base.metadata.create_all(engine) #创建所有表结构
if __name__ == '__main__':
SessionCls = sessionmaker(bind=engine)
#创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例
session = SessionCls()
mama = Parent(id='1',name='mamaxx')
baba = Parent(id='2',name='babaoo')
session.add_all([mama,baba])
# onesb = Child(id='1',name='onesb',parent_id='2')
# twosb = Child(id='2',name='twosb',parent_id='2')
#session.add_all([onesb,twosb])
session.commit()

3.)多对多之三表外键关联
美狮美高梅官方网站 5

#!/usr/bin/env python3
#coding:utf8
from sqlalchemy import create_engine,func,Table
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String,ForeignKey
from  sqlalchemy.orm import sessionmaker,relationship
Base = declarative_base()
#关系表
Host2Group = Table('host_2_group',Base.metadata,
               Column('host_id',ForeignKey('hosts.id'),primary_key=True),
               Column('group_id',ForeignKey('group.id'),primary_key=True),
               )
engine = create_engine("mysql+mysqldb://liuyao:liuyao@121.42.195.15:3306/liuyao", max_overflow=5)
class Host(Base):
    __tablename__ = 'hosts'
    id = Column(Integer,primary_key=True,autoincrement=True)
    hostname = Column(String(64),unique=True,nullable=False)
    ip_addr = Column(String(128),unique=True,nullable=False)
    port = Column(Integer,default=22)
    groups = relationship('Group',
                      secondary= Host2Group,
                      backref = 'host_list')
class Group(Base):
    __tablename__ = 'group'
    id = Column(Integer,primary_key=True)
    name = Column(String(64),unique=True,nullable=False)

if __name__ == '__main__':
    SessionCls = sessionmaker(bind=engine)
    session = SessionCls()
    g1 = Group(name='g1')
    g2 = Group(name='g2')
    g3 = Group(name='g3')
    g4 = Group(name='g4')
    session.add_all([g1,g2,g3,g4])
    session.commit()

orm增删改查

#!/usr/bin/env python3#_*_ coding:utf-8 _*_#Author:wdfrom sqlalchemy import create_engine,Table,Column,Integer,String,ForeignKeyfrom sqlalchemy.orm import sessionmakerfrom sqlalchemy.ext.declarative import declarative_baseengine=create_engine("mysql+pymysql://stu:1234qwer@10.0.0.241:3307/student?charset=gbk",                     max_overflow=5,                     echo=True)#数据库连接信息为,连接类型://用户名:密码@数据库地址:端口/数据库名字?编码#max_overflow创建连接,允许溢出5个连接,echo=True,输出相应的sql信息到控制台,方便调试。base=declarative_base()#生成orm基类class user:  #映射表    __tablename__='user'    id=Column(Integer,autoincrement=True,primary_key=True)    name=Column(String(20))    age=Columnsessoion_class=sessionmaker(bind=engine)#创建与数据库的会话类,这里的sessoion_class是类Session=sessoion_class()#生成会话实例user1=user(name='wd',age=22)#生成user对象Session.add   #添加user1,可以使用add_all,参数为列表或者tupleSession.commit()     #提交#Session.rollback()  #回滚Session.close()      #关闭会话

data=Session.query.filter(user.age==33).delete()Session.commit()        #提交Session.close()      #关闭会话

#data=Session.query.filter(user.age>20).update({"name":'jarry'})#update语法data=Session.query.filter(user.age==22).first()#面向对象语法data.name='coco'#如果data中数据多条需要使用for循环设置Session.commit()        #提交Session.close()      #关闭会话

#!/usr/bin/env python3#_*_ coding:utf-8 _*_#Author:wdfrom sqlalchemy import create_engine,Table,Column,Integer,String,ForeignKeyfrom sqlalchemy.orm import sessionmakerfrom sqlalchemy.ext.declarative import declarative_baseengine=create_engine("mysql+pymysql://stu:1234qwer@10.0.0.241:3307/student?charset=gbk",                     max_overflow=5,                     echo=True)#数据库连接信息为,连接类型://用户名:密码@数据库地址:端口/数据库名字?编码#max_overflow创建连接,允许溢出5个连接,echo=True,输出相应的sql信息到控制台,方便调试。base=declarative_base()#生成orm基类class user:  #映射表    __tablename__='user'    id=Column(Integer,autoincrement=True,primary_key=True)    name=Column(String(20))    age=Column    def __repr__:   #定义        return "" % (self.id,self.name,self.age)sessoion_class=sessionmaker(bind=engine)#创建与数据库的会话类,这里的sessoion_class是类Session=sessoion_class()#生成会话实例#data=Session.query.get  #get语法获取primrykey中的关键字,在这里主键为id,获取id为2的数据#data=Session.query.filter(user.age>22,user.name=='mack').first()#filter语法两个等于号,filter_by语法一个等于号,可以有多个filter,如果多个数据返回列表,first代表获取第一个,为all()获取所有data=Session.query.filter(user.age>20,user.name.in_(['mack','wd'])).all()#in语法print #打印第一个结果Session.commit()        #提交,如果回滚的话,数据将不存在了Session.close()      #关闭会话

美狮美高梅官方网站 6美狮美高梅官方网站 7

Common Filter OperatorsHere’s a rundown of some of the most common operators used in filter():equals:     query.filter(User.name == 'ed')not equals:     query.filter(User.name != 'ed')LIKE:query.filter(User.name.like('%ed%'))IN:NOT IN:query.filter(~User.name.in_(['ed', 'wendy', 'jack']))IS NULL:IS NOT NULL:AND:2.1. ObjectRelationalTutorial 17query.filter(User.name.in_(['ed', 'wendy', 'jack']))# works with query objects too:query.filter(User.name.in_( session.query(User.name).filter(User.name.like('%ed%'))))query.filter(User.name == None)# alternatively, if pep8/linters are a concernquery.filter(User.name.is_query.filter(User.name != None)# alternatively, if pep8/linters are a concernquery.filter(User.name.isnotSQLAlchemy Documentation, Release 1.1.0b1# use and_()from sqlalchemy import and_query.filter(and_(User.name == 'ed', User.fullname == 'Ed Jones'))# or send multiple expressions to .filter()query.filter(User.name == 'ed', User.fullname == 'Ed Jones')# or chain multiple filter()/filter_by() callsquery.filter(User.name == 'ed').filter(User.fullname == 'Ed Jones')Note: Makesureyouuseand_()andnotthePythonandoperator! • OR:Note: Makesureyouuseor_()andnotthePythonoroperator! • MATCH:query.filter(User.name.match('wendy'))Note: match() uses a database-specific MATCH or CONTAINS f 常用查询语法

常用查询

其他操作

##获取所有数据data=Session.query.all()#获取user表所有数据for i in data:    print##统计#count=Session.query.count()#获取所有的条数count=Session.query.filter(user.name.like("ja%")).count()#获取某些条数print##分组from sqlalchemy import func#需要导入func函数res=Session.query(func.count(user.name),user.name).group_by(user.name).all()print

本文由美狮美高梅官方网站发布,转载请注明来源

关键词: