澳门新萄京官方网站-www.8455.com-澳门新萄京赌场网址

澳门新萄京官方网站ORM框架与mysql数据库的无缝对

2019-09-11 作者:www.8455.com   |   浏览(64)

ORM
现行反革命大家聊聊深远操作数据库了。
世家都清楚,使用数据库的原生语句来写,一旦数据量了,首先就得疯狂重复写代码,何况还基本不怎么重用,都是一回写死,前面需求又得再写,那么面前遭逢对象编制程序的为主里面教您四个直面临象数据库,那年大家看效果
普普通通sql数据库建表一从头这样:

ORM框架与mysql数据库的无缝过渡,orm框架mysql数据库

ORM
当今大家聊聊深远操作数据库了。
大家都知情,使用数据库的原生语句来写,一旦数据量了,首先就得疯狂重复写代码,而且还着力不怎么重用,都以三次写死,后边须要又得再写,那么面临对象编程的主干里面教你三个面前碰着对象数据库,这一年大家看效用
一般sql数据库建表一初叶那样:

1 create table table_name(id int not null auto_increment,
2                         name varchar(32),
3                         password varchar(32),
4                          primary key(id)
5                          )

那是特别轻巧的sql的表,假使复杂点,加些什么关系的,推测头都要炸,那么,orm是何许鬼?它是三个框架,封装了数据库原语,大家得以面向对象来戏弄数据库了。

import sqlalchemy
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import create_engine
from sqlalchemy import Colum,Integer,String
from sqlalchemy.orm import sessionmaker

engine=create_engine('mysql pymysql://root:[email protected]/slkdb',encoding ='utf-8',echo=True)
'''
注意写法,orm支持很多借口,我这里是用pymysql,所以是
mysql pymysql://<user>:<password>@<host>/<dbname> #user是用户名,password是密码,host是数据库所在ip地址,dbname是要处理的数据表名字,什么,你的数据表不支持中文?报错?什么拉丁的错?我告诉你,只要在dbname后面加一个?charset=utf8 既可解决

中文支持写法:engine=create_engine('mysql pymysql://root:[email protected]/slkdb?charset=utf8',encoding ='utf-8',echo=True)

由于我是python3,不支持安装MySQL-Python这个模块,这个接口对应的创建就不写了。
'''
Base = declarative_base()#生成orm基类
class User(Base):
    __tablename__='user'#表名
    id = Colum(Integer,primary_key=True)
    name = Colum(String(32))
    password = Colum(String(32))
Base.metadata.create_all(engine)#创建表结构
session_class=sessionmaker(bind=engine)#创建一个数据库的会话,注意这里只是创建了对象
session=session_class()#此时才是生成实例,相当于cursor
User1=User(name='hehe',password = '456456')#生成要生成的数据对象
User2=User(name='zhaff',password = '298789')#生成要生成的数据对象
session.add(User1)
session.add(User2)
session.commit()#此时提交后才最终把数据创建完毕

  

在用配置类的秘诀给app设置配置时,SQLALCHEMY_ECHO 这么些是记录打印SQL语句用于调节和测量检验的, 一般设置为False, 不然会在调控台出口一大堆的事物

从今接触了python,就被深深的抓住,首先是它往往现身在自己职业选拔的出名GIS软件中,叁回为了给二个GIS软件写点脚本,就尝试了一晃,这一品尝不妨,心从此就被她栓住了,再付出什么东西首先就思量用python去做。

SQLAlchemy的观念是,SQL数据库的量级和总体性首要于对象会集;而指标集结的抽象又首要于表和行。

1 create table table_name(id int not null auto_increment,
2                         name varchar(32),
3                         password varchar(32),
4                          primary key(id)
5                          )

好了 数据也插入进去了运行结果消息:

2018-03-06 15:49:45,082 INFO sqlalchemy.engine.base.Engine SHOW VARIABLES LIKE 'sql_mode'
2018-03-06 15:49:45,082 INFO sqlalchemy.engine.base.Engine {}
2018-03-06 15:49:45,085 INFO sqlalchemy.engine.base.Engine SELECT DATABASE()
2018-03-06 15:49:45,085 INFO sqlalchemy.engine.base.Engine {}
2018-03-06 15:49:45,085 INFO sqlalchemy.engine.base.Engine show collation where `Charset` = 'utf8' and `Collation` = 'utf8_bin'
2018-03-06 15:49:45,085 INFO sqlalchemy.engine.base.Engine {}
2018-03-06 15:49:45,086 INFO sqlalchemy.engine.base.Engine SELECT CAST('test plain returns' AS CHAR(60)) AS anon_1
2018-03-06 15:49:45,086 INFO sqlalchemy.engine.base.Engine {}
2018-03-06 15:49:45,087 INFO sqlalchemy.engine.base.Engine SELECT CAST('test unicode returns' AS CHAR(60)) AS anon_1
2018-03-06 15:49:45,087 INFO sqlalchemy.engine.base.Engine {}
2018-03-06 15:49:45,087 INFO sqlalchemy.engine.base.Engine SELECT CAST('test collated returns' AS CHAR CHARACTER SET utf8) COLLATE utf8_bin AS anon_1
2018-03-06 15:49:45,087 INFO sqlalchemy.engine.base.Engine {}
2018-03-06 15:49:45,088 INFO sqlalchemy.engine.base.Engine DESCRIBE `user`
2018-03-06 15:49:45,088 INFO sqlalchemy.engine.base.Engine {}
2018-03-06 15:49:45,091 INFO sqlalchemy.engine.base.Engine BEGIN (implicit)
2018-03-06 15:49:45,092 INFO sqlalchemy.engine.base.Engine INSERT INTO user (name, password) VALUES (%(name)s, %(password)s)
2018-03-06 15:49:45,092 INFO sqlalchemy.engine.base.Engine {'name': 'hehe', 'password': '456456'}
2018-03-06 15:49:45,092 INFO sqlalchemy.engine.base.Engine INSERT INTO user (name, password) VALUES (%(name)s, %(password)s)
2018-03-06 15:49:45,092 INFO sqlalchemy.engine.base.Engine {'name': 'zhaff', 'password': '298789'}
2018-03-06 15:49:45,093 INFO sqlalchemy.engine.base.Engine COMMIT


'''注意:运营进度中只怕晤面世 Warning: (1366, "Incorrect string value: '\xD6\xD0\xB9\xFA\xB1\xEA...' for column 'VARIABLE_VALUE' at row 481")
result = self._query(query)
如此的警戒可能别的巴拉巴拉的警戒,那一年不经意它既可,因为她单纯是告诫,而不是error,程序还是好端端运作,数据库表内数据已经济建设立。技能有限,前段时间尚未减轻这么些标题,前期有时机笔者优化'''
世家大概看到那会以为麻蛋怎么更目眩神摇了的痛感,毕竟那么多包模块的各类乱入还应该有各样对象创设看起来很复杂,

好,是时候上演实在的手艺了:

追加数据现已说过,就地点的add,上面说查询

data = session.query(User).filter(User.id>=1).filter(User.id<4).all()#多规格查询,直接三个filter既可,这里的暗号都以相比,单等号会出错哟~

print(data)

也得以动用in_([*arg]),表示在arg元组中相称

data = session.query(User).filter(User.name.in_(['zhaoxin','zhaff'])).all()
print(data)

输出:[zhaoxin : 29999, zhaoxin : 29999, zhaff : 298789]

修改:
data = session.query(User).filter(User.name=='hehe').all()[0]#多规格查询,这里的all[0]也得以用frist()代替
print(data)
data.name = 'sb'
session.commit()#修改必要交给,不然不大概修改,一般单个修改非常多,多种修改能够用
print(data)

/home/python/.virtualenvs/py3_flask/bin/python /home/python/Desktop/test/demo_sqlalchemy.py
2018-12-27 17:46:54,205 INFO sqlalchemy.engine.base.Engine SHOW VARIABLES LIKE 'sql_mode'
2018-12-27 17:46:54,205 INFO sqlalchemy.engine.base.Engine {}
2018-12-27 17:46:54,208 INFO sqlalchemy.engine.base.Engine SHOW VARIABLES LIKE 'lower_case_table_names'
2018-12-27 17:46:54,208 INFO sqlalchemy.engine.base.Engine {}
2018-12-27 17:46:54,211 INFO sqlalchemy.engine.base.Engine SELECT DATABASE()
2018-12-27 17:46:54,211 INFO sqlalchemy.engine.base.Engine {}
2018-12-27 17:46:54,212 INFO sqlalchemy.engine.base.Engine show collation where `Charset` = 'utf8mb4' and `Collation` = 'utf8mb4_bin'
2018-12-27 17:46:54,212 INFO sqlalchemy.engine.base.Engine {}
2018-12-27 17:46:54,214 INFO sqlalchemy.engine.base.Engine SELECT CAST('test plain returns' AS CHAR AS anon_1
2018-12-27 17:46:54,214 INFO sqlalchemy.engine.base.Engine {}
2018-12-27 17:46:54,215 INFO sqlalchemy.engine.base.Engine SELECT CAST('test unicode returns' AS CHAR AS anon_1
2018-12-27 17:46:54,215 INFO sqlalchemy.engine.base.Engine {}
2018-12-27 17:46:54,216 INFO sqlalchemy.engine.base.Engine SELECT CAST('test collated returns' AS CHAR CHARACTER SET utf8mb4) COLLATE utf8mb4_bin AS anon_1
2018-12-27 17:46:54,216 INFO sqlalchemy.engine.base.Engine {}
2018-12-27 17:46:54,217 INFO sqlalchemy.engine.base.Engine DESCRIBE `user`
2018-12-27 17:46:54,217 INFO sqlalchemy.engine.base.Engine {}
2018-12-27 17:46:54,218 INFO sqlalchemy.engine.base.Engine DESCRIBE `role`
2018-12-27 17:46:54,218 INFO sqlalchemy.engine.base.Engine {}
* Running on (Press CTRL C to quit)
* Restarting with stat
2018-12-27 17:46:54,661 INFO sqlalchemy.engine.base.Engine SHOW VARIABLES LIKE 'sql_mode'
2018-12-27 17:46:54,661 INFO sqlalchemy.engine.base.Engine {}
2018-12-27 17:46:54,663 INFO sqlalchemy.engine.base.Engine SHOW VARIABLES LIKE 'lower_case_table_names'
2018-12-27 17:46:54,663 INFO sqlalchemy.engine.base.Engine {}
2018-12-27 17:46:54,667 INFO sqlalchemy.engine.base.Engine SELECT DATABASE()
2018-12-27 17:46:54,667 INFO sqlalchemy.engine.base.Engine {}
2018-12-27 17:46:54,668 INFO sqlalchemy.engine.base.Engine show collation where `Charset` = 'utf8mb4' and `Collation` = 'utf8mb4_bin'
2018-12-27 17:46:54,668 INFO sqlalchemy.engine.base.Engine {}
2018-12-27 17:46:54,670 INFO sqlalchemy.engine.base.Engine SELECT CAST('test plain returns' AS CHAR AS anon_1
2018-12-27 17:46:54,670 INFO sqlalchemy.engine.base.Engine {}
2018-12-27 17:46:54,670 INFO sqlalchemy.engine.base.Engine SELECT CAST('test unicode returns' AS CHAR AS anon_1
2018-12-27 17:46:54,671 INFO sqlalchemy.engine.base.Engine {}
2018-12-27 17:46:54,671 INFO sqlalchemy.engine.base.Engine SELECT CAST('test collated returns' AS CHAR CHARACTER SET utf8mb4) COLLATE utf8mb4_bin AS anon_1
2018-12-27 17:46:54,671 INFO sqlalchemy.engine.base.Engine {}
2018-12-27 17:46:54,672 INFO sqlalchemy.engine.base.Engine DESCRIBE `user`
2018-12-27 17:46:54,672 INFO sqlalchemy.engine.base.Engine {}
2018-12-27 17:46:54,674 INFO sqlalchemy.engine.base.Engine DESCRIBE `role`
2018-12-27 17:46:54,674 INFO sqlalchemy.engine.base.Engine {}
* Debugger is active!
* Debugger PIN: 983-796-441

缘何会被python吸引的,我探究后得出这几个结论:

**一 安装 SQLAlchemy

那是特别轻便的sql的表,即便复杂点,加些什么关系的,揣摸头都要炸,那么,orm是怎么样鬼?它是三个框架,封装了数据库原语,大家得以面向对象来戏弄数据库了。

输出结果:

hehe : 456456

1、语言轻便,亲昵,容命理术数习

**

import sqlalchemy
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import create_engine
from sqlalchemy import Colum,Integer,String
from sqlalchemy.orm import sessionmaker

engine=create_engine('mysql pymysql://root:123456@localhost/slkdb',encoding ='utf-8',echo=True)
'''
注意写法,orm支持很多借口,我这里是用pymysql,所以是
mysql pymysql://<user>:<password>@<host>/<dbname> #user是用户名,password是密码,host是数据库所在ip地址,dbname是要处理的数据表名字,什么,你的数据表不支持中文?报错?什么拉丁的错?我告诉你,只要在dbname后面加一个?charset=utf8 既可解决

中文支持写法:engine=create_engine('mysql pymysql://root:123456@localhost/slkdb?charset=utf8',encoding ='utf-8',echo=True)

由于我是python3,不支持安装MySQL-Python这个模块,这个接口对应的创建就不写了。
'''
Base = declarative_base()#生成orm基类
class User(Base):
    __tablename__='user'#表名
    id = Colum(Integer,primary_key=True)
    name = Colum(String(32))
    password = Colum(String(32))
Base.metadata.create_all(engine)#创建表结构
session_class=sessionmaker(bind=engine)#创建一个数据库的会话,注意这里只是创建了对象
session=session_class()#此时才是生成实例,相当于cursor
User1=User(name='hehe',password = '456456')#生成要生成的数据对象
User2=User(name='zhaff',password = '298789')#生成要生成的数据对象
session.add(User1)
session.add(User2)
session.commit()#此时提交后才最终把数据创建完毕

sb : 456456

同理 删除便是delete了
data = session.query(User).filter(User.name=='sb').all()[0]#多规格查询,这里的all[0]也得以用frist()替代
print(data)
data.name = 'sb'
session.commit()
如此那般便删除了名称为'sb'的数目。

删改查都以先query查到后才做的改变,那一点而不是弄混了。

分组计算

总括大家都精通,count,那么这里自然正是

data = session.query(User).filter(User.name=='sb').count()#从不all,写了all就一定于二个类了,那么此时count就改成了类措施,错误提醒该User类中从不count这么些attribute。

分组总括
from sqlalchemy import func
data = session.query(User.name,func.count(User.name)).group_by(User.name).all()

2、开源的库众多,只要你能想到就能够赢得

复制代码 代码如下:

  

print(data)

输出:[('zhaff', 1), ('zhaoxin', 2)]
group_by的效劳就和命令行的group by同样,详细的情况移步:

连表查询:

这时候借使成立了四个新的类对象。
class Bala(Base):
*****此间省略了
同上平等

那就是说八个表,我们要涉及他们五个,比方表内 name这栏,名字同样的全给笔者弄出来
result = session.query(User,Bala).filter(User.name == Bala.name).all()#这种是强制钦点name联系的,无需有外键联系
出口结果以列表套元组格式出现,每一种元组中对应的正是User.name == Bala.name对应的那两条数据的详细新闻。那就不演示了。
有外键联系的能够应用
result = session.query(User).join(Bala).all()#来实现
上面orm最牛逼的地点就是外键关联的方便性,直接上代码:

import sqlalchemy
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import create_engine
from sqlalchemy import Column,Integer,String,ForeignKey
from sqlalchemy.orm import sessionmaker,relationship

engine=create_engine('mysql pymysql://root:[email protected]/slkdb',encoding ='utf-8')
Base = declarative_base()#生成orm基类
class Student(Base):#重新生成两个数据表,之前的都删了重新开始
    __tablename__='student'#表名
    id = Column(Integer,primary_key=True)
    name = Column(String(32),nullable=False)
    register_date = Column(String(32),nullable=False)

    def __repr__(self):
        return 'ID:%s,name: %s'%(self.id,self.name)
class Stu_record(Base):
    __tablename__='stcored'
    id = Column(Integer,primary_key=True)
    day = Column(Integer)
    statue = Column(String(32),nullable=False)
    stu_id = Column(Integer, ForeignKey('student.id'))#外键关联就在这,注意是table_name名.id而不是类对象名.id
    student = relationship('Student',backref='my_study_recode')#这个实现了反向查询,这行代码相当于实例化一个Student的对象实例,此时下面的self.student.name可以调用,通过my_study_recode可以调用Stu_record这个对象的属性,这个函数是从内存中调用,python中封装出来的,并不是数据库里面的功能,如此方便很多倍
    def __repr__(self):
        return '%s第%s天的登录状态%s'%(self.student.name,self.day,self.statue)

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

session_class=sessionmaker(bind=engine)
session=session_class()
s1 = Student(name='zhaoxin',register_date='2011-02-14')
s2 = Student(name='jianji',register_date='2012-01-14')
s3 = Student(name='ruizi',register_date='2011-05-14')
s4 = Student(name='luoli',register_date='2011-06-11')
t1 = Stu_record(day=1,statue='YES',stu_id=1)
t2 = Stu_record(day=2,statue='NO',stu_id=1)
t3 = Stu_record(day=3,statue='YES',stu_id=1)
t4 = Stu_record(day=4,statue='NO',stu_id=1)
t5 = Stu_record(day=5,statue='YES',stu_id=2)
session.add_all([s1,s2,s3,s4,t1,t2,t3,t4,t5])
session.commit()
s_obj=session.query(Student).filter(Student.name=='zhaoxin').first()#此时返回的是student这个类
print(s_obj.my_study_recode)#通过关联,这个关联是内存里进行的通过类之间的映射,反查到Stu_record中所有的属性,并调用Stu_record的__repr__函数。

  


[zhaoxin第1天的报到状态YES, zhaoxin第2天的报到意况NO, zhaoxin第3天的记名状态YES, zhaoxin第4天的登入状态NO]

一对多外键关联也是不期而遇,可是照旧要留神多少个细节:
在论及时,大家都清楚了是周围那样的stu_id = Column(Integer, ForeignKey('student.id')),那么这么一对多表示着如此的代码不仅仅一行,关联的键不平等;
那就是说有几条那个,就有几条看似student = relationship('Student',backref='my_study_recode')的代码,那一年要钦命
foreign_keys = [***这里是本对象下关联外键的属性名***],如此一来Computer就会辨别到底什么人关联了哪个人,就不会分不清,借使把那些写进函数,那么Computer就能够搅乱,然后报错:大致说的就是有多个foreign_keys关联在这一个表里,foreign_keys那几个天性应该钦赐,不然会傻傻分不清楚。

好了,上边最后讲下最关键的多对多关系

直白在代码里面解说,重新创立新表。(为了演示效果,作者尚未分开放,作为合格的开拓职员,创制和改动查询等公事写在贰个代码里实为不妥,可是此间是自己要作为典范遵从规则,就写一同了。)

import sqlalchemy
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import create_engine,Table
from sqlalchemy import Column,Integer,String,ForeignKey
from sqlalchemy.orm import sessionmaker,relationship

engine=create_engine('mysql pymysql://root:[email protected]/slkdb?charset=utf8')
Base = declarative_base()
book_m2m_author =Table('book_m2m_author',Base.metadata,
                       Column('book_id',Integer,ForeignKey('book.id')),
                       Column('author_id',Integer,ForeignKey('author.id'))
                       )#为什么不用class的方式创建这个表呢?因为我不会在里面插任何数据或者更改,我只需要改源数据就是那两个class里面的,那么这个由映射都会自动更改

class Book(Base):
    __tablename__='book'
    id=Column(Integer,primary_key=True)
    name = Column(String(32))
    put_date = Column(String(32))
    authors = relationship('Author',secondary=book_m2m_author,backref='books')#连接author表,查询时通过第三张表book_m2m_author查询
    def __repr__(self):
        return self.name

class Author(Base):
    __tablename__='author'
    id = Column(Integer, primary_key=True)
    name = name = Column(String(32))
    def __repr__(self):
        return self.name

Base.metadata.create_all(engine)


session_class=sessionmaker(bind=engine)
session=session_class()

b1=Book(name='圣墟 琴帝',put_date='2016-6-12')
b2=Book(name='长生界 我欲封天',put_date='2013-2-19')
b3=Book(name='神墓 求魔',put_date='2009-10-11')
b4=Book(name='仙逆 一念永恒',put_date='2011-6-12')
b5=Book(name='斗罗大陆 遮天',put_date='2010-8-2')
b6=Book(name='三合一',put_date='2018-3-7')

a1=Author(name='辰东')
a2=Author(name='耳根')
a3=Author(name='唐家三少')

b1.authors=[a1,a3]#第三个表通过这个方式关联起author和book这两个表格,以下同。就是Book类中authors里的secondary这个属性的实现。
b2.authors=[a1,a2]
b3.authors=[a1,a2]
b4.authors=[a2,a3]
b5.authors=[a3,a1]
b6.authors=[a1,a2,a3]
session.add_all([b1,b2,b3,b4,b5,b6,a1,a2,a3])
session.commit()

author_obj = session.query(orm_m2m.Author).filter(orm_m2m.Author.name=='辰东').first()
print(author_obj.books)#通过book实现到Book里面调用匹配辰东属性的反查效果
book_obj = session.query(orm_m2m.Book).filter(orm_m2m.Book.name=='三合一').first()
print(book_obj,book_obj.authors)#如此就实现作者查书 和书查作者的关联

  


输出:
[圣墟 琴帝, 长生界 笔者欲封天, 神墓 求魔, 斗罗大陆 遮天, 三合一]
三合一 [辰东, 耳根, 唐家三少]

好了,到此地orm具体也讲完了,实际生活中,多表格关联会数不清,借令你看的一脸懵逼,那对不起,可能我本人水平还不高,不能疏解入微,人生苦短,作者用python。

 

ORM 现在大家聊聊深入操作数据库了。 我们都清楚,使用数据库的原生语句来写,一旦数...

 

pip install sqlalchemy

好了 数据也插入进去了运转结果新闻:

2018-03-06 15:49:45,082 INFO sqlalchemy.engine.base.Engine SHOW VARIABLES LIKE 'sql_mode'
2018-03-06 15:49:45,082 INFO sqlalchemy.engine.base.Engine {}
2018-03-06 15:49:45,085 INFO sqlalchemy.engine.base.Engine SELECT DATABASE()
2018-03-06 15:49:45,085 INFO sqlalchemy.engine.base.Engine {}
2018-03-06 15:49:45,085 INFO sqlalchemy.engine.base.Engine show collation where `Charset` = 'utf8' and `Collation` = 'utf8_bin'
2018-03-06 15:49:45,085 INFO sqlalchemy.engine.base.Engine {}
2018-03-06 15:49:45,086 INFO sqlalchemy.engine.base.Engine SELECT CAST('test plain returns' AS CHAR(60)) AS anon_1
2018-03-06 15:49:45,086 INFO sqlalchemy.engine.base.Engine {}
2018-03-06 15:49:45,087 INFO sqlalchemy.engine.base.Engine SELECT CAST('test unicode returns' AS CHAR(60)) AS anon_1
2018-03-06 15:49:45,087 INFO sqlalchemy.engine.base.Engine {}
2018-03-06 15:49:45,087 INFO sqlalchemy.engine.base.Engine SELECT CAST('test collated returns' AS CHAR CHARACTER SET utf8) COLLATE utf8_bin AS anon_1
2018-03-06 15:49:45,087 INFO sqlalchemy.engine.base.Engine {}
2018-03-06 15:49:45,088 INFO sqlalchemy.engine.base.Engine DESCRIBE `user`
2018-03-06 15:49:45,088 INFO sqlalchemy.engine.base.Engine {}
2018-03-06 15:49:45,091 INFO sqlalchemy.engine.base.Engine BEGIN (implicit)
2018-03-06 15:49:45,092 INFO sqlalchemy.engine.base.Engine INSERT INTO user (name, password) VALUES (%(name)s, %(password)s)
2018-03-06 15:49:45,092 INFO sqlalchemy.engine.base.Engine {'name': 'hehe', 'password': '456456'}
2018-03-06 15:49:45,092 INFO sqlalchemy.engine.base.Engine INSERT INTO user (name, password) VALUES (%(name)s, %(password)s)
2018-03-06 15:49:45,092 INFO sqlalchemy.engine.base.Engine {'name': 'zhaff', 'password': '298789'}
2018-03-06 15:49:45,093 INFO sqlalchemy.engine.base.Engine COMMIT


'''注意:运行进度中也许相会世 Warning: (1366, "Incorrect string value: '\xD6\xD0\xB9\xFA\xB1\xEA...' for column 'VARIABLE_VALUE' at row 481")
result = self._query(query)
那样的警戒或然别的巴拉巴拉的警戒,这年不经意它既可,因为她单独是告诫,并非error,程序照旧好端端运行,数据库表内数据已经制造。技巧有限,这几天从不减轻那么些难点,前期有机遇小编优化'''
世家兴许看到那会感到到麻蛋怎么更扑朔迷离了的感到到,毕竟那么多包模块的各类乱入还恐怕有各类对象成立看起来很复杂,

好,是时候上演的确的技能了:

追加数量已经说过,就地方的add,下边说查询

data = session.query(User).filter(User.id>=1).filter(User.id<4).all()#多规格查询,间接多少个filter既可,这里的符号都以比较,单等号会出错哟~

print(data)

也得以利用in_([*arg]),表示在arg元组中相称

data = session.query(User).filter(User.name.in_(['zhaoxin','zhaff'])).all()
print(data)

输出:[zhaoxin : 29999, zhaoxin : 29999, zhaff : 298789]

修改:
data = session.query(User).filter(User.name=='hehe').all()[0]#多规格查询,这里的all[0]也足以用frist()代替
print(data)
data.name = 'sb'
session.commit()#修改必要付出,不然不可能修改,一般单个修改比较多,多种修改能够用
print(data)

得知有一个很NB的ORM框架SQLAlchemy,所以筹划攻读一下,在此从前日起就初步做学习笔记,希望能坚持不渝下去,本笔记简要记录一些自身学习中的心得和要义,尽量多写一些代码轨范供之后翻看,学习前就说那样多了,下边就起来吧!

导入若无报错则设置成功

输出结果:

hehe : 456456

澳门新萄京官方网站 1

复制代码 代码如下:

sb : 456456

同理 删除便是delete了
data = session.query(User).filter(User.name=='sb').all()[0]#多规格查询,这里的all[0]也能够用frist()替代
print(data)
data.name = 'sb'
session.commit()
如此便删除了名称为'sb'的数额。

删改查都以先query查到后才做的修改,那一点实际不是弄混了。

分组总计

总括大家都掌握,count,那么这里自然就是

data = session.query(User).filter(User.name=='sb').count()#不曾all,写了all就一定于四个类了,那么此时count就改为了类措施,错误提醒该User类中从未count这么些attribute。

分组总括
from sqlalchemy import func
data = session.query(User.name,func.count(User.name)).group_by(User.name).all()

 

>>> import sqlalchemy
>>> sqlalchemy.__version__
'0.9.1'
>>>

print(data)

输出:[('zhaff', 1), ('zhaoxin', 2)]
group_by的效果就和命令行的group by同样,详细的情况移步:

连表查询:

那时候假使创设了二个新的类对象。
class Bala(Base):
*****这里省略了
同上同一

那就是说三个表,我们要涉及他们三个,比方表内 name那栏,名字一样的全给自家弄出来
result = session.query(User,Bala).filter(User.name == Bala.name).all()#这种是强制指定name联系的,无需有外键联系
输出结果以列表套元组格式出现,各样元组中对应的正是User.name == Bala.name对应的这两条数据的详细消息。那就不演示了。
有外键联系的可以应用
result = session.query(User).join(Bala).all()#来实现
上面orm最牛逼的地方正是外键关联的方便性,直接上代码:

import sqlalchemy
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import create_engine
from sqlalchemy import Column,Integer,String,ForeignKey
from sqlalchemy.orm import sessionmaker,relationship

engine=create_engine('mysql pymysql://root:123456@localhost/slkdb',encoding ='utf-8')
Base = declarative_base()#生成orm基类
class Student(Base):#重新生成两个数据表,之前的都删了重新开始
    __tablename__='student'#表名
    id = Column(Integer,primary_key=True)
    name = Column(String(32),nullable=False)
    register_date = Column(String(32),nullable=False)

    def __repr__(self):
        return 'ID:%s,name: %s'%(self.id,self.name)
class Stu_record(Base):
    __tablename__='stcored'
    id = Column(Integer,primary_key=True)
    day = Column(Integer)
    statue = Column(String(32),nullable=False)
    stu_id = Column(Integer, ForeignKey('student.id'))#外键关联就在这,注意是table_name名.id而不是类对象名.id
    student = relationship('Student',backref='my_study_recode')#这个实现了反向查询,这行代码相当于实例化一个Student的对象实例,此时下面的self.student.name可以调用,通过my_study_recode可以调用Stu_record这个对象的属性,这个函数是从内存中调用,python中封装出来的,并不是数据库里面的功能,如此方便很多倍
    def __repr__(self):
        return '%s第%s天的登录状态%s'%(self.student.name,self.day,self.statue)

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

session_class=sessionmaker(bind=engine)
session=session_class()
s1 = Student(name='zhaoxin',register_date='2011-02-14')
s2 = Student(name='jianji',register_date='2012-01-14')
s3 = Student(name='ruizi',register_date='2011-05-14')
s4 = Student(name='luoli',register_date='2011-06-11')
t1 = Stu_record(day=1,statue='YES',stu_id=1)
t2 = Stu_record(day=2,statue='NO',stu_id=1)
t3 = Stu_record(day=3,statue='YES',stu_id=1)
t4 = Stu_record(day=4,statue='NO',stu_id=1)
t5 = Stu_record(day=5,statue='YES',stu_id=2)
session.add_all([s1,s2,s3,s4,t1,t2,t3,t4,t5])
session.commit()
s_obj=session.query(Student).filter(Student.name=='zhaoxin').first()#此时返回的是student这个类
print(s_obj.my_study_recode)#通过关联,这个关联是内存里进行的通过类之间的映射,反查到Stu_record中所有的属性,并调用Stu_record的__repr__函数。

  


[zhaoxin第1天的报到状态YES, zhaoxin第2天的记名意况NO, zhaoxin第3天的记名状态YES, zhaoxin第4天的登入状态NO]

一对多外键关联也是不期而同,可是依旧要注意多少个细节:
在涉及时,大家都通晓了是相仿那样的stu_id = Column(Integer, ForeignKey('student.id')),那么这么一对多表示着如此的代码不仅仅一行,关联的键不平等;
那么有几条那个,就有几条看似student = relationship('Student',backref='my_study_recode')的代码,这一年要钦定
foreign_keys = [***此地是本对象下关联外键的属性名***],如此一来Computer就会分辨到底何人关联了何人,就不会分不清,假如把那么些写进函数,那么Computer就能搅乱,然后报错:大致说的就是有多个foreign_keys关联在那么些表里,foreign_keys那性情子应该钦命,不然会傻傻分不清楚。

好了,下边最终讲下最关键的多对多涉及

一向在代码里面批注,重新创建新表。(为了演示效果,作者尚未分开放,作为合格的开辟职员,创设和改造查询等公事写在二个代码里实为不妥,不过此间是自己要作为表率遵从规则,就写一齐了。)

import sqlalchemy
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import create_engine,Table
from sqlalchemy import Column,Integer,String,ForeignKey
from sqlalchemy.orm import sessionmaker,relationship

engine=create_engine('mysql pymysql://root:123456@localhost/slkdb?charset=utf8')
Base = declarative_base()
book_m2m_author =Table('book_m2m_author',Base.metadata,
                       Column('book_id',Integer,ForeignKey('book.id')),
                       Column('author_id',Integer,ForeignKey('author.id'))
                       )#为什么不用class的方式创建这个表呢?因为我不会在里面插任何数据或者更改,我只需要改源数据就是那两个class里面的,那么这个由映射都会自动更改

class Book(Base):
    __tablename__='book'
    id=Column(Integer,primary_key=True)
    name = Column(String(32))
    put_date = Column(String(32))
    authors = relationship('Author',secondary=book_m2m_author,backref='books')#连接author表,查询时通过第三张表book_m2m_author查询
    def __repr__(self):
        return self.name

class Author(Base):
    __tablename__='author'
    id = Column(Integer, primary_key=True)
    name = name = Column(String(32))
    def __repr__(self):
        return self.name

Base.metadata.create_all(engine)


session_class=sessionmaker(bind=engine)
session=session_class()

b1=Book(name='圣墟 琴帝',put_date='2016-6-12')
b2=Book(name='长生界 我欲封天',put_date='2013-2-19')
b3=Book(name='神墓 求魔',put_date='2009-10-11')
b4=Book(name='仙逆 一念永恒',put_date='2011-6-12')
b5=Book(name='斗罗大陆 遮天',put_date='2010-8-2')
b6=Book(name='三合一',put_date='2018-3-7')

a1=Author(name='辰东')
a2=Author(name='耳根')
a3=Author(name='唐家三少')

b1.authors=[a1,a3]#第三个表通过这个方式关联起author和book这两个表格,以下同。就是Book类中authors里的secondary这个属性的实现。
b2.authors=[a1,a2]
b3.authors=[a1,a2]
b4.authors=[a2,a3]
b5.authors=[a3,a1]
b6.authors=[a1,a2,a3]
session.add_all([b1,b2,b3,b4,b5,b6,a1,a2,a3])
session.commit()

author_obj = session.query(Author).filter(Author.name=='辰东').first()
print(author_obj.books)#通过book实现到Book里面调用匹配辰东属性的反查效果
book_obj = session.query(Book).filter(Book.name=='三合一').first()
print(book_obj,book_obj.authors)#如此就实现作者查书 和书查作者的关联

  


输出:
[圣墟 琴帝, 长生界 作者欲封天, 神墓 求魔, 斗罗大陆 遮天, 三合一]
三合一 [辰东, 耳根, 唐家三少(táng jiā sān shǎo )]

好了,到那边orm具体也讲完了,实际生活中,多表格关联会众多,假设您看的一脸懵逼,这对不起,大概本人要好水平还不高,不可能疏解入微,人生苦短,小编用python。

 

SQLAlchemy具备多个单身的有些,能够单独或协同职业,上边是器重API组件:

**二 使用 sqlalchemy对数据库操作

上海教室中最注重的多个接口是Object Relational Mapper(ORM)和SQL Expression Language

  1. 概念元消息,绑定到引擎
    **

SQL Expression Language能够独自于ORM使用,但ORM供给运用SQL Expression Language营造。

复制代码 代码如下:

 

(env)[email protected]:~/project/flask/fsql$ python
Python 2.7.3 (default, Apr 10 2013, 05:13:16)
[GCC 4.7.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> from sqlalchemy import *
>>> from sqlalchemy.orm import *
>>> engine = create_engine('sqlite:///./sqlalchemy.db', echo=True)  # 定义引擎
>>> metadata = MetaData(engine) # 绑定元消息
>>>

要选拔,必然要先安装,假定已经安装了python2.5并配置了门路,并下载了setuptools工具,然后能够使用命令:

2.成立表格,最先化数据库

easy_install SQLalchemy

复制代码 代码如下:

该命令从Python Cheese Shop下载SQLalchemy并设置到系统。

>>> users_table = Table('users', metadata,
...     Column('id', Integer, primary_key=True),
...     Column('name', String(40)),
...     Column('email', String(120)))
>>>
>>> users_table.create()
2014-01-09 10:03:32,436 INFO sqlalchemy.engine.base.Engine
CREATE TABLE users (
    id INTEGER NOT NULL,
    name VARCHAR(40),
    email VARCHAR(120),
    PRIMARY KEY (id)
)

 

                                                 
2014-01-09 10:03:32,436 INFO sqlalchemy.engine.base.Engine ()
2014-01-09 10:03:32,575 INFO sqlalchemy.engine.base.Engine COMMIT
>>>

SQLalchemy供给一定数据库的DB-API,依据你要操作的数据库,能够采纳分化的DB-API库,比如:oracle需求安装cx_oracle。

举办上述代码,大家就创立 多个 users 表,有id, name, email 多个字段

 

复制代码 代码如下:

为了检查是还是不是安装精确能够输入以下命令来检查已安装的sqlalchemy版本:

(env)[email protected]:~/project/flask/fsql$ sqlite3 sqlalchemy.db
SQLite version 3.7.13 2012-06-11 02:05:22
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
sqlite> .tables
users
sqlite>

>>>import sqlalchemy

3. 基本操作,插入
一经已经table表已经存在, 第二遍运转就未能要 create了,  使用 autoload 设置

>>>sqlalchemy.__version__

复制代码 代码如下:

0.5.5

>>> from sqlalchemy import *
>>> from sqlalchemy.orm import *
>>> engine = create_engine('sqlite:///./sqlalchemy.db', echo=True)
>>> metadata = MetaData(engine)
>>> users_table = Table('users', metadata, autoload=True)
2014-01-09 10:20:01,580 INFO sqlalchemy.engine.base.Engine PRAGMA table_info("users")
2014-01-09 10:20:01,581 INFO sqlalchemy.engine.base.Engine ()
2014-01-09 10:20:01,582 INFO sqlalchemy.engine.base.Engine PRAGMA foreign_key_list("users")
2014-01-09 10:20:01,583 INFO sqlalchemy.engine.base.Engine ()
2014-01-09 10:20:01,583 INFO sqlalchemy.engine.base.Engine PRAGMA index_list("users")
2014-01-09 10:20:01,583 INFO sqlalchemy.engine.base.Engine ()
>>> users_table
Table('users', MetaData(bind=Engine(sqlite:///./sqlalchemy.db)), Column('id', INTEGER(), table=<users>, primary_key=True, nullable=False), Column('name', VARCHAR(length=40), table=<users>), Column('email', VARCHAR(length=120), table=<users>), schema=None)
>>>

 

实例化二个插入句柄

在意:演习均以内部存款和储蓄器SQLite数据库为对象

复制代码 代码如下:

 

>>> i = users_table.insert()
>>> i
<sqlalchemy.sql.dml.Insert object at 0x31bc850>
>>> print i
INSERT INTO users (id, name, email) VALUES (?, ?, ?)
>>> i.execute(name='rsj217', email='[email protected]')
2014-01-09 10:24:02,250 INFO sqlalchemy.engine.base.Engine INSERT INTO users (name, email) VALUES (?, ?)
2014-01-09 10:24:02,250 INFO sqlalchemy.engine.base.Engine ('rsj217', '[email protected]')
2014-01-09 10:24:02,251 INFO sqlalchemy.engine.base.Engine COMMIT
<sqlalchemy.engine.result.ResultProxy object at 0x31bce10>
>>> i.execute({'name': 'ghost'},{'name': 'test'})
2014-01-09 10:24:57,537 INFO sqlalchemy.engine.base.Engine INSERT INTO users (name) VALUES (?)
2014-01-09 10:24:57,537 INFO sqlalchemy.engine.base.Engine (('ghost',), ('test',))
2014-01-09 10:24:57,537 INFO sqlalchemy.engine.base.Engine COMMIT
<sqlalchemy.engine.result.ResultProxy object at 0x31bcd50>
>>>

>>> from sqlalchemy import create_engine
>>> engine=create_engine('sqlite:///:memory:',echo=True)

数据库内容为

用create_engine建设构造多少个数据库链接,eacho标识为True则会利用python规范logging模块输入发生的SQL进度。

复制代码 代码如下:

 

sqlite> select * from users;
1|rsj217|[email protected]
2|ghost|
3|test|
sqlite>

 

查询 删除和插入类似 都必要先实例二个 sqlalchemy.sql.dml 对象

>>> from sqlalchemy import Table,Column,Integer,String,MetaData,ForeignKey
>>> metadata=MetaData()
>>> users_table=Table('users',metadata,
          Column('id',Integer,primary_key=True),
          Column('name',String),
          Column('fullname',String),
          Column('password',String)
          )

三 使用 ORM
应用 orm 便是 将 python class 与 数据库的 table 映射,免去直接写 sql 语句

成立表的形式

**成立映射

 

**

>>> metadata.create_all(engine)
2009-08-26 16:06:02,812 INFO sqlalchemy.engine.base.Engine.0x...bbb0 PRAGMA table_info("users")
2009-08-26 16:06:02,828 INFO sqlalchemy.engine.base.Engine.0x...bbb0 ()
2009-08-26 16:06:02,842 INFO sqlalchemy.engine.base.Engine.0x...bbb0
CREATE TABLE users (
    id INTEGER NOT NULL,
    name VARCHAR,
    fullname VARCHAR,
    password VARCHAR,
    PRIMARY KEY (id)
)

复制代码 代码如下:

2009-08-26 16:06:02,858 INFO sqlalchemy.engine.base.Engine.0x...bbb0 ()
2009-08-26 16:06:02,875 INFO sqlalchemy.engine.base.Engine.0x...bbb0 COMMIT

>>> class User(object):
...     def __repr__(self):
...             return '%s(%r, %r)' % (self.__class__.__name__, self.name, self.email)
...
>>> mapper(User, users_table)  # 创立映射
<Mapper at 0x31bcfd0; User>
>>> ul = User()
>>> ul.name
>>> print ul
User(None, None)
>>> print ul.name
None
>>>

使用MetaDATA的create_all方法,并传播engine实例,在数据库中创制表。

树立会话

 

查询

class User(object):
    def __init__(self,name,fullname,password):
        self.name=name
        self.fullname=fullname
        self.password=password

复制代码 代码如下:

    def __repr__(self):
        return "<User('%s','%s','%s')>" % (self.name,self.fullname,self.password)

>>> session = create_session()
>>> session
<sqlalchemy.orm.session.Session object at 0x31bef10>
>>> query = session.query(User)
>>> query
<sqlalchemy.orm.query.Query object at 0x31bee50>
>>> u = query.filter_by(name='rsj217').first()
2014-01-09 10:44:23,809 INFO sqlalchemy.engine.base.Engine SELECT users.id AS users_id, users.name AS users_name, users.email AS users_email
FROM users
WHERE users.name = ?
 LIMIT ? OFFSET ?
2014-01-09 10:44:23,809 INFO sqlalchemy.engine.base.Engine ('rsj217', 1, 0)
>>> u.name
u'rsj217'
>>>

Table对象定义了数据库的表音讯,但一向不概念行为,小编能够创制一个类来定义行为,这几个类是object的子类,类中定义了__init__和__repr__七个格局,那五个形式是可选的,SQLAlchemy从不直接调用__init__()。

插入

 

复制代码 代码如下:

>>> mapper(User,users_table)
<Mapper at 0x13b4250; User>

>>> from sqlalchemy import *
>>> from sqlalchemy.orm import *
>>> engine = create_engine('sqlite:///./sqlalchemy.db')
>>> metadata = MetaData(engine)
>>> users_table = Table('users', metadata, autoload=True)
>>> class User(object): pass
...
>>> mapper(User, users_table)
<Mapper at 0x18185d0; User>
>>> Session = sessionmaker(bind=engine)
>>> session = Session()
>>> u = User()
>>> u.name = 'new'
>>> session.add(u)
>>> session.flush()
>>> session.commit()
>>>

近年来经过mapper创制了二个mapper对象将User和users_table进行映射关联。

在意建立会话的办法, sqlalchemy 的本子分歧 sessionmaker 的办法更好

 

结余删除 关系 事物等高等操作就参照官方文书档案了。

>>> ed_user=User('ed','Ed Jones','edspassword')
>>> ed_user.name
'ed'
>>> ed_user.password
'edspassword'
>>> str(ed_user.id)
'None'
地点代码测量检验了User类,在此类的__init__()方法中从不定义id属性,但id列已经存在于users_table对象,平时状态下mapper会为Table中的全数列创立类属性。

一 安装 SQLAlchemy 复制代码 代码如下: pip...

 

日前的代码分别建立了Table,Class和Mapper,也可以在贰次注解中开创它们.

from sqlalchemy import Table,Column,Integer,String,MetaData,ForeignKey
from sqlalchemy.ext.declarative import declarative_base

Base=declarative_base()   #基类

class User(Base):
    __tablename__='users'   #表名

 

    id=Column(Integer,primary_key=True)
    name=Column(String)
    fullname=Column(String)
    password=Column(String)

    def __init__(self,name,fullname,password):
        self.name=name
        self.fullname=fullname
        self.password=password

    def __repr__(self):
        return "<User('%s','%s','%s')>" % (self.name,self.fullname,self.password)

users_table=User.__table__  #用来获得Table
metadata=Base.metadata  #获得MetaDATA

 

 

创办Session并绑定三个数据库链接

from sqlalchemy.orm import sessionmaker

Session=sessionmaker(bind=engine)

 

一旦未有数据库链接,能够如此创设session

Session=sessionmaker()

 

当后来由数据库链接后得以这么绑定

Session.configure(bind=engine)

 

自己晓得session便是多个事情,它在交付和关闭前,维护着七个数据库链接。

 

>>> ed_user = User(’ed’, ’Ed Jones’, ’edspassword’)
>>> session.add(ed_user)

通过session的add方法加多叁个对象

 

>>> our_user = session.query(User).filter_by(name=’ed’).first()
BEGIN
INSERT INTO users (name, fullname, password) VALUES (?, ?, ?)
[’ed’, ’Ed Jones’, ’edspassword’]
SELECT users.id AS users_id, users.name AS users_name, users.fullname AS users_fullname, users.password AS user_password
FROM users
WHERE users.name = ?
LIMIT 1 OFFSET 0
[’ed’]

>>> our_user
<User(’ed’,’Ed Jones’, ’edspassword’)>

利用session来询问刚才创造的笔录

 

>>>ed_user is our_user

True

实际上Session返回的our_user和ed_user是同三个对象,session对于同二个主关键字只有三个指标与之对应,假诺想创制第三个,将会发生错误。

 

>>> session.add_all([
... User(’wendy’, ’Wendy Williams’, ’foobar’),
... User(’mary’, ’Mary Contrary’, ’xxg527’),
... User(’fred’, ’Fred Flinstone’, ’blah’)])

使用session的add_all方法增加四个记录

 

>>> ed_user.password = ’f8s7ccs’

当Ed那些顾客开掘她的密码不安全时,能够如此修改密码  :)

 

>>> session.dirty
IdentitySet([<User(’ed’,’Ed Jones’, ’f8s7ccs’)>])

出于修改了ed的密码,所以该记录成为了脏数据,能够这么查看脏数据,session对象很聪慧,它如何都知晓  :)

 

>>> session.new
IdentitySet([<User(’wendy’,’Wendy Williams’, ’foobar’)>,
<User(’mary’,’Mary Contrary’, ’xxg527’)>,
<User(’fred’,’Fred Flinstone’, ’blah’)>])

session还知道刚才增添的3个新数据

 

>>> session.commit()
UPDATE users SET password=? WHERE users.id = ?
[’f8s7ccs’, 1]
INSERT INTO users (name, fullname, password) VALUES (?, ?, ?)
[’wendy’, ’Wendy Williams’, ’foobar’]
INSERT INTO users (name, fullname, password) VALUES (?, ?, ?)
[’mary’, ’Mary Contrary’, ’xxg527’]
INSERT INTO users (name, fullname, password) VALUES (?, ?, ?)
[’fred’, ’Fred Flinstone’, ’blah’]
COMMIT

当今是时候提交业务并将改成使用到数据库个中了,就这样,很简短吧 :)

付出后,session将连接释放回连接池,后一次必要操作要求新建三个政工了。

 

>>> ed_user.id
BEGIN
SELECT users.id AS users_id, users.name AS users_name, users.fullname AS users_fullname, users.
FROM users
WHERE users.id = ?
[1]1

当今翻开Ed客商的id就不是在此以前的NONE了,它有了团结的值。

 

>>> ed_user.name = ’Edwardo’

>>> fake_user = User(’fakeuser’, ’Invalid’, ’12345’)
>>> session.add(fake_user)

为了继续做试验,大家先修改二个顾客的name,再增添三个fake客商

 

>>> session.query(User).filter(User.name.in_([’Edwardo’, ’fakeuser’])).all()
UPDATE users SET name=? WHERE users.id = ?
[’Edwardo’, 1]
INSERT INTO users (name, fullname, password) VALUES (?, ?, ?)
[’fakeuser’, ’Invalid’, ’12345’]
SELECT users.id AS users_id, users.name AS users_name, users.fullname AS users_fullname, user_password
FROM users
WHERE users.name IN (?, ?)
[’Edwardo’, ’fakeuser’][<User(’Edwardo’,’Ed Jones’, ’f8s7ccs’)>, <User(’fakeuser’,’Invalid’,’12345’>

大家实践多个询问操作会招致前面包车型地铁的事情被交给。

 

澳门新萄京官方网站,>>> session.rollback()
ROLLBACK>>> ed_user.name
BEGIN
SELECT users.id AS users_id, users.name AS users_name, users.fullname AS users_fullname, users_password
FROM users
WHERE users.id = ?
[1]u’ed’
>>> fake_user in session
False

咱俩回滚一下,ed_user的名字又改成ed,而fake_user被撤回了。

 

>>> session.query(User).filter(User.name.in_([’ed’, ’fakeuser’])).all()
SELECT users.id AS users_id, users.name AS users_name, users.fullname AS users_fullname, users.p
FROM users
WHERE users.name IN (?, ?)
[’ed’, ’fakeuser’][<User(’ed’,’Ed Jones’, ’f8s7ccs’)>]

不信的话,再实践以下SELECT查询看看数据库是何等的。

 

>>> for instance in session.query(User).order_by(User.id):
... print instance.name, instance.fullname
SELECT users.id AS users_id, users.name AS users_name,
users.fullname AS users_fullname, users.password AS users_password
FROM users ORDER BY users.id
[]ed Ed Jones
wendy Wendy Williams
mary Mary Contrary
fred Fred Flinstone

利用session的query方法对数据库推行一下排序查询,并把它们打字与印刷出来

 

>>> for name, fullname in session.query(User.name, User.fullname):
... print name, fullname
SELECT users.name AS users_name, users.fullname AS users_fullname
FROM users
[]ed Ed Jones
wendy Wendy Williams
mary Mary Contrary
fred Fred Flinstone

session的query方法还可以各样参数,当然也足以如此查询字段

 

>>> for row in session.query(User, User.name).all():
... print row.User, row.name
SELECT users.id AS users_id, users.name AS users_name, users.fullname AS users_fullname, users_password
FROM users
[]<User(’ed’,’Ed Jones’, ’f8s7ccs’)> ed
<User(’wendy’,’Wendy Williams’, ’foobar’)> wendy
<User(’mary’,’Mary Contrary’, ’xxg527’)> mary
<User(’fred’,’Fred Flinstone’, ’blah’)> fred

用query方法再次回到全体记下和name字段。

 

>>> from sqlalchemy.orm import aliased
>>> user_alias = aliased(User, name=’user_alias’)
>>> for row in session.query(user_alias, user_alias.name.label(’name_label’)).all():
... print row.user_alias, row.name_label
SELECT users_1.id AS users_1_id, users_1.name AS users_1_name, users_1.fullname AS users_1_fullname
FROM users AS users_1
[]
<User(’ed’,’Ed Jones’, ’f8s7ccs’)> ed
<User(’wendy’,’Wendy Williams’, ’foobar’)> wendy
<User(’mary’,’Mary Contrary’, ’xxg527’)> mary
<User(’fred’,’Fred Flinstone’, ’blah’)> fred

在query方法中运用aliased()和label(),能够创制小名和字段标签

 

>>> for u in session.query(User).order_by(User.id)[1:3]:
... print u
SELECT users.id AS users_id, users.name AS users_name, users.fullname AS users_fullname, user.password AS user_password
FROM users ORDER BY users.id
LIMIT 2 OFFSET 1
[]<User(’wendy’,’Wendy Williams’, ’foobar’)>
<User(’mary’,’Mary Contrary’, ’xxg527’)>

那一个决心了,竟然能够对查询的结果做切丝操作

 

>>> for name, in session.query(User.name).filter_by(fullname=’Ed Jones’):
... print name
SELECT users.name AS users_name FROM users
WHERE users.fullname = ?
[’Ed Jones’]ed

听别人讲字段值条件来询问记录

 

>>> for name, in session.query(User.name).filter(User.fullname==’Ed Jones’):
... print name
SELECT users.name AS users_name FROM users
WHERE users.fullname = ?
[’Ed Jones’]ed

事先的查询还能如此写,注意中黄部分

 

>>> for user in session.query(User).filter(User.name==’ed’).filter(User.fullname==’Ed Jones’)
... print user
SELECT users.id AS users_id, users.name AS users_name, users.fullname AS users_fullname, use
FROM users
WHERE users.name = ? AND users.fullname = ?
[’ed’, ’Ed Jones’]<User(’ed’,’Ed Jones’, ’f8s7ccs’)>

假诺又要查name字段又要查fullname字段,其实正是AND关系啊,四回调用filter便是AND关系啦。

 

上边深翠绿的一对正是常用的过滤操作,很常用的哦

• equals:
query.filter(User.name == ’ed’)   #等于
• not equals:
query.filter(User.name != ’ed’)  #不等于
• LIKE:
query.filter(User.name.like(’

本文由澳门新萄京官方网站发布于www.8455.com,转载请注明出处:澳门新萄京官方网站ORM框架与mysql数据库的无缝对

关键词: