sqlalchemy在pythonweb中开发的使用(基于tornado的基础上)

1、关于SQLAlchemy的安装
pip install SQLAlchemy安装
若是上面的方式安装不成功的状况可使用下面的方法
百度下载window或者linux下面对应的sqlalchemy的版本下载地址
解压下载的压缩包
进去该目录下使用python setup.py install
测试安装是否成功
2、开发基本的配置(以tornado开发为参考)
一、新建一个包取名为models
二、在__init__.py文件中写上基本的配置

#!/usr/bin/env python

# encoding: utf-8

#引入基本的包

from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

 

# 链接数据库的数据

HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'tornadotest'
USERNAME = 'root'
PASSWORD = 'root'

# DB_URI的格式：dialect（mysql/sqlite）+driver://username:password@host:port/database?charset=utf8

DB_URI = 'mysql+pymysql://{}:{}@{}:{}/{}?charset=utf8'.format(USERNAME,PASSWORD,HOSTNAME,PORT,DATABASE)

# 建立引擎

engine = create_engine(DB_URI, echo=False )

# sessionmaker生成一个session类

Session = sessionmaker(bind=engine)
dbSession = Session()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
三、在models包下建立一个实体的类(取名User.py)

# coding=utf-8

from datetime import datetime
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import create_engine, Column, Integer, String, Boolean, DateTime, ForeignKey
from models import engine
from models import dbSession
from sqlalchemy.orm import relationship

Base = declarative_base(engine)

# 定义好一些属性，与user表中的字段进行映射，而且这个属性要属于某个类型

class User(Base):
__tablename__ = 'user1'

id = Column(Integer, primary_key=True, autoincrement=True)
username = Column(String(50), nullable=False)
password = Column(String(100))
createtime = Column(DateTime, default=datetime.now)
last_login = Column(DateTime)
loginnum = Column(Integer, default=0)
_locked = Column(Boolean, default=False, nullable=False)

#能够在类里面写别的方法,相似查询方法
@classmethod
def all(cls):
return dbSession.query(cls).all()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
四、在tornado的.py文件中

# coding:utf8

import tornado.httpserver
import tornado.ioloop
import tornado.options
import tornado.web
from pycket.session import SessionMixin
from tornado.options import define, options
from models import dbSession
from models.User import User1
import creat_tables #单独写一个文件用来建立表的

define("port", default=8000, help="run tornado service", type=int)
define("tables", default=False, group="application", help="creat tables", type=bool)
....
....
if __name__ == "__main__":
tornado.options.parse_command_line()
if options.tables:
creat_tables.run()
app = tornado.web.Application(handlers=[
(r"/", IndexHandle),
(r"/test01", Test01)
], **settings)
app.listen(options.port)
tornado.httpserver.HTTPServer(app)
tornado.ioloop.IOLoop.instance().start()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
五、建立creat_tables.py文件，里面的代码以下:

#coding=utf-8

from models import engine
from models.User import Base

#将建立好的User类，映射到数据库的users表中

def run():
print '------------create_all-------------'
Base.metadata.create_all(engine)
print '------------create_end-------------'
1
2
3
4
5
6
7
8
9
10
11
12
13
六、运行代码建立表

前提是在代码的服务器上建立了数据库
进入对应的工做空间
直接运行python 项目文件名称 --tables[这个地方的名字由这个地方决定:define("tables", default=False, group="application", help="creat tables", type=bool)]
3、关于sqlalchemy的基本操做
一、基本的配置

class BaseHandle(tornado.web.RequestHandler, SessionMixin):
def initialize(self):
self.db = dbSession
print "-----------initialize方法---------"

def get_current_user(self):
username = self.session.get("username")
return username if username else None

def on_finish(self):
self.db.close()
print "-------------on_finish方法----------------"
1
2
3
4
5
6
7
8
9
10
11
12
二、查询数据(在建立数据的实体类中新增类方法)

@classmethod
def all(cls):
return dbSession.query(cls).all()

@classmethod
def by_id(cls, id):
return dbSession.query(cls).filter_by(id=id).first()

@classmethod
def by_name(cls, name):
return dbSession.query(cls).filter_by(username=name).first()
1
2
3
4
5
6
7
8
9
10
11
使用方式

# 测试sqlalchemy的test视图(all返回的是一个`list`,可是`first`返回的是一个对象)

class Test01(BaseHandle):
def get(self):
# ===============写sql语句start==============#
aa = self.db.query(User1).filter(User1.id == 1).all()
print aa
#或者直接使用定义好的方法
print User.all();
# ===============写sql语句end==============#
self.write("我是测试数据")
1
2
3
4
5
6
7
8
9
10
11
12
三、关于增长数据(注意关于增删改的操做要进行commit提交)

user = User()
user.username = xxx
user.password = xxx
self.db.add(user)
self.db.commit()
1
2
3
4
5
四、关于修改数据

#先查询出,而后从新赋值
1
2
3
五、查询User1表中所有数据

user = self.db.query(User1).all()
1
六、查询某些字段

user = self.db.query(User1.username,User1.password).all()
1
七、根据条件查询返回一个对象

user = self.db.query(User1).filter(User1.password == "123").first()
1
八、查询计算总条数

user = self.db.query(User1).count()
1
九、使用limit分页查找

user = self.db.query(User1).limit(3).all()
1
十、slice切片操做

user = self.db.query(User1).slice(1,3).all()
1
十一、使用like进行模糊查询

user = self.db.query(User1).filter(User1.username.like("zhan%")).all()
1
十二、and_的使用(须要先导包from sqlalchemy import text, and_,func)

user = self.db.query(User1).filter(and_(User1.username.like("zhan%"),
User1.password.like("2%"))).all()
1
2
1三、查找大于多少的值

user = self.db.query(User1).filter(User1.loginnum >= 3).all()
1
1四、排序desc的使用

user = self.db.query(User1).order_by(User1.loginnum.desc()).all()
1
1五、filter_by() 使用关键字进行条件查询，不须要用类名指定字段名

user = self.db.query(User).filter_by(username='zhansan').all()
user = self.db.query(User).filter_by(password='222').all()
1
2
1六、update() 更新操做，至关于执行了add操做

self.dbSession.query(User).filter(User.id==1)
.update({User.username:"aaa"})
self.dbSession.commit()
1
2
3
1七、delete删除数据

aa = self.db.query(User).filter(User.id==3).first()
self.db.delete(aa)
1
2
4、关于sqlalchemy中使用mysql的约束
一、主键约束:primary key 不能为空且不能重复
二、主键的自动增加:auto_increment
三、惟一约束:unique
四、非空约束:not null
五、外键约束:foreign key
5、使用execute批量建立数据
self.db.execute(表名.__table__.insert(), [
{'字段名1': randint(1, 100), '字段名2':'aaa','字段名3': randint(1, 100)}
for i in xrange(500)
])
#提交数据
self.db.commit()
1
2
3
4
5
6
6、关于sqlalchemy的一对多的查询(重点也是经常使用的)
一、在一对多的处理中主要使用是一个表的一个字段是别的表某一列中指定的值(所谓的外键约束)
二、在一对多的关系表中子表中使用外键约束[ForeignKey(主表.列名)]注意点主表与子表关联的列的属性要一致
三、父与子表中互相查询使用relationship
四、新建一个学生表(student)和一个班级表(classes)

from sqlalchemy import create_engine, Column, Integer, String, Boolean, DateTime, ForeignKey

#导入relationship

from sqlalchemy.orm import relationship

#新建立一个学生表的类(子表)

class Student(Base):
__tablename__ = "student"
id = Column(Integer, primary_key=True, autoincrement=True)
username = Column(String(100), nullable=False)
create_time = Column(DateTime, default=datetime.now)
# 建立一个外键约束(在子表中建立外键约束，只能是父表中可枚举的值)
class_id = Column(Integer, ForeignKey('classess.id'))
"""
使用relationship()反向查找
理解:
在student表中能够经过classes查找到classess表里面的数据
在classess表里面能够经过students查找到student表里面的数据
"""
classes = relationship("Classess", backref="students")

 

# 建立一个班级表的类(父表)

class Classess(Base):
__tablename__ = "classess"
id = Column(Integer, primary_key=True, autoincrement=True)
classname = Column(String(100), nullable=False)
createtime = Column(DateTime, default=datetime.now)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
四、批量插入数据

#班级表中批量插入

self.db.execute(Classess.__table__.insert(), [
{'classname': str(i) + 'class'} for i in xrange(1, 4)
])
self.db.commit()

#学生表中批量插入

self.db.execute(Student.__table__.insert(), [
{'username': 'username' + str(i),
'class_id': randint(1, 3)} for i in xrange(20)
])
self.db.commit()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
五、关于一对多的查询的使用

#查询语句跟以前介绍的同样的

#经过学生查询到该学生的班级

aa = self.db.query(Student).filter_by(id=1).first()
print aa.classes.classname

#查询班级下全部的学生

bb = self.db.query(Classess).filter_by(id=2).first()
for stu in bb.students:
print stu.username
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
7、关于sqlalchemy的一对一的使用(扩展一张表的信息)
一、新建一个用户表和用户扩展表

# 建立一个用户表的类

class User1(Base):
__tablename__ = 'user1'

id = Column(Integer, primary_key=True, autoincrement=True)
username = Column(String(50), nullable=False)
password = Column(String(100))
createtime = Column(DateTime, default=datetime.now)
last_login = Column(DateTime)
loginnum = Column(Integer, default=0)
_locked = Column(Boolean, default=False, nullable=False)
#添加一个字段关联到子表
user1Ext = relationship("User1Ext",uselist=False)

#建立一个用户表的扩展表

class User1Ext(Base):
__tablename__ = "user1ext"
id = Column(Integer,primary_key=True)
sex = Column(String(10))
age = Column(Integer)
#扩展表当作是一个子表添加一个外键约束
user_id = Column(Integer,ForeignKey("user1.id"),unique=True)
#添加一个与user关联的字段
user = relationship("User1",uselist=False)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
二、添加数据

用户表

用户扩展表

 

#根据用户表查询到用户扩展表

aa = self.db.query(User1).filter_by(id=17).first()
print aa.user1Ext.sex

#根据用户扩展表查询用户信息

bb = self.db.query(User1Ext).filter_by(id=1).first()
print bb.user.username
1
2
3
4
5
6
7
8
9
10
11
8、多对多的查询(须要一张中间表，而后根据一对多的方式查询)
案例:一个学生能够有多个学科，一个学科有多个学生

一、建立一张学生表的试视图类

# 建立学生表

class Student(Base):
__tablename__ = "student"
id = Column(Integer, primary_key=True, autoincrement=True)
username = Column(String(100), nullable=False)
createtime = Column(DateTime, default=datetime.now)
# 新增关联到学科表的字段(secondary表示第二张表的意思,StudentToScore是中间表)
student_core = relationship("Core", secondary=StudentToScore.__table__)
1
2
3
4
5
6
7
8
9
10
二、建立一个学科表的视图类

# 建立学科表

class Core(Base):
__tablename__ = "score"
id = Column(Integer, primary_key=True, autoincrement=True)
corename = Column(String(100), nullable=False)
core = Column(Integer)
# 新增关联到学生表的字段(secondary表示第二张表的意思,StudentToScore是中间表)
student_core = relationship("Student", secondary=StudentToScore.__table__)
1
2
3
4
5
6
7
8
9
10
三、建立一个中间表来关联学生表与学科表

# 建立中间表

class StudentToScore(Base):
__tablename__ = "student_to_score"
student_id = Column(Integer, ForeignKey("student.id"), primary_key=True)
score_id = Column(Integer, ForeignKey("score.id"), primary_key=True)
1
2
3
4
5
6
7
四、总结上面建立的三张表

一、多对多的关系必须建立一个中间表做为桥梁
二、中间表是这两张表的子表，经过外键约束到对应，而后经过双主键约束
三、在各自的表中加上relationship()去关联对应的表
五、批量建立数据(注意先插入学生表与学科表数据后插入中间表的)

#批量插入学生表数据

self.db.execute(Student.__table__.insert(), [
{'username': 'username' + str(i + 1),'class_id': randint(1, 3)} for i in xrange(20)
])
self.db.commit()

#批量插入学科表数据

self.db.execute(Core.__table__.insert(), [
{'corename': 'coursename' + str(i + 1),'score': randint(60, 80)} for i in xrange(5)
])

#批量插入中间表数据

self.db.execute(StudentToScore.__table__.insert(), [
{'student_id': randint(1, 20),'score_id': randint(1, 5)} for i in xrange(10)])
self.db.commit()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
六、测试代码

#查询学生表id=1的学科

aa = self.db.query(Student).filter_by(id=1).first()
for a in aa.student_core:
print a.corename

#查询学科id=1下所有的学生

bb = self.db.query(Core).filter_by(id=1).first()for b in bb.student_score: print b.username--------------------- 做者：水痕01 来源：CSDN 原文：https://blog.csdn.net/kuangshp128/article/details/73413584 版权声明：本文为博主原创文章，转载请附上博文连接！