SQLAlchemy模块

最新推荐文章于 2025-03-01 15:51:38 发布
最新推荐文章于 2025-03-01 15:51:38 发布
阅读量673 收藏
点赞数 1
分类专栏： Python 文章标签： SQLAlchemy python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/AtlanSI/article/details/84893943
版权

SQLAlchemy模块

一.概述

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

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

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

二.内部处理(创建连接)

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

from sqlalchemy import create_engine
  
  
engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/数据库", 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='IP', 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。

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

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

Base = declarative_base()
#固定语句，创建一个父类

# 创建单表
#往下所有的类都需要继承Base这个父类
class Users(Base):
   __tablename__ = 'users'
   id = Column(Integer, primary_key=True)
   name = Column(String(32))
   extra = Column(String(16))
   #Column（数据类型，属性）固定写法

   __table_args__ = (
   UniqueConstraint('id', 'name', name='uix_id_name'),
   #创建联合唯一索引
       Index('ix_id_name', 'name', 'extra'),
       #创建索引
   )


# 外键索引
class Favor(Base):
   __tablename__ = 'favor'
   nid = Column(Integer, primary_key=True)
   #设置主键
   caption = Column(String(50), default='red', unique=True)
   #设置唯一键


class Person(Base):
   __tablename__ = 'person'
   nid = Column(Integer, primary_key=True)
   #设置主键
   name = Column(String(32), index=True, nullable=True)
   #设置索引，不为null
   favor_id = Column(Integer, ForeignKey("favor.nid"))
   #设置外键


# 多外键索引
class Group(Base):
   __tablename__ = 'group'
   id = Column(Integer, primary_key=True)
   name = Column(String(64), unique=True, nullable=False)
   port = Column(Integer, default=22)


class Server(Base):
   __tablename__ = 'server'

   id = Column(Integer, primary_key=True, autoincrement=True)
   hostname = Column(String(64), unique=True, nullable=False)


class ServerToGroup(Base):
   __tablename__ = 'servertogroup'
   nid = Column(Integer, primary_key=True, autoincrement=True)
   #设置主键，自动增长
   server_id = Column(Integer, ForeignKey('server.id'))
   #设置外键
   group_id = Column(Integer, ForeignKey('group.id'))


def init_db():
   Base.metadata.create_all(engine)
   #指明使用的连接器
   #这个方法会自动寻找Base父类下的所有子类进行执行


def drop_db():
   Base.metadata.drop_all(engine)

注：设置外检的另一种方式 ForeignKeyConstraint([‘other_id’], [‘othertable.other_id’])

增

engine = create_engine("mysql+pymysql://Atlan:密码@atlan.top:3306/ORM?charset=utf8", max_overflow=5)
Session = sessionmaker(bind=engine)
session = Session()

obj1 = Users(name='Atlan',extra='黑金')
#Users为上方创建的类，此处作用是表名
session.add(obj1)
#单条数据插入

objs = [
    Users(name='Altan',extra='bolu'),
    Users(name='wangwu',extra='lisi'),
    Users(name='wang', extra='lisi')
]
session.add_all(objs)
#add_all会让整个容器类型的数据进行写入
session.commit()
session.close()

删除

engine = create_engine("mysql+pymysql://Atlan:密码@atlan.top:3306/ORM?charset=utf8", max_overflow=5)
Session = sessionmaker(bind=engine)
session = Session()
session.query(Users.id,Users.name,Users.extra).filter(Users.id > 8).delete()
#删除行，需使用查询的语句进行删除
session.commit()
#提交修改
session.close()
#关闭会话连接

改

engine = create_engine("mysql+pymysql://Atlan:密码@atlan.top:3306/ORM?charset=utf8", max_overflow=5)
Session = sessionmaker(bind=engine)
session = Session()

session.query(Users.id,Users.name,Users.extra).filter(Users.id > 7).update({'name':'baba'})
update(这里写要修改的列和值，以字典的方式传入)

session.query(Users).filter(Users.id > 2).update({Users.name: Users.name + "099"}, synchronize_session=False)
此处update中的内容是让user.name（数据类型为字符串）这个字段加上’099‘（字符串相加操作）

session.query(Users).filter(Users.id > 2).update({"num": Users.num + 1}, synchronize_session="evaluate")
此处update中的内容是让user.name（数据类型为int）这个字段加上1（int相加操作）

session.commit()
#提交修改
session.close()
#关闭会话连接

查

engine = create_engine("mysql+pymysql://Atlan:密码@atlan.top:3306/ORM?charset=utf8", max_overflow=5)
Session = sessionmaker(bind=engine)
session = Session()

user_type_list = session.query(Users).all()
all()是将结果取回
print(type(user_type_list))
返回列表，列表的每个元素都是对象
user_type_list = session.query(Users.name,Users.extra).filter(Users.id > 3)
query(这是写要查询的列),filter(这里写过滤条件（是python的表达式）)

for i in user_type_list:
    print(i.name,i.extra)
#循环打印值
session.commit()
#提交修改
session.close()
#关闭会话连接

#　条件
engine = create_engine("mysql+pymysql://Atlan:密码@atlan.top:3306/ORM?charset=utf8", max_overflow=5)
Session = sessionmaker(bind=engine)
session = Session()
ret = session.query(Users).filter_by(name='alex').all()
#filter_by和filter一样,括号中是表达式非SQL条件
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()
#in需要_(下划线)固定写法
ret = session.query(Users).filter(~Users.id.in_([1,3,4])).all()
#~（波浪号）表示not
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()
#and_()括中的内容是and关系
ret = session.query(Users).filter(or_(Users.id < 2, Users.name == 'eric')).all()
#or_（）括号中的内容是or关系
ret = session.query(Users).filter(
    or_(
        Users.id < 2,
        and_(Users.name == 'eric', Users.id > 3),
        Users.extra != ""
    )).all()
    session.commit()
#提交修改
session.close()
#关闭会话连接
  #组合关系


# 通配符
ret = session.query(Users).filter(Users.name.like('e%')).all()
ret = session.query(Users).filter(~Users.name.like('e%')).all()
#~（波浪号）表示not

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

# 排序
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()
#左连接
ret = session.query(Person,isouter=True).join(Favor).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()
session.commit()
#提交修改
session.close()
#关闭会话连接

relationship操作

class Favor(Base):
    #单独创建一个表
    __tablename__ = 'favor'
    nid = Column(Integer, primary_key=True)
    caption = Column(String(50), default='red', unique=True)
    
class Person(Base):
    __tablename__ = 'person'
    nid = Column(Integer, primary_key=True)
    name = Column(String(32), index=True, nullable=True)
    favor_id = Column(Integer, ForeignKey("favor.nid"))
    #ForeignKey("favor.nid")指明外键为favor表的nid字段
    user_type = relationship("Favor",backref='xxoo')
    # relationship 跟外键捆绑在一起使用
    # relationship('这里写和外键同一个表'（这里写的是从Person获取Favor的数据），\
    # backref='这里任意写'（这里写的是从Favor获取Person的数据行）)
    #这里相当创建一个快捷方式
    #两张表根据外键连接的时候可以直接使用user_type来获取对应的行（以外键为条件对应）
    #例如where Person.facor_id = Favor.nid 这样使用user_type可以帮我们自动完成

例如

user_list = session.query(Person.name,Favor.caption).join(Favor,isouter=True).all()
for row in user_list:
    print(row[0],row[1],row.name,row.caption)
#正常通过外联获取值

#使用了relationship的
user_list = session.query(Person)
for row in user_list:
    print(row.name,row.id,row.user_type.caption)

"""
1   白金
2   黑金
obj.xx ==> [obj,obj...]
"""
class UserType(Base):
    #单独创建一个表
    __tablename__ = 'favor'
    id = Column(Integer, primary_key=True)
    title = Column(String(50), default='red', unique=True)

"""
1   Atlan  1
2   wangwu   1
3   lisi    2
# 正向
ut = relationship（backref='xx'）
obj.ut ==> 1   白金
"""
class Users(Base):
    __tablename__ = 'person'
    id = Column(Integer, primary_key=True)
    name = Column(String(32), index=True, nullable=True)
    user_type_id = Column(Integer, ForeignKey("UserType.nid"))
    #ForeignKey("favor.nid")指明外键为favor表的nid字段
    user_type = relationship("UserType",backref='xxoo')
    # relationship 跟外键捆绑在一起使用
    # relationship('这里写和外键同一个表'（这里写的是从Person获取Favor的数据），\
    # backref='这里任意写'（这里写的是从Favor获取Person的数据行）)
    #这里相当创建一个快捷方式
    #两张表根据外键连接的时候可以直接使用user_type来获取对应的行（以外键为条件对应）
    #例如where Person.facor_id = Favor.nid 这样使用user_type可以帮我们自动完成

#获取用户类型  (表如上)  
#使用正常方式
type_list = session.query(UserType)
for row in type_list:
    print(row.id,row.title,session.query(Users).filter(Users.user_type_id == row.id).all())
 
#使用 relationship  
    type_list = session.query(UserType)
for row in type_list:
    print(row.id,row.title,row.xxoo)
python alchemy_python之sqlalchemy模块
weixin_32427471的博客
01-14 517
一、sqlalchemy简介SQLAlchemy是Python编程语言下的一款开源软件。提供了SQL工具包及对象关系映射(ORM)工具，使用MIT许可证发行。SQLAlchemy“采用简单的Python语言，为高效和高性能的数据库访问设计，实现了完整的企业级持久模型”。SQLAlchemy的理念是，SQL数据库的量级和性能重要于对象集合；而对象集合的抽象又重要于表和行。因此，SQLAlchmey采...
Python使用sqlalchemy模块连接数据库操作示例
09-19
### Python使用sqlalchemy模块连接数据库操作详解 #### 一、SQLAlchemy简介 SQLAlchemy是一个Python SQL工具包和ORM（对象关系映射），它提供了一整套全面的企业级持久化模式功能，包括活跃记录模式、数据映射器...
sqlalchemy
02-07
The SQLAlchemy Object Relational Mapper presents a method of associating user-defined Python classes with database tables, and instances of those classes (objects) with rows in their corresponding tables. It includes a sys- tem that transparently synchronizes all changes in state between objects and their related rows, called a unit of work, as well as a system for expressing database queries in terms of the user defined classes and their defined relationships between each other. The ORM is in contrast to the SQLAlchemy Expression Language, upon which the ORM is constructed. Whereas the SQL Expression Language, introduced in SQL Expression Language Tutorial, presents a system of representing the primitive constructs of the relational database directly without opinion, the ORM presents a high level and abstracted pattern of usage, which itself is an example of applied usage of the Expression Language. While there is overlap among the usage patterns of the ORM and the Expression Language, the similarities are more superficial than they may at first appear. One approaches the structure and content of data from the perspective of a user-defined domain model which is transparently persisted and refreshed from its underlying storage model. The other approaches it from the perspective of literal schema and SQL expression representations which are explicitly composed into messages consumed individually by the database. A successful application may be constructed using the Object Relational Mapper exclusively. In advanced situations, an application constructed with the ORM may make occasional usage of the Expression Language directly in certain areas where specific database interactions are required. The following tutorial is in doctest format, meaning each >>> line represents something you can type at a Python command prompt, and the following text represents the expected return value.
SQLAlchemy模块的使用教程
a9794666的博客
04-01 153
数据库表是一个二维表，包含多行多列。把一个表的内容用Python的数据结构表示出来的话，可以用一个list表示多行，list的每一个元素是tuple，表示一行记录，比如，包含id和name的user表： [ ('1', 'Michael'), ('2', 'Bob'), ('3', 'Adam') ] Python的DB-API返回的数据结构就...
SQLAlchemy系列教程：SQLAlchemy快速入门示例项目
最新发布
neweastsun的专栏
03-01 555
这在用户和地址之间创建了双向关系。SQLAlchemy简化了数据库交互，并为Python项目带来了ORM功能。通过本指南中详细介绍的适当设置，你将能够创建可伸缩、可维护且高效的数据库应用程序。
Python 数据持久层ORM框架 SQLAlchemy模块
weixin_54217348的博客
03-13 3394
SQLAlchemy：强大的数据库抽象层，简化ORM操作，提供高效查询接口，支持多种数据库引擎。解锁数据交互潜能，助力开发者专注业务逻辑。选择SQLAlchemy，让数据库管理变得轻松而高效！
python的sqlalchemy模块
echo_Ae的博客
12-02 544
安装：python -m pip install SQLAlchemy（命令行） 第一步下载了之后 我们要先查询它的版本（检查是否安装正确） import sqlalchemy print(sqlalchemy.__version__) # 查询版本 1.1.14 那我们来查询数据库里面的某个表全部数据： from sqlalchemy import create_
Flask中sqlalchemy模块的实例用法
09-16
本篇文章将详细介绍如何在Flask应用中使用SQLAlchemy模块，包括安装、配置、初始化、定义模型以及处理关系。 **一、安装** 在开始使用Flask-SQLAlchemy之前，需要先确保已经安装了相应的库。可以通过以下命令来...
Python的SQLalchemy模块连接与操作MySQL的基础示例
09-10
安装完成后，可以导入SQLAlchemy模块并尝试运行一些测试代码来验证安装是否成功。 3. **连接MySQL数据库** 使用SQLAlchemy连接MySQL数据库，需要创建一个数据库引擎。这通常通过`create_engine()`函数完成，传入...
采用python中SQLalchemy模块访问数据库_IT168文库1
08-04
首先，需要导入 SQLAlchemy 模块，并建立数据库引擎。 ```python from sqlalchemy import * from sqlalchemy.orm import * mysql_engine = create_engine("$address", echo, module) ``` 其中，`$address` 是数据库...
SQLAlchemy
weixin_33877885的博客
02-20 1202
SQLAlchemy 1.介绍 SQLAlchemy是一个基于Python实现的ORM框架。该框架建立在 DB API之上，使用关系对象映射进行数据库操作，简言之便是：将类和对象转换成SQL，然后使用数据API执行SQL并获取执行结果。 pip3 install sqlalchemy 组成部分： Engine，框架的引擎 Connection Pooling ，数据库连接池 Dialect，选择连...
Python常用模块：sqlalchemy
人不风流枉少年
01-25 737
sqlalchemy是Python的ORM框架，类似于Java中的Hibernate框架。 sqlalchemy = “" mysql = "” mysql-connector = “*” from sqlalchemy import Column, Integer, String, create_engine, ForeignKey from sqlalchemy.orm import sess...
sqlalchemy模块的基本使用
dnfo2073的博客
09-03 135
Python中SQLAlchemy模块通过建立orm来对数据库进行操作 1. 建表 　　方式1 # -*- coding:utf-8 -*- # Author:Wong Du from sqlalchemy import create_engine from sqlalchemy.ext.declarative import declarative_bas...
Python编程：orm之sqlalchemy模块
彭世瑜的博客
02-03 1496
orm英文全称object relational mapping,对象映射关系 http://www.sqlalchemy.org/ 常用操作 """ MySQL-Python mysql+mysqldb://:@[:]/ pymysql mysql+pymysql://:@/[?] MySQL-Connector mysql+mysqlconnector
Flask-SQLAlchemy模块实战教程
本文主要介绍了如何在Flask应用中使用SQLAlchemy模块，包括安装、配置以及初始化的基本步骤。 在Python的Web开发框架Flask中，SQLAlchemy是一个强大的ORM（对象关系映射）库，用于处理数据库操作。它使得开发者可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值