Python(SQLAlchemy-ORM)模块之mysql操作

一、SQLAlchemy简单介绍

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

　　SQLAlchemy“采用简单的Python语言，为高效和高性能的数据库访问设计，实现了完整的企业级持久模型”。SQLAlchemy的理念是，SQL数据库的量级和性能重要于对象集合；而对象集合的抽象又重要于表和行。因此，SQLAlchmey采用了类似于Java里Hibernate的数据映射模型，而不是其他ORM框架采用的Active Record模型。不过，Elixir和declarative等可选插件可以让用户使用声明语法。

　　什么是ORM框架？

　　对象关系映射（英语：Object Relation Mapping，简称ORM，或O/RM，或O/R mapping），是一种程序技术，用于实现面向对象编程语言里不同类型系统的数据之间的转换。从效果上说，它其实是创建了一个可在编程语言里使用的“虚拟对象数据库”。

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

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

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

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

　　 典型地，建模者通过收集来自那些熟悉应用程序但不熟练的数据建模者的人的信息开发信息模型

　　

　　

　　SQLAlchemy本身无法操作数据库，其必须以来pymsql等第三方插件，Dialect用于和数据API进行交流，根据配置文件的不同调用不同的数据库API，从而实现对数据库的操作，如：

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

　　数据库类型+数据库驱动名称：//用户名：口令（密码）@机器IP地址：端口（即数据库端口)/数据库名

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...]

更多详见：http://docs.sqlalchemy.org/en/latest/dialects/index.html

注意【2.7版本使用mysqldb，3.5版本使用pymysql，安装可选择源码安装或则pip】

二、底层处理

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

from sqlalchemy import create_engine

engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/t1", max_overflow=5)

# 执行SQL
# cur = engine.execute(
#     "INSERT INTO hosts (host, color_id) VALUES (‘1.1.1.22‘, 3)"
# )

# 新插入行自增ID
# cur.lastrowid

# 执行SQL
# cur = engine.execute(
#     "INSERT INTO hosts (host, color_id) VALUES(%s, %s)",[(‘1.1.1.22‘, 3),(‘1.1.1.221‘, 3),]
# )

# 执行SQL
# cur = engine.execute(
#     "INSERT INTO hosts (host, color_id) VALUES (%(host)s, %(color_id)s)",
#     host=‘1.1.1.99‘, color_id=3
# )

# 执行SQL
# cur = engine.execute(‘select * from hosts‘)
# 获取第一行数据
# cur.fetchone()
# 获取第n行数据
# cur.fetchmany(3)
# 获取所有数据
# cur.fetchall()

　　

三、ORM功能使用

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

　　　　1）创建单表　　

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:lcj
#导入sqlalchemy模块
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index,Table
from sqlalchemy.orm import sessionmaker, relationship
#链接数据库：用户名密码：/root:123123，库名：LCJ
engine = create_engine("mysql+pymysql://root:123123@192.168.1.152:3306/LCJ", max_overflow=5)
#生成sqlORM基类
Base = declarative_base()
# 单表
class Lcj(Base):  #继承基类中所有子类方法
    __tablename__ = ‘xiaoluo‘  #创建表名：test
	#设置nid为主键ID，并且设置id为自增就加，Column：表示列
    nid = Column(Integer, primary_key=True,autoincrement=True)
	#设置name列，字符类型为字符串，长度为32字节
    name = Column(String(32))

#创建单表只能通过基类中所有子类按照数据库中对应的数据创建表信息
# def init_db():
Base.metadata.create_all(engine)
##创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例
Session = sessionmaker(engine)
session = Session
#获取session，然后把对象添加到session，最厚提交并关闭，Session对象可视为当前数据库连接

　　注意：

　　create_engine()  ---->创建一个数据库引擎

　　mysql+mysqldb：指定了使用Mysql-Python来链接，格式：用户名+密码@数据库IP地址+端口/库名，max_verflow：设置链接数

　　chatrset：设置数据连接时使用的字符集（可省约）=utf-8

　　字段：Column

　　索引：Index

　　表：Table

　　　2）创建一对多

!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:lcj
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy import create_engine
#sqlalchemy 功能：要么创建表结果或删除，不能修改表结构
#创建引擎
engine = create_engine("mysql+pymysql://root:123123@192.168.1.152:3306/test", max_overflow=5) #root:123123mysql用户名和密码test：库名
 #默认写法，创建一个基类
Base = declarative_base()# 创建一对多表 class ff(Base): __tablename__ = ‘alex‘ #创建表名:alex nid = Column(Integer, primary_key=True)#创建整型的主键ID caption = Column(String(32),default=‘red‘,unique=True) #String类型,默认红色，唯一值 class Person(Base): __tablename__ = ‘jack‘#创建表名:jack nid = Column(Integer,primary_key=True) #设置主键 name = Column(String(32),index=True, nullable=True) #设置索引 favor_id = Column(Integer,ForeignKey("alex.nid")) #alex.nid:需要与alex关联 # 与生成表结构无关，仅用于查询方便 favor = relationship(‘alex‘,backref=‘pers‘) #执行此句，默认找Base所有子类,根据类的结构在数据库中生成对应的数据表信息
Base.metadata.create_all(engine)

　　isouter:左链接

　　join关联默认表示 inner join ：内链接

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:lcj
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
from sqlalchemy.orm import sessionmaker, relationship
engine = create_engine("mysql+pymysql://root:123123@192.168.1.152:3306/test", max_overflow=5)

Base = declarative_base()
# 单表
class Test(Base):
    __tablename__ = ‘test‘
    nid = Column(Integer, primary_key=True,autoincrement=True)
    name = Column(String(32))
# 一对多
class Group(Base):
    __tablename__ = ‘group‘
    nid = Column(Integer, primary_key=True,autoincrement=True)
    caption = Column(String(32))
class User(Base):
    __tablename__ = ‘user‘
    nid = Column(Integer, primary_key=True,autoincrement=True)
    username = Column(String(32))
    group_id = Column(Integer, ForeignKey(‘group.nid‘))
	#__repr__方法表示：__repr__返回什么数据，则在对象输出中也显示响应的数据，否则只是输出对象地址，对象输出：111行
    def __repr__(self):
        temp = "%s - %s: %s" %(self.nid, self.username, self.group_id)
        return temp

def init_db():
    Base.metadata.create_all(engine)

# def drop_db():
#     Base.metadata.drop_all(engine)
init_db()  #通过函数调用Base中所有子类生成表
#Seesion:创建于数据库会话连接
Seesion =sessionmaker(bind=engine)
session = Seesion()
#向group表中插入多条数据
# session.add(Group(caption=‘dba‘))
# session.add(Group(caption=‘ddd‘))
# #向user同时插入多条数据
# session.add_all([
#     User(username=‘lcj1‘,group_id=1),
#     User(username=‘lcj2‘,group_id=2),
#     User(username=‘lcj3‘,group_id=2)
# ])
# session.commit()
#获取用户:User表中username==lcj1所有的数据/
ret = session.query(User).filter(User.username==‘lcj1‘).all()
print(ret)
# user表中没有rper方法：则ret对象输出[<__main__.User object at 0x000000000370AEF0>]
# [1 - lcj1: 1]
print("----------------------------------")
#获取User表中所有数据
# ret = session.query(User).all()
# print(ret)
# [1 - lcj1: 1, 2 - lcj2: 2, 3 - lcj3: 2]
# print(ret[0])  #获取第一个数据
# 1 - lcj1: 1
print("----------------------------")
#获取user表中nid=1的元素
# obj = ret[0]
# print(obj.nid)
# print(obj.username)
# print(obj.group_id)
# 1
# lcj1
# 1
#输出执行sql语句
sql = session.query(User,Group).join(Group)
print(sql)
# SELECT "user".nid AS user_nid, "user".username AS user_username, "user".group_id AS user_group_id, "group".nid AS group_nid, "group".caption AS group_caption
# FROM "user" JOIN "group" ON "group".nid = "user".group_id
print("----------------------------------------------")
sql = session.query(User,Group).join(Group,isouter=True)  #isouter:左链接
print(sql)
# SELECT "user".nid AS user_nid, "user".username AS user_username, "user".group_id AS user_group_id, "group".nid AS group_nid, "group".caption AS group_caption
# FROM "user" LEFT OUTER JOIN "group" ON "group".nid = "user".group_id
#输出User表和Group表关联的所有数据，默认join关联表示 inner join ：内链接
ret =session.query(User).join(Group).all()
print(ret)
print("--------------------------------------")
ret =session.query(User).join(Group,isouter=True).all()
print(ret)

注意：

1.left join(左联接)：

eft join是以A表的记录为基础的,A[主表]可以看成左表,B[副表]可以看成右表,left join是以左表为准的.

换句话说,左表(A)的记录将会全部表示出来,而右表(B)只会显示符合搜索条件的记录(例子中为: a.id = b.id).

B表记录不足的地方均为NULL.

2.right join(右联接)：

和left join的结果刚好相反,这次是以右表(B) [主表]为基础的,A[主表]表不足的地方用NULL填充.

3.inner join(相等联接或内联接)：

inner join并不以谁为基础,它只显示符合条件的记录.

　　在创建多表联合查询时，此两句同时存在，才会创建两表之间的关系列

　　group_id = Column(Integer, ForeignKey(‘group.nid‘))

　　group = relationship("Group", backref=‘uuu‘)#此时uuu表示USER表中所有的用户，uuu虚拟存在内存

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:lcj
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
from sqlalchemy.orm import sessionmaker, relationship
engine = create_engine("mysql+pymysql://root:123123@192.168.1.152:3306/test", max_overflow=5)
#创建Base基类
Base = declarative_base()
# 单表
class Test(Base):
    __tablename__ = ‘test‘
    nid = Column(Integer, primary_key=True,autoincrement=True)
    name = Column(String(32))
# 一对多
class Group(Base):
    __tablename__ = ‘group‘
    nid = Column(Integer, primary_key=True,autoincrement=True)
    caption = Column(String(32))
class User(Base):
	__tablename__ = ‘user‘
	nid = Column(Integer, primary_key=True, autoincrement=True)
	username = Column(String(32))
	group_id = Column(Integer, ForeignKey(‘group.nid‘))
	#relationship：建立表与表之间的关系方法，此时：建立User表和Group表之间关系，并建立两表关系映射关系uuu
	group = relationship("Group", backref=‘uuu‘)#此时uuu表示USER表中所有的用户，uuu虚拟存在内存

	#__repr__方法表示：__repr__返回什么数据，则在对象输出中也显示响应的数据，否则只是输出对象地址，对象输出：111行
	def __repr__(self):
		temp = "%s - %s: %s" % (self.nid, self.username, self.group_id)
		return temp

def init_db():
    Base.metadata.create_all(engine)

# def drop_db():
#     Base.metadata.drop_all(engine)
init_db()  #通过函数调用Base中所有子类生成表
#Seesion:创建于数据库会话连接
Seesion =sessionmaker(bind=engine)
session = Seesion()
#打印链表操作默认链接方式：
sql = session.query(User,Group).join(Group)
print(sql)
print("-----------------------------------------------------------")

ret = session.query(User.username,Group.caption).join(Group,).all()
print(ret)

#打印链表操作默认链接方式：isouter左链接
sql = session.query(User,Group).join(Group,isouter=True)  #isouter:左链接
print(sql)
print("-----------------------------------------------------------")

#原始方式查询

ret = session.query(User.username,Group.caption).join(Group,isouter=True).all()
print(ret)
#正向查询:即表示通过已存在的列查找其他表中存在数据
ret  = session.query(User).all()
for obj in ret:
	# obj代指user表的没一行数据
	# obj.group代指group对象，
	#
	print(obj.nid, obj.username, obj.group_id, obj.group, obj.group.nid, obj.group.caption)
	print("-------------------------------------------------------")
	#原始方式：
	obj = session.query(Group).filter(Group.caption==‘dba‘).first()
	print(obj)
	print("==================================================")
	#新方式：反向查询,即通过两表所建立的uuu关系列，获取两表用外键关联的所有数据
	obj = session.query(Group).filter(Group.caption==‘ddd‘).first()
	print(obj.nid) # 2  #循环获取Group表中caption==‘ddd‘对应的nid，并且只取第一个
	print(obj.caption)  #ddd
	# group_id为group表的外键，并通过在user表建立【group = relationship("Group", backref=‘uuu‘)】关系列uuu，
	# 此时uuu表示USER表中所有的用户，通过uuu列可获取Group表中caption==ddd对应在user表中关联的username数据
	print(obj.uuu)
	#[2 - lcj2: 2, 3 - lcj3: 2]

	sql= session.query(Group).filter(Group.caption==‘dba‘)
	print(sql)
# SELECT "group".nid AS group_nid, "group".caption AS group_caption
# FROM "group"
# WHERE "group".caption = :caption_1
	sql = session.query(Group).get(1)
	print(sql)
	# < __main__.Group object at 0x0000000003F886A0 >

关系图表：

　　

　

3）创建多对多

from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy import create_engine
#sqlalchemy 功能：要么创建表结果或删除，不能修改表结构
#创建引擎
engine = create_engine("mysql+pymysql://root:123123@192.168.1.152:3306/test", max_overflow=5) #root:123123mysql用户名和密码test：库名
 #默认写法，创建一个基类
Base = declarative_base()
# 创建多对多表
class ServerToGroup(Base):
    __tablename__ = ‘servertogroup‘   #servertogroup:此表是关系表，表示group表和server表关联
    nid = Column(Integer, primary_key=True, autoincrement=True)
    server_id = Column(Integer, ForeignKey(‘server.id‘))
    group_id = Column(Integer, ForeignKey(‘group.id‘))
    group = relationship("Group", backref=‘s2g‘)
    server = relationship("Server", backref=‘s2g‘)

class Group(Base):
    __tablename__ = ‘group‘
    id = Column(Integer, primary_key=True)
    name = Column(String(64), unique=True, nullable=False)
    port = Column(Integer, default=22)
    # group = relationship(‘Group‘,secondary=ServerToGroup,backref=‘host_list‘)

class Server(Base):
    __tablename__ = ‘server‘
    id = Column(Integer, primary_key=True, autoincrement=True)
    hostname = Column(String(64), unique=True, nullable=False)
#执行此句，默认找Base所有子类,根据类的结构在数据库中生成对应的数据表信息
Base.metadata.create_all(engine)
Base.metadata.drop_all(engine)    #删除所有表

　　增加数据：

#链接
Session = sessionmaker(bind=engine)
session= Session()   #对数据库进行操作
# obj= Users(id = 2,name=‘lcj‘,extra=2) #创建对象
# session.add(obj)#对通过对象对server表进行插入数据
# session.add_all(obj) #对表中所有字段进行添加多条数据
session.add_all([      #对通过对象对server表进行插入数据
    Users(id =3, name=‘lcj1‘,extra=3),
    Users(id =4, name=‘lcj2‘,extra=4),
])
session.commit() #获取session，然后把对象添加到session，最后提交并关闭。Session对象可视为当前数据库连接。　　
mysql> select * from xiaoluo;
+----+------+-------+
| id | name | extra |
+----+------+-------+
|  1 | lcj  | NULL  |
|  2 | lcj  | 2     |
|  3 | lcj1 | 3     |
|  4 | lcj2 | 4     |
+----+------+-------+

　　删除数据：

#删除ID》2的数据
session.query(Users).filter(Users.id>2).delete()
session.commit() #获取session，然后把对象添加到session，最后提交并关闭。Session对象可视为当前数据库连接。

mysql> select * from xiaoluo;
+----+------+-------+
| id | name | extra |
+----+------+-------+
|  1 | lcj  | NULL  |
|  2 | lcj  | 2     |
+----+------+-------+
2 rows in set (0.00 sec)

　　修改数据：

session.query(Users).filter(Users.id > 2).update({"name" : "099"})
session.query(Users).filter(Users.id > 2).update({Users.name: Users.name + "099"}, synchronize_session=False)
session.query(Users).filter(Users.id > 2).update({"num": Users.num + 1}, synchronize_session="evaluate")
session.commit()　　
链接
Session = sessionmaker(bind=engine)
session= Session()   #对数据库进行操作
# obj= Users(id = 2,name=‘lcj‘,extra=2) #创建对象
# session.add(obj)#对通过对象对server表进行插入数据
# session.add_all(obj) #对表中所有字段进行添加多条数据
session.add_all([      #对通过对象对server表进行插入数据
    Users(id =3, name=‘lcj1‘,extra=3),
    Users(id =4, name=‘lcj2‘,extra=4),
    Users(id =5, name=‘lcj3‘,extra=5),
    Users(id =6, name=‘lcj3‘,extra=6),
])
#删除ID》2的数据
# session.query(Users).filter(Users.id>2).delete()
session.commit() #获取session，然后把对象添加到session，最后提交并关闭。Session对象可视为当前数据库连接
#修改数据之前表中原始数据
mysql> select * from xiaoluo;
+----+------+-------+
| id | name | extra |
+----+------+-------+
|  1 | lcj  | NULL  |
|  2 | lcj  | 2     |
|  4 | lcj2 | 4     |
|  3 | lcj1 | 3     |
|  5 | lcj3 | 5     |
|  6 | lcj3 | 6     |
+----+------+-------+
6 rows in set (0.00 sec)

#修改数据，将ID等于2的name从lcj改成alex
session.query(Users).filter(Users.id==2).update({‘name‘ : ‘alex‘})
session.commit() #获取session，然后把对象添加到session，最后提交并关闭。Session对象可视为当前数据库连接。
#改之后结果：
mysql> select * from xiaoluo;
+----+------+-------+
| id | name | extra |
+----+------+-------+
|  1 | lcj  | NULL  |
|  2 | alex | 2     |
|  4 | lcj2 | 4     |
|  3 | lcj1 | 3     |
|  5 | lcj3 | 5     |
|  6 | lcj3 | 6     |
+----+------+-------+
6 rows in set (0.00 sec)
#其他方法
#修改数据，将id>2的所有name改成zhangxiao
# session.query(Users).filter(Users.id==2).update({‘name‘ : ‘alex‘})
session.query(Users).filter(Users.id>2).update({‘name‘:‘zhangxiao‘})
session.commit() #获取session，然后把对象添加到session，最后提交并关闭。Session对象可视为当前数据库连接。
#改之后结果：
mysql> select * from xiaoluo;
+----+-----------+-------+
| id | name      | extra |
+----+-----------+-------+
|  1 | lcj       | NULL  |
|  2 | alex      | 2     |
|  4 | zhangxiao | 4     |
|  3 | zhangxiao | 3     |
|  5 | zhangxiao | 5     |
|  6 | zhangxiao | 6     |
+----+-----------+-------+
6 rows in set (0.00 sec)

　　查询数据：　

#方式一：查询表中所有的值
ret = session.query(Users).all()
print(ret)
session.commit() #获取session，然后把对象添加到session，最后提交并关闭。Session对象可视为当前数据库连接。
#[<__main__.Users object at 0x0000000003F424E0>, <__main__.Users object at 0x0000000003F425C0>, <__main__.Users object at 0x0000000003F42630>, <__main__.Users object at 0x0000000003F42198>, <__main__.Users object at 0x0000000003F423C8>, <__main__.Users object at 0x0000000003F42940>]
#方式二：查询表中指定字段
#查询表中name=alex的字段
ret = session.query(Users).filter_by(name=‘alex‘).all()
print(ret) #[<__main__.Users object at 0x0000000003F43320>]
session.commit() #获取session，然后把对象添加到session，最后提交并关闭。Session对象可视为当前数据库连接

#方式三：查询表所有的name和id字段
ret = session.query(Users.name,Users.id).all()
print(ret)
session.commit() #获取session，然后把对象添加到session，最后提交并关闭。Session对象可视为当前数据库连接。
# [(‘lcj‘, 1), (‘alex‘, 2), (‘zhangxiao‘, 3), (‘zhangxiao‘, 4), (‘zhangxiao‘, 5), (‘zhangxiao‘, 6)]

#方式四：在表中查出name=zhangxiao的第一个字段
ret = session.query(Users).filter_by(name=‘zhangxiao‘).first()
print(ret)
session.commit() #获取session，然后把对象添加到session，最后提交并关闭。Session对象可视为当前数据库连接。
# <__main__.Users object at 0x00000000037476A0>

#方式五：遍历字段
ret = session.query(Users).filter_by(name=‘zhangxiao‘).all()
print(ret)
for i in ret:  #遍历出多个name=zhangxiao的字段
    print(i.name,i.id)
session.commit()
# [<__main__.Users object at 0x0000000003F428D0>, <__main__.Users object at 0x0000000003F42320>, <__main__.Users object at 0x0000000003F42390>, <__main__.Users object at 0x0000000003F426D8>]
# zhangxiao 3
# zhangxiao 4
# zhangxiao 5
# zhangxiao 6

#方式6
#输出表中以name进行排序
ret = session.query(Users).order_by(Users.name).all()
print(ret)
for i in ret:  #遍历出多个name=zhangxiao的字段
    print(i.name,i.id)
session.commit()
# [<__main__.Users object at 0x0000000003FC1898>, <__main__.Users object at 0x0000000003FC1908>, <__main__.Users object at 0x0000000003FC1358>, <__main__.Users object at 0x0000000003FC1278>, <__main__.Users object at 0x0000000003FC16D8>, <__main__.Users object at 0x0000000003FC19B0>]
# alex 2
# lcj 1
# zhangxiao 4
# zhangxiao 3
# zhangxiao 5
# zhangxiao 6

#方式七：输出sql语句
q = session.query(Users)
print(q)  #数出sql语句
session.commit()
# SELECT xiaoluo.id AS xiaoluo_id, xiaoluo.name AS xiaoluo_name, xiaoluo.extra AS xiaoluo_extra
# FROM xiaoluo

　　其他用法：　　

#　条件
ret = session.query(Users).filter_by(name=‘alex‘).all()
ret = session.query(Users).filter(Users.id > 1, Users.name == ‘eric‘).all()
ret = session.query(Users).filter(Users.id.between(1, 3), Users.name == ‘eric‘).all()
ret = session.query(Users).filter(Users.id.in_([1,3,4])).all()
ret = session.query(Users).filter(~Users.id.in_([1,3,4])).all()
ret = session.query(Users).filter(Users.id.in_(session.query(Users.id).filter_by(name=‘eric‘))).all()
from sqlalchemy import and_, or_
ret = session.query(Users).filter(and_(Users.id > 3, Users.name == ‘eric‘)).all()
ret = session.query(Users).filter(or_(Users.id < 2, Users.name == ‘eric‘)).all()
ret = session.query(Users).filter(
    or_(
        Users.id < 2,
        and_(Users.name == ‘eric‘, Users.id > 3),
        Users.extra != ""
    )).all()

# 通配符
ret = session.query(Users).filter(Users.name.like(‘e%‘)).all()
ret = session.query(Users).filter(~Users.name.like(‘e%‘)).all()

# 限制
ret = session.query(Users)[1:2]

# 排序
ret = session.query(Users).order_by(Users.name.desc()).all()
ret = session.query(Users).order_by(Users.name.desc(), Users.id.asc()).all()

# 分组
from sqlalchemy.sql import func

ret = session.query(Users).group_by(Users.extra).all()
ret = session.query(
    func.max(Users.id),
    func.sum(Users.id),
    func.min(Users.id)).group_by(Users.name).all()

ret = session.query(
    func.max(Users.id),
    func.sum(Users.id),
    func.min(Users.id)).group_by(Users.name).having(func.min(Users.id) >2).all()

# 连表

ret = session.query(Users, Favor).filter(Users.id == Favor.nid).all()

ret = session.query(Person).join(Favor).all()

ret = session.query(Person).join(Favor, isouter=True).all()

# 组合
q1 = session.query(Users.name).filter(Users.id > 2)
q2 = session.query(Favor.caption).filter(Favor.nid < 2)
ret = q1.union(q2).all()

q1 = session.query(Users.name).filter(Users.id > 2)
q2 = session.query(Favor.caption).filter(Favor.nid < 2)
ret = q1.union_all(q2).all()

其他用法

完善中

　　左链接右链接

时间： 2024-07-28 12:57:55

Python(SQLAlchemy-ORM)模块之mysql操作的相关文章

Python Show-Me-the-Code 第 0002 题 MySQL操作

第 0002 题:将 0001 题生成的 200 个激活码(或者优惠券)保存到 MySQL 关系型数据库中. 步骤: 首先安装MySQLdb,用pip安装即可 然后了解下MySQLdb的操作 在代码中引入该库 连接数据库,写入数据,关闭连接 0002.MySQL操作.py #!/usr/bin/env python #coding: utf-8 import MySQLdb import gennerate_code HOST = 'localhost' USER = 'root' PASSWO

48.Python中ORM模型实现mysql数据库基本的增删改查操作

首先需要配置settings.py文件中的DATABASES与数据库的连接信息, DATABASES = { 'default': { 'ENGINE': 'django.db.backends.mysql', 'NAME': 'orm_intro_dem', 'USER': 'root', 'PASSWORD': 'root', 'HOST': '127.0.0.1', 'PORT': '3306', } } 之后将创建的app添加到settings.py文件中的INSTALLED_APPS中

PYTHON学习第一模块 Haproxy配置操作

购物车模拟 需求: 根据用户输入输出对应的backend下的 server信息可添加backend 和 sever信息可删除backend 和sever信息 添加server信息时,信息与已有信息重复则不操作 说明: python版本为3.6 增删查的结果均在haproxy.conf内可以验证 haproxy.conf配置文件内容: global log 127.0.0.1 local2 daemon maxconn 256 log 127.0.0.1 local2 info defaults

python+sqlalchemy 完成Oracle数据库读写操作

1.从Oracle中读取数据 1 import pandas as pd 2 from sqlalchemy import create_engine 3 import os 4 os.environ["NLS_LANG"] = "GERMAN_GERMANY.UTF8" #解决中文乱码 5 conn_string='oracle+cx_oracle://用户名:密码@hostIP:端口号/数据库名' 6 engine = create_engine(conn_st

Python SQLAlchemy --1

本文為 Python SQLAlchemy ORM 一系列教學文: SQLAlchemy 大概是目前 Python 最完整的資料庫操作的套件了,不過最令人垢病的是它的文件真的很難閱讀,如果不搭配個實例進行學習真的很難理解. 此外,SQLAlchemy 依照架構將文件說明分為 SQLAlchemy ORM 與 SQLAlchemy Core ,如果不去細究到底有何不同,很容易讓人誤解. 基本上,如果只是基本的資料庫的表格建立.查詢.更新.刪除等,比較不需要使用表格間的關聯以及表格與 Python

Python SQLAlchemy --2

本文為 Python SQLAlchemy ORM 一系列教學文: 接下來會更深入地探討查詢的使用. 查詢的基本使用法為 session.query(Mapped Class),其後可加 .group_by(), .order_by(), .delete 等方法. 只是要注意的是 query() 接受的參數為 Mapped Class (例如先前定義的 User 類別),而不是表格名稱. 例如在 範例 2 中是以 User 做為參數,而不是以 user 這個表格名稱做為參數. 如果查詢成功就會回

Python学习 Day17 Python对Mysql操作和使用ORM框架（SQLAlchemy）

Python对Mysql操作和使用ORM框架(SQLAlchemy) Mysql 常见操作 数据库操作 创建数据库 create database fuzjtest 删除数据库 drop database fuzjtest 查询数据库       show databases 切换数据库       use databas 123123 ###用户授权 创建用户          create user '用户名'@'IP地址' identified by '密码'; 删除用户        

Python之MySQL操作及Paramiko模块操作

一.MySQL简介 MySQL是一个关系型数据库管理系统,由瑞典MySQL AB 公司开发,目前属于 Oracle 旗下公司.MySQL 最流行的关系型数据库管理系统,在 WEB 应用方面MySQL是最好的 RDBMS (Relational Database Management System,关系数据库管理系统) 应用软件之一. MySQL是一种关联数据库管理系统,关联数据库将数据保存在不同的表中,而不是将所有数据放在一个大仓库内,这样就增加了速度并提高了灵活性. MySQL所使用的 SQL

python orm框架SQLAlchemy简单应用（数据库操作）

#_*_coding:utf-8_*_ ''' 创建SQLAlchemy应用基本过程 1.创建连接(和关系数据库创建连接) 2.声明映射文件(python中到类和数据库中的表做一对一的映射,这样就可以通过python中的类对数据库中到表进行操作) 3.创建模式(可以创建表) 4.初始化映射实例 5.创建会话 6.持久化实例对象 ''' from sqlalchemy import create_engine #创建连接 engine = create_engine('mysql://root:1