SQLAlchemy学习

最新推荐文章于 2024-11-10 15:33:43 发布
最新推荐文章于 2024-11-10 15:33:43 发布
阅读量121 收藏
点赞数
文章标签： 数据库 python
原文链接：http://www.cnblogs.com/ryxiong-blog/p/11278235.html
版权

一SQLAlchemy简介

SQLAlchemy是一个基于Python实现的ORM框架。该框架建立在 DB API之上，使用关系对象映射进行数据库操作，简言之便是：将类和对象转换成SQL，然后使用数据API执行SQL并获取执行结果。

1.与Django中models的区别

很多小伙伴说SQLAlchemy不如Django的models好用，这里我们需要知道。

Models其实只是配置和使用比较简单，毕竟是Django自带的ORM框架，但是兼容性远不如SQLAchemy，真正算得上全面的ORM框架必然是SQLAlchemy。

无论使用什么ORM框架，其实都是为了方便不熟练数据库使用的同学，最推荐的还是使用原生的SQL语句，也建议大家攻克SQL难关。

2.SQLAlchemy组成

组成部分：

  • Engine，框架的引擎

  • Connection Pooling ，数据库连接池

  • Dialect，选择连接数据库的DB API种类

  • Schema/Types，架构和类型

  • SQL Exprression Language，SQL表达式语言

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

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

二、SQLAlchemy使用

1.执行原生sql语句

通过SQLAlchemy执行源生的sql语句

方式一：

from sqlalchemy import create_engine
​
engine = create_engine(
    "mysql+pymysql://root:123@127.0.0.1:3306/sqlalchemy01?charset=utf8",
    max_overflow=0,  # 超过连接池大小外最多创建的连接
    pool_size=5,  # 连接池大小
    pool_timeout=30,  # 池中没有线程最多等待的时间，否则报错
    pool_recycle=-1  # 多久之后对线程池中的线程进行一次连接的回收（重置）
)
​
​
def task():
    conn = engine.raw_connection()
    cursor = conn.cursor()
    cursor.execute(
        "select * from t1"
    )
    result = cursor.fetchall()
    print(">>>",result)
    cursor.close()
    conn.close()
​
task()

方式二：

from sqlalchemy import create_engine
​
engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/sqlalchemy01", max_overflow=0, pool_size=5)
​
​
def task():
    conn = engine.connect()
    with conn:
        cur = conn.execute(
            "select * from t1"
        )
        result = cur.fetchall()
        print(result)
​
task()

方式三

from sqlalchemy import create_engine
​
engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/sqlalchemy01", max_overflow=0, pool_size=5)
​
​
def task():
    cur = engine.execute("select * from t1")
    result = cur.fetchall()
    cur.close()
    print(result)
​
task()

2.数据表的操作

通过sqlalchemy来创建表和删除表

import datetime
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, Text, ForeignKey, DateTime, UniqueConstraint, Index
​
# 建立基础类 R关系 M映射 类
Base = declarative_base()
​
​
class Users(Base):
    __tablename__ = 'users'  # 指定创建的表名
​
    # 写字段
    id = Column(Integer, primary_key=True)
    name = Column(String(32), index=True, nullable=False)
    email = Column(String(32), unique=True)
    # ctime = Column(DateTime, default=datetime.datetime.now)
    # extra = Column(Text, nullable=True)
​
    __table_args__ = (
        UniqueConstraint('id', 'name', name='uix_id_name'),  # 设置位移约束
        Index('ix_id_name', 'name', 'email'),  # 设置索引
    )
​
​
# 创建数据库的引擎
engine = create_engine(
    "mysql+pymysql://root:123@127.0.0.1:3306/sqlalchemy01?charset=utf8",
    max_overflow=0,  # 超过连接池大小外最多创建的连接
    pool_size=5,  # 连接池大小
    pool_timeout=30,  # 池中没有线程最多等待的时间，否则报错
    pool_recycle=-1  # 多久之后对线程池中的线程进行一次连接的回收（重置）
)
​
# 检索所有继承Base的Object并在 engine 指向的数据库中创建所有的表
Base.metadata.create_all(engine)
​
# 删除所有的数据库表
Base.metadata.drop_all(engine)
1.单表创建示例
import datetime
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, Text, ForeignKey, DateTime, UniqueConstraint, Index
​
# 建立基础类 R关系 M映射 类
Base = declarative_base()
​
​
class Users(Base):
    __tablename__ = 'users'  # 指定创建的表名
​
    # 写字段
    id = Column(Integer, primary_key=True)
    name = Column(String(32), index=True, nullable=False)
    email = Column(String(32), unique=True)
    # ctime = Column(DateTime, default=datetime.datetime.now)
    # extra = Column(Text, nullable=True)
​
    __table_args__ = (
        UniqueConstraint('id', 'name', name='uix_id_name'),  # 设置位移约束
        Index('ix_id_name', 'name', 'email'),  # 设置索引
    )
​
​
# 创建数据库的引擎
engine = create_engine(
    "mysql+pymysql://root:123@127.0.0.1:3306/sqlalchemy01?charset=utf8",
    max_overflow=0,  # 超过连接池大小外最多创建的连接
    pool_size=5,  # 连接池大小
    pool_timeout=30,  # 池中没有线程最多等待的时间，否则报错
    pool_recycle=-1  # 多久之后对线程池中的线程进行一次连接的回收（重置）
)
​
# 检索所有继承Base的Object并在 engine 指向的数据库中创建所有的表
Base.metadata.create_all(engine)
​
# 删除所有的数据库表
Base.metadata.drop_all(engine)
2.一对多示例
# ########## 一对多示例 ##########
class School(Base):
    __tablename__ = "school"
    id = Column(Integer,primary_key=True)
    name = Column(String(32),nullable=False)
​
​
class Student(Base):
    __tablename__ = "student"
    id = Column(Integer,primary_key=True)
    name = Column(String(32),nullable=False)
    school_id = Column(Integer,ForeignKey("school.id")) # 多对一关系存储列
​
    # 与生成表结构无关，仅用于查询方便
    school = relationship("School", backref='student')
    
engine = create_engine("mysql+pymysql://root:root@127.0.0.1:3306/sqlalchemy01?charset=utf8")
​
# 检索所有继承 Model 的Object 并在 engine 指向的数据库中创建 所有的表
Model.metadata.create_all(engine)
3.多对多表结构创建
from sqlalchemy import Column,Integer,String,ForeignKey
from sqlalchemy.orm import relationship
​
class Girls(Model):
    __tablename__ = "girl"
    id = Column(Integer,primary_key=True)
    name = Column(String(32),nullable=False)
    # relationship
    g2b = relationship("Boys",backref="b2g",secondary="hotel")
​
​
class Boys(Model):
    __tablename__ = "boy"
    id = Column(Integer,primary_key=True)
    name = Column(String(32),nullable=False)
​
​
class Hotels(Model):
    __tablename__ = "hotel"
    id = Column(Integer,primary_key=True)
    boy_id = Column(Integer,ForeignKey("boy.id"))
    girl_id = Column(Integer,ForeignKey("girl.id"))
    
engine = create_engine("mysql+pymysql://root:root@127.0.0.1:3306/sqlalchemy01?charset=utf8")
​
# 检索所有继承 Model 的Object 并在 engine 指向的数据库中创建 所有的表
Model.metadata.create_all(engine)
4.定义函数来创建和删除表
def init_db():
    """
    根据类创建数据库表
    :return: 
    """
    engine = create_engine(
        "mysql+pymysql://root:123@127.0.0.1:3306/s6?charset=utf8",
        max_overflow=0,  # 超过连接池大小外最多创建的连接
        pool_size=5,  # 连接池大小
        pool_timeout=30,  # 池中没有线程最多等待的时间，否则报错
        pool_recycle=-1  # 多久之后对线程池中的线程进行一次连接的回收（重置）
    )
​
    Base.metadata.create_all(engine)
​
​
def drop_db():
    """
    根据类删除数据库表
    :return: 
    """
    engine = create_engine(
        "mysql+pymysql://root:123@127.0.0.1:3306/s6?charset=utf8",
        max_overflow=0,  # 超过连接池大小外最多创建的连接
        pool_size=5,  # 连接池大小
        pool_timeout=30,  # 池中没有线程最多等待的时间，否则报错
        pool_recycle=-1  # 多久之后对线程池中的线程进行一次连接的回收（重置）
    )
​
    Base.metadata.drop_all(engine)
​
​
if __name__ == '__main__':
    drop_db()
    init_db()

3.记录的增删改查

数据库记录操作的两种方式

from sqlalchemy.orm import sessionmaker
from sqlalchemy import create_engine
from models import Users
 
engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/s6", max_overflow=0, pool_size=5)
############方式一#############
Session = sessionmaker(bind=engine)
 
# 每次执行数据库操作时，都需要创建一个session
session = Session()
 
# ############# 执行ORM操作 #############
obj1 = Users(name="alex1")
session.add(obj1)
 
# 提交事务
session.commit()
# 关闭session
session.close()
​
###########方式二###########
# 方式二：支持线程安全，为每个线程创建一个session
            #               - threading.Local
            #               - 唯一标识
            # ScopedSession对象
            #       self.registry(), 加括号 创建session
            #       self.registry(), 加括号 创建session
            #       self.registry(), 加括号 创建session
            from greenlet import getcurrent as get_ident
Session = sessionmaker(bind=engine)
            session = scoped_session(Session,get_ident)
            # session.add
            # 操作
            session.remove()
1.单表的增删改查
from day101_sqlAlchemy.SQLAlchemy02_create_table_single import engine,Users
from sqlalchemy.orm import sessionmaker
​
Session = sessionmaker(engine)  # 新建数据库的查询窗口
db_session = Session()  # 打开查询窗口
​
# 增加单条数据
# u = Users(name="ryxiong")  # 新建insert语句 insert into
# db_session.add(u)  # 将insert语句移动到 db_session 查询窗口
# db_session.commit()  # 执行查询窗口中的所有语句
# db_session.close()  # 关闭查询窗口
​
# 增加多条数据
# u_list = [Users(name="egon"),Users(name="alex")]
# db_session.add_all(u_list)  # 添加多条数据
# db_session.commit()
# db_session.close()
​
​
# 查询数据
# res = db_session.query(Users).all()  # 查询所有数据
# for user in res:
#     print(user.id,user.name)
​
# res = db_session.query(Users).first()  # 查询符合条件的第一条数据
# print(res.id,res.name)  # 3 alex
​
# 并列条件查询
# res = db_session.query(Users).filter(Users.id<3,Users.name=="ryxiong").all()
# for user in res:
#     print(user.id,user.name)  # 1 ryxiong
​
# res = db_session.query(Users).filter(Users.id<3,Users.name=="ryxiong").first()
# print(res.id,res.name)  # 1 ryxiong
​
​
# 修改数据
# db_session.query(Users).filter(Users.id==2).update({"name":"Egon"})
# db_session.commit()
​
# 删除数据
db_session.query(Users).filter(Users.id==3).delete()
db_session.commit()
2.一对多的增删改查
from day101_sqlAlchemy.SQLAlchemy03_create_table_foreignKey import engine,Student,School
from sqlalchemy.orm import sessionmaker
​
Session = sessionmaker(engine)  # 新建数据库的查询窗口
db_session = Session()  # 打开查询窗口
​
# 增加一条数据
# school = School(name="新东方")
# db_session.add(school)
# db_session.commit()
​
# 在添加学生
# school_fir = db_session.query(School).filter(School.name=="新东方").first()
#
# student = Student(name="ryxiong",school_id=school_fir.id)
# db_session.add(student)
# db_session.commit()
​
# 1.添加数据 relationship 正向添加数据
# stu = Student(name="alex",school=School(name="蓝翔"))
# db_session.add(stu)
# db_session.commit()
​
# 2.添加数据relationship 反向添加数据
# sch = School(name="蓝翔")
# sch.student = [
#     Student(name="egon"),
#     Student(name="wusir")
# ]
# db_session.add(sch)
# db_session.commit()
​
​
# 查询
# 1.relationship正向查询
res = db_session.query(Student).all()
for stu in res:
    print(stu.id,stu.name,stu.school.name)
​
# 2.relationship反向查询
res = db_session.query(School).all()
for sch in res:
    for stu in sch.student:
        print(sch.name,stu.id,stu.name)
3.多对多查询
from day101_sqlAlchemy.SQLAlchemy04_create_table_M2M import engine,Boys,Girls
from sqlalchemy.orm import sessionmaker
​
Session = sessionmaker(engine)  # 新建数据库的查询窗口
db_session = Session()  # 打开查询窗口
​
# 添加数据
# 1.relationship正向添加
# girl = Girls(name="Nancy",boy=[Boys(name="ryxiong"),Boys(name="alex")])
# db_session.add(girl)
# db_session.commit()
​
# 2.relationship反向添加
# boy = Boys(name="egon")
# boy.girl = [
#     Girls(name="罗玉凤"),
#     Girls(name="朱利安"),
# ]
#
# db_session.add(boy)
# db_session.commit()
​
# 查询数据
​
# 1.relationship 正向查询
​
res = db_session.query(Girls).all()
for girl in res:
    for boy in girl.boy:
        print(girl.name,boy.name)
​
# 2.relationship 反向查询
res = db_session.query(Boys).all()
for boy in res:
    for girl in boy.girl:
        print(boy.name,girl.name)

 4.记录的高级查询

from day101_sqlAlchemy.SQLAlchemy02_create_table_single import engine,Users
from sqlalchemy.sql import text
from sqlalchemy.orm import sessionmaker
from sqlalchemy import and_,or_
​
Session = sessionmaker(engine)  # 新建数据库的查询窗口
db_session = Session()  # 打开查询窗口
​
# 逻辑条件查询 and/or
# ret1 = db_session.query(Users).filter(and_(Users.id<3,Users.name=="ryxiong")).all()
# print(ret1)
# ret2 = db_session.query(Users).filter(or_(Users.id<2,Users.name=="egon")).all()
# print(ret2)
#
# ret3 = db_session.query(Users).filter(
#     or_(
#         and_(Users.id==1,Users.name=="ryxiong"),
#         and_(Users.id==2,Users.name=="egon")
#     )
# ).all()
# print(ret3)
​
​
# 查询所有数据排序
# ret = db_session.query(Users).order_by(Users.id.asc()).all()  # 按照id升序排列
#
# print(ret)
​
​
# 查询数据，指定查询数据列，加入别名
# ret = db_session.query(Users.name.label("username"),Users.id).first()
#
# print(ret)  # ('alex', 3)
# print(ret.id,ret.username)  # 3 alex
​
# 表达式筛选条件
# user_list = db_session.query(Users).filter(Users.name=="ryxiong").all()
# user_list1 = db_session.query(Users).filter_by(name="ryxiong").all()
# for user in user_list:
#     print(user.name)
​
​
# 复杂查询
# user_list2 = db_session.query(Users).filter(text("id<:value and name=:name")).params(value=3,name="ryxiong")
# print(user_list2)
​
​
# 查询语句
# user_list3 = db_session.query(Users).filter(text("select * from user id<:value and name=:name")).params(value=3,name="ryxiong")
# print(user_list3)
​
​
# 其他查询条件
# ret = db_session.query(Users).filter(Users.id.between(1,3)).all()  # 查询id值在1-3之间，不包含3的
# print(ret)
#
# ret1 = db_session.query(Users).filter(Users.id.in_([1,2])).all()  # 查询id在列表[1,2]中的用户
# print(ret1)
#
# ret2 = db_session.query(Users).filter(~Users.id.in_([1,2])).all()  # 查询用户id不在列表[1,2]中的。
# print(ret2)
​
# 子查询
# ret3 = db_session.query(Users).filter(Users.id.in_(db_session.query(Users.id).filter_by(name="ryxiong"))).all()
# print(ret3)
​
# 通配符
# ret4 = db_session.query(Users).filter(Users.name.like("%ong")).all()
# print(ret4)
# ret5 = db_session.query(Users).filter(~Users.name.like("%ong")).all()
# print(ret5)
​
​
# 切片
# ret6 = db_session.query(Users)[1:2]
# print(ret6)
​
​
# 分组 group_by
from sqlalchemy.sql import func
# ret7 = db_session.query(Users).group_by(Users.name).all()
# print(ret7)
​
​
# 聚合函数
ret8 = db_session.query(
    func.max(Users.id),
    func.sum(Users.id),
    func.min(Users.id),
).group_by(Users.name).all()
print(ret8)  # [(3, Decimal('3'), 3), (2, Decimal('2'), 2), (1, Decimal('1'), 1)]
​
​
ret9 = db_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()
print(ret9)  # [(3, Decimal('3'), 3)]

 

 

转载于:https://www.cnblogs.com/ryxiong-blog/p/11278235.html

weixin_30808693
关注
SQLAlchemy 学习文档
06-06
SQLAlchemy 学习文档 SQLAlchemy 是一个 Python SQL 工具库，提供了一个高级的对象关系映射（Object-Relational Mapping，ORM）系统，可以让开发者使用 Python 语言操作关系数据库。下面是 SQLAlchemy 学习文档的...
SQLAlchemy学习笔记1
03-18
这篇“SQLAlchemy学习笔记1”可能涉及了初学者入门的一些核心概念，包括数据库配置、模型定义、会话管理以及基本的CRUD操作。 首先，SQLAlchemy的核心概念是`Engine`，它是与数据库进行通信的接口。通过配置连接...
Python ORM框架SQLAlchemy学习笔记之映射类使用实例和Session会话介绍
12-25
1. 创建映射类的实例(Instance) 前面介绍了如何将数据库实体表映射到Python类上，下面我们可以创建这个类的一个实例(Instance)，我们还是以前一篇文章的User类为例，让我们创建User对象：复制代码 代码如下:>>> ed_...
Python ORM框架SQLAlchemy学习笔记之关系映射实例
01-20
昨天简单介绍了SQLAlchemy的使用，但是没有能够涉及其最精彩的ORM部分，今天我将简单说明一下，当然主要还是讲解官方文档的内容，由于是学习笔记，有可能存在精简或者自己理解的部分，不做权威依据。 当我们开始使用...
Python ORM框架SQLAlchemy学习笔记之数据添加和事务回滚介绍
01-20
1. 添加一个新对象 前面介绍了映射到实体表的映射类User，如果我们想将其持久化(Persist)，...因为SQLAlchemy采取的是Lazyload策略，也就是说现在这个对象被标记为Pending准备状态，但没有执行任何可能导致数据库变化
07 Oracle数据库恢复基础解析：从检查点到归档，一步步构建数据安全防线
超哥的博客
11-09 839
检查点是Oracle数据库中的一个特殊事件，它的作用是将内存中的数据块同步到磁盘上，以确保数据的持久性。简单来说，就是让数据库“记住”到目前为止所有的更改。Redo日志是Oracle用来记录所有数据更改的日志文件。每次对数据库进行修改时，都会先写入Redo日志，然后再写入数据文件。这样，即使系统崩溃，也能通过Redo日志恢复数据。当数据库运行在归档模式下时，一旦当前的Redo日志文件满，Oracle会将其复制到一个安全的存储位置，并标记为已归档。这样可以长期保留Redo日志，便于历史数据的恢复。
2024.11.6-Redis的事务与持久化
whisper_Java 的博客
11-06 780
MULTI、EXEC、DISCARD和WATCH 是 Redis 事务相关的命令。Redis的事务是将一系列待执行的指令存到一个Queue中，并使用exec执行事务。​--1. Redis事务是一个独立的隔离机制：事务中的所有命令都会序列化到queue、并按顺序地执行queue里的指令。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断。​​multi: 用于开启事务，将待执行的命令放入到队列中exec命令:负责触发并执行事务中的所有命令：discard: 用于取消组队。
Redis - 事务
ketil27的博客
11-08 796
Redis 的事务和MySQL的事务概念上是类似的.都是把⼀系列操作绑定成⼀组.让这⼀组能够批量执 ⾏.弱化的原⼦性:redis没有"回滚机制".只能做到这些操作"批量执⾏".不能做到"⼀个失败就恢复到 初始状态".不保证⼀致性:不涉及"约束". 也没有回滚.MySQL的⼀致性体现的是运⾏事务前和运⾏后,结果都 是合理有效的,不会出现中间⾮法状态.不需要隔离性:也没有隔离级别,因为不会并发执⾏事务(redis单线程处理请求).
windows11安装redis
qq_42985657的博客
11-06 414
下载免安装版本，鼠标点击一下自动下载。解压。
【达梦数据库】Oracle数据库通过DTS工具迁移数据到达梦数据库--索引数量存在出入
weixin_47686079的博客
11-06 139
【代码】【达梦数据库】Oracle数据库通过DTS迁移到达梦数据库索引数量不一致。
SpringBoot助力的共享汽车业务优化系统
2402_85762143的博客
11-09 916
在整个系统测试中，根据需求文档和设计文档，逐一对功能进行检测并写好测试用例，有效避免残片缺陷，因为产品出现缺陷不仅影响功能，而且可以导致数据的不准确，导致产品质量的降低，经过测试，才能使得产品的稳定性和成熟度得到极大的提升，产品质量也才有保证。近来，软件工程界趋向于一种新的观点，即认为软件生命周期每一阶段中都应包含测试，从而检验本阶段的成果是否接近预期的目标，尽可能早的发现错误并加以修正，如果不在早期阶段进行测试，错误的延时扩散常常会导致最后成品测试的巨大困难。任务：消除软件故障，保证程序的可靠运行。
Java基于小程序公考学习平台的设计与实现（附源码，文档）
chusheng1840的博客
11-09 838
Java基于小程序公考学习平台的设计与实现，小程序公考学习平台使用Java语言进行编码，使用Mysql创建数据表保存本系统产生的数据。系统可以提供信息显示和相应服务，其管理小程序公考学习平台信息，查看小程序公考学习平台信息，管理小程序公考学习平台。总之，小程序公考学习平台集中管理信息，有着保密性强，效率高，存储空间大，成本低等诸多优点。它可以降低信息管理成本，实现信息管理计算机化。关键词：小程序公考学习平台；Java语言；Mysql。
基于 SpringBoot 实现QQ邮箱验证码注册功能
2301_79201049的博客
11-06 638
找到并开通以下的邮件协议服务，而且服务开启也较为简单，需要我们发送一个短信到指定的号码，开启后平台会提供一个授权码，一定要记住这个授权码，发邮件的时候需要这个。host 是根据服务主机区分，网易邮箱是 smtp.163.com, qq邮箱是 smtp.qq.com。其中的 username 是你第一步中操作的邮箱账号，nickname 是接收者收到邮件中显示的发件人。发送邮件的核心依赖是 mail ，由于该项目还涉及其他依赖就全都导进来了。（1）首先打开QQ邮箱，点击设置并来到账号页面。
现场工程师日记-MSYS2迅速部署PostgreSQL主从备份数据库
丁劲犇技术发布空间
11-09 653
用一主一从两个PostgreSQL实例，基于默认的WAL replica 是最简单的主从方式。对16TB的盘阵，我们保留102GB的WAL空间，这样即使从节点废了，过了1天再开机，也能赶上（主机WAL还没被清理）。本文章介绍从0开始部署主从服务器的步骤。
部署安装jdk8\redis\mysql8\nginx
最新发布
weixin_45969142的博客
11-10 591
部署安装jdk8\redis\mysql8\nginx
springboot使用aop防御用户重复请求
干货分享，希望帮助读者不断提升自己的编程技能，解决工作中实际问题，并激发对技术的无限热爱。
11-09 527
InheritedString message() default "不允许重复提交，请稍候再试";/*** @Author* @Date*/@Aspectthrow new ServiceException("重复提交间隔时间不能小于'1'秒");} else {//解析参数point.getArgs()//获取url//获取 token} else {try {= 200) {return;
【gitlab-ce】各组件介绍
binqian的专栏
11-10 504
Puma 和 Nginx 是两种不同类型的服务器，它们在 Web 应用架构中扮演不同的角色。通过这种组合，可以充分发挥 Nginx 和 Puma 的优势，构建一个高性能、高可用的 Web 服务架构。
【C语言】分布式系统
windy1a的博客
11-08 512
本地性原理（Cache Locality）：尽量将常用数据存储在离请求者最近的地方，例如Redis的哈希槽或Memcached的内存区域，减少网络延迟。一致性问题：在分布式环境中，由于网络延迟、分区容错等原因，保持所有节点的数据同步是一个难题，这涉及到两阶段提交、三阶段 commit 等复杂协议。缓存预热和刷新策略：定期预加载热点数据到缓存，或者设置合理的过期策略，及时更新数据。缓存分片和容量管理：根据系统的负载动态调整缓存大小，确保各个节点的缓存容量平衡。
大数据之多级缓存方案
赵玉的专栏
11-06 999
综上所述，多级缓存架构通过在不同层级上部署多个缓存层，提高了数据访问效率和系统性能。在应用多级缓存架构时，需要仔细权衡这些挑战和优势，并根据具体的应用场景和需求进行设计和优化。在应用多级缓存时，需要根据具体的应用场景和需求进行权衡和选择。综上所述，多级缓存方案是一种有效的优化手段，可以显著提高应用程序的性能和响应速度。在实施多级缓存方案时，需要根据应用程序的特点和需求进行定制化设置，并注意缓存一致性、数据安全性等问题。多级缓存架构是一种在系统的不同层级上部署多个缓存层，以提高数据访问效率和系统性能的策略。
SQLAlchemy数据库操作指南：连接与对象映射
"SQLAlchemy 学习文档" SQLAlchemy 是一个 Python SQL 工具包和 ORM（对象关系映射）系统，它提供了全面的数据库抽象层，使得开发者可以使用 Python 类来定义数据库模式，并通过这些类进行数据库操作。在这个学习...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值