06sqlalchemy

最新推荐文章于 2024-10-14 10:47:23 发布
最新推荐文章于 2024-10-14 10:47:23 发布
阅读量117 收藏
点赞数
分类专栏： tornado
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_14993591/article/details/82458981
版权

ORM

在服务器后台，数据是要存储在数据库的，但是如果项目在开发和部署的时候，是使用的不同的数据库，该怎么办呢？是不是需要把所有的 SQL 语句都再重新写一遍呢？

使用 ORM 隔离框架和数据库

ORM全称 Object Relational Mapping 
对象关系映射

通过 ORM 可以不用关心后台是使用的哪种数据库，只需要按照 ORM 所提供的语法规则去书写相应的代码， ORM 就会自动的转换成对应对应数据库的 SQL 语句

ORM则可以为我们提供一种最自然的方式，即 对象映射方式 来操作数据表。对 数据表 的操作实际上就变成了对指定的 对象 进行操作，数据表中的字段 都被映射到 对象的属性 上面。换句话说，对象属性的变化将直接更新到对应的数据表中去。

ORM 对象关系映射，简而言之，就是把数据库的一个个table(表)，映射为编程语言的class(类)

廖大神

https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/0014320114981139589ac5f02944601ae22834e9c521415000

数据库表是一个二维表，包含多行多列。把一个表的内容用Python的数据结构表示出来的话，可以用一个list表示多行，list的每一个元素是tuple，表示一行记录，比如，包含id和name的user表：

[
    ('1', 'Michael'),
    ('2', 'Bob'),
    ('3', 'Adam')
]

Python的DB-API返回的数据结构就是像上面这样表示的。

但是用tuple表示一行很难看出表的结构。如果把一个tuple用class实例来表示，就可以更容易地看出表的结构来：

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


[
    User('1', 'Michael'),
    User('2', 'Bob'),
    User('3', 'Adam')
]

这就是传说中的ORM技术：Object-Relational Mapping，把关系数据库的表结构映射到对象上。是不是很简单？

但是由谁来做这个转换呢？所以ORM框架应运而生。

在Python中，最有名的ORM框架是SQLAlchemy。

ORM框架的作用就是把数据库表的一行记录与一个对象互相做自动转换。

SQLAlchemy连接数据库

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


上面讲到了 SQLAlchemy 是 python 中常用的 ORM ，那具体该如何操作呢？

#

第一步：安装

安装： mysql
安装python包： pymysql、sqlalchemy

pip安装 python 包

pip install -i https://pypi.douban.com/simple pymysql
pip install -i https://pypi.douban.com/simple sqlalchemy

这里是使用国内的源

第二步：导入模块

from sqlalchemy import create_engine

第三步：数据库数据

HOSTNAME = '127.0.0.1' 
PORT = '3306' 
DATABASE = 'mydb' 
USERNAME = 'admin' 
PASSWORD = 'Root110qwe'


不需要设置端口转发

第四步：数据连接 URL

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


'mysql+pymysql://admin:password@127.0.0.1:3306/test?charset=utf8'
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...]

第五步：连接数据库


engine = create_engine(Db_Uri)



create_engine()用来初始化数据库连接

第六步：测试连接


if __name__=='__main__': 
    connection = engine.connect()
    result = connection.execute('select 1')
    print(result.fetchone())

代码

connect.py

# -*- coding:utf-8 -*-

from sqlalchemy import create_engine

HOSTNAME = '127.0.0.1'      # 在本机上运行
PORT = '3306'               # 端口
DATABASE = 'mydb'           # 数据库
USERNAME = 'admin'          # 用户名
PASSWORD = 'Root110qwe'     # 密码



# 连接数据库的路径
# “mysql+pymysql”指定了使用 pymysql 来连接

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


# 连接数据库
# create_engine() 会返回一个数据库引擎

engine = create_engine(db_url)



if __name__ == '__main__':
    connection = engine.connect()
    result = connection.execute('select 1')
    print(result.fetchone())

终端显示

(1,)

Module

刚才已经使用 SQLAlchemy 连上数据库，现在该如何在数据库里面新建表呢？

第一步：创建 Module 的 Base 类

from sqlalchemy.ext.declarative import declarative_base

# declarative_base() 创建了一个 BaseModel 类，
# 这个类的子类可以自动与一个表关联。
# 创建对象的基类

Base = declarative_base((engine))

对象关系型映射，数据库中的表与python中的类相对应，创建的类必须继承自 sqlalchemy 中的基类。

使用 declarative 方法定义的映射类依据一个基类，这个基类是维系类和数据表关系的目录。

应用通常只需要有一个 Base 的实例。我们通过 declarative_base() 功能创建一个基类。

第二步：创建 Module

from datetime import datetime
from sqlalchemy import Column, Integer, String, DateTime
from connect import Base

class User(Base):
    # 表的名字:
    __tablename__ = 'user'
    # 表的结构:
    id = Column(Integer, primary_key=True, autoincrement=True)  # 主键  自增
    username = Column(String(20), nullable=False)  # 不为空
    password = Column(String(50))
    creatime = Column(DateTime, default=datetime.now)

再次强调，我们用类来表示数据库里面的表！！！

这些表的类都继承于我们的Base基类。

在类里面我们定义一些属性，这个属性通过映射，就对应表里面的字段

第三步：创建 Module

Base.metadata.create_all()
# 找到BaseModel的所有子类(User)，并在数据库中建立这些表User

执行此代码，就会把创建好的 Module 映射到数据库中

Module

__tablename__： 数据库中的表名
Column：    用来创建表中的字段的一个方法
Integer：     整形，映射到数据库中的int类型
String：       字符类型，映射到数据库中的varchar类型，使用时，需要提供一个字符长度
DateTime： 时间类型

通过 SQLAlchemy 提供的语法来声明表

代码

user_module.py

from datetime import datetime
from  sqlalchemy import Column,Integer,String,DateTime
from connect import Base

# 实体类User，对应数据库中的user表
class User(Base):
    # 表的名字:
    __tablename__ = 'user'
    # 表的结构:
    id = Column(Integer, primary_key=True, autoincrement=True)  # 主键  自增
    username = Column(String(20), nullable=False)  # 不为空
    password = Column(String(50))
    creatime = Column(DateTime, default=datetime.now)


if __name__ == '__main__':
    # 找到BaseModel的所有子类，并在数据库中建立这些表
    Base.metadata.create_all()

connect.py

from sqlalchemy import create_engine

HOSTNAME = '127.0.0.1'  # 在本机上运行
PORT = '3306'  # 端口
DATABASE = 'mydb'  # 数据库
USERNAME = 'admin'  # 用户名
PASSWORD = 'Root110qwe'  # 密码


# 连接数据库的路径
# “mysql+pymysql”指定了使用 pymysql 来连接
db_url = 'mysql+pymysql://{}:{}@{}:{}/{}?charset=utf8'.format(
   USERNAME,
   PASSWORD,
   HOSTNAME,
   PORT,
   DATABASE
)


# 连接数据库
# create_engine() 会返回一个数据库引擎

engine = create_engine(db_url)


from sqlalchemy.ext.declarative import declarative_base

# declarative_base() 创建了一个 BaseModel 类，
# 这个类的子类可以自动与一个表关联。
# 创建对象的基类

Base = declarative_base((engine))


if __name__ == '__main__':
   connection = engine.connect()
   result = connection.execute('select 1')
   print(result.fetchone())

增删改查

现在万事具备，只需要往表中进行数据的更改即可，那改如何操作呢？

数据操作

第一步：创建会话

from sqlalchemy.orm import sessionmaker
# sessionmaker() 会生成一个数据库会话类

Session = sessionmaker(engine)

# 创建session对象:
session = Session()
在对表数据进行增删改查之前，先需要建立会话，建立会话之后才能进行操作，
就类似于文件要打开之后才能对文件内容操作

增add

# 创建新User对象:
person = User(username='wu', password='qwe123')

# 添加到session:
session.add(person)

# 提交即保存到数据库:
session.commit()

关键是获取session，然后把对象添加到session，最后提交并关闭。Session对象可视为当前数据库连接。

session.add_all(
    [
        User(username='qq',password = 'qwe'),
        User(username='lala', password='aaa')
    ]
)

session.commit()
add 是添加一条数据， add_all 添加多条数据
代码

test_module.py

from connect import session
from user_module import User

def add_user():
   # 创建新User对象:
    person = User(username='wu', password='qwe123')
    # 添加到session:
    session.add(person)

    session.add_all(
        [
            User(username='qq', password='qwe'),
            User(username='lala', password='aaa')
        ]
    )
    # 提交即保存到数据库:
    session.commit()

if __name__ == '__main__':
   add_user()

connect.py

from sqlalchemy import create_engine

HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'mydb'
USERNAME = 'admin'
PASSWORD = 'Root110qwe'

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


# 连接数据库
engine = create_engine(db_url)


from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base((engine)) # 创建基类


from sqlalchemy.orm import sessionmaker
Session = sessionmaker(engine)
session = Session()   # 建立会话 再进行增删改查


if __name__ == '__main__':
   connection = engine.connect()
   result = connection.execute('select 1')
   print(result.fetchone())

user_module.py

from datetime import datetime
from sqlalchemy import Column, Integer, String, DateTime
from connect import Base


# 实体类User，对应数据库中的user表

class User(Base):
   # 表的名字:
   __tablename__ = 'user'
   # 表的结构:
   id = Column(Integer, primary_key=True, autoincrement=True)  # 主键  自增
   username = Column(String(20), nullable=False)  # 不为空
   password = Column(String(50))
   creatime = Column(DateTime, default=datetime.now)


if __name__ == '__main__':
   # 找到BaseModel的所有子类，并在数据库中建立这些表
   Base.metadata.create_all()

查 query

如何从数据库表中查询数据呢？有了ORM，查询出来的可以不再是tuple，而是User对象。SQLAlchemy提供的查询接口如下：
rows = session.query(User).all()
rows = session.query(User).first()
query 就是查询的意思，在 SQLAlchemy 中也用来查询数据

all 是查询所有的意思
first 是查询第一条数据
代码
from connect import session
from user_module import User


def search_user():
    rows = session.query(User).all()
    print(rows)


if __name__ == '__main__':
    search_user()

终端显示

[<user_module.User object at 0xb687808c>, <user_module.User object at 0xb68782cc>, <user_module.User object at 0xb687832c>, <user_module.User object at 0xb687838c>]

为了显示美观 重写repr

from datetime import datetime
from sqlalchemy import Column,Integer,String,DateTime
from connect import Base

class User(Base):
   __tablename__ = 'user'
   id = Column(Integer,primary_key=True,autoincrement=True)
   username = Column(String(20),nullable=False)
   password = Column(String(50))
   creatime = Column(DateTime,default=datetime.now)

   def __repr__(self):
      return "<User(id=%s,username=%s,password=%s,creatime=%s)>" % (
         self.id,
         self.username,
         self.password,
         self.creatime
      )

if __name__ == '__main__':
   Base.metadata.create_all()

终端显示

[<User(id=1,username=wu,password=qwe123,creatime=2018-08-21 18:32:09)>, <User(id=2,username=wu,password=qwe123,creatime=2018-08-21 18:42:54)>, <User(id=3,username=qq,password=qwe,creatime=2018-08-21 18:42:54)>, <User(id=4,username=lala,password=aaa,creatime=2018-08-21 18:42:54)>]

改 update

rows = session.query(User).filter(User.username=='budong').update({User.password:1})

session.commit()

session.query(Users).filter(Users.id > 2).update({"name" : "099"})

session.commit()
update  用来更改数据 注意 字典 {User.password:1}
filter  查询条件
代码
from connect import session
from user_module import User


def update_user():
   rows = session.query(User).filter(User.id==2).update({User.password:1})
   session.commit()


if __name__ == '__main__':
   update_user()

删delete

rows = session.query(User).filter(User.username=='budong')[0]
print(rows)
session.delete(rows)
session.commit()



session.query(User).filter(User.username=='budong').delete()
session.commit()
session.query(Users).filter(Users.id > 2).delete()
session.commit()
使用 delete 方法来删除数据
代码
from connect import session
from user_module import User


def deleter_user():
   rows = session.query(User).filter(User.id==2)[0]
   print(rows)
   session.delete(rows)
   session.commit()


if __name__ == '__main__':
   deleter_user()

mysql

mysql -uroot -pqwe123

create database mydb;

flush privileges;    #刷新授权；

grant all on *.* to 'admin'@'%'; #给admin所有权限

flush privileges;

是root用户创建的数据库mydb

需要把操作mydb的权限赋给admin用户

代码

connect.py

# -*- coding:utf-8 -*-

from sqlalchemy import create_engine

HOSTNAME = '127.0.0.1'  # 在本机上运行
PORT = '3306'  # 端口
DATABASE = 'mydb'  # 数据库
USERNAME = 'admin'  # 用户名
PASSWORD = 'Root110qwe'  # 密码

# 连接数据库的路径
# “mysql+pymysql”指定了使用 pymysql 来连接
db_url = 'mysql+pymysql://{}:{}@{}:{}/{}?charset=utf8'.format(
    USERNAME,
    PASSWORD,
    HOSTNAME,
    PORT,
    DATABASE
)

# 连接数据库
# create_engine() 会返回一个数据库引擎
engine = create_engine(db_url)

from sqlalchemy.ext.declarative import declarative_base

# declarative_base() 创建了一个 BaseModel 类，
# 这个类的子类可以自动与一个表关联。
# 创建对象的基类
Base = declarative_base((engine))

from sqlalchemy.orm import sessionmaker

# sessionmaker() 会生成一个数据库会话类
Session = sessionmaker(engine)
# 创建session对象:
session = Session()

if __name__ == '__main__':
    connection = engine.connect()
    result = connection.execute('select 1')
    print(result.fetchone())

user_module.py

from datetime import datetime
from sqlalchemy import Column, Integer, String, DateTime
from connect import Base


# 实体类User，对应数据库中的user表
class User(Base):
    # 表的名字:
    __tablename__ = 'user'
    # 表的结构:
    id = Column(Integer, primary_key=True, autoincrement=True)  # 主键  自增
    username = Column(String(20), nullable=False)  # 不为空
    password = Column(String(50))
    creatime = Column(DateTime, default=datetime.now)

    def __repr__(self):
        return "<User(id=%s,username=%s,password=%s,creatime=%s)>" % (
            self.id,
            self.username,
            self.password,
            self.creatime
        )


if __name__ == '__main__':
    # 找到BaseModel的所有子类，并在数据库中建立这些表
    Base.metadata.create_all()

test_module.py

from connect import session
from user_module import User


def add_user():
    # 创建新User对象:
    person = User(username='1wua', password='qwe123')
    # 添加到session:
    session.add(person)

    session.add_all(
        [
            User(username='1qqa', password='qwe'),
            User(username='1lalaa', password='aaa')
        ]
    )
    # 提交即保存到数据库:
    session.commit()


def search_user():
    rows = session.query(User).all()
    print(rows)


def update_user():
    rows = session.query(User).filter(User.id == 5).update({User.password: 1})
    session.commit()


def deleter_user():
    # rows = session.query(User).filter(User.id > 4)[0]
    # print(rows)
    # session.delete(rows)
    session.query(User).filter(User.id > 5).delete()
    session.commit()


if __name__ == '__main__':
    # add_user()
    # search_user()
    # update_user()
    deleter_user()

没注释的代码

connect0.py

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

HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'mydb'
USERNAME = 'admin'
PASSWORD = 'Root110qwe'

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

# 连接数据库
engine = create_engine(db_url)

# 创建基类
Base = declarative_base((engine))

# 创建会话
Session = sessionmaker(engine)
session = Session()

if __name__ == '__main__':
   connection = engine.connect()
   result = connection.execute('select 1')
   print(result.fetchone())

user_module0.py

from datetime import datetime
from sqlalchemy import Integer, String, Column, DateTime
from connect0 import Base


class Users(Base):
   __tablename__ = 'users'
   id = Column(Integer, primary_key=True, autoincrement=True)
   username = Column(String(20), nullable=False)
   password = Column(String(50))
   creatime = Column(DateTime, default=datetime.now())

   def __repr__(self):
      return "<User(id=%s,username=%s,password=%s,creatime=%s)" % (
         self.id,
         self.username,
         self.password,
         self.creatime
      )


if __name__ == '__main__':
   Base.metadata.create_all()

test_module.py

from connect0 import session
from user_module0 import Users


def add_user():
   person = Users(username='p', password='123')
   session.add(person)

   session.add_all(
      [
         Users(username='k', password='123'),
         Users(username='l', password='123')
      ]
   )
   session.commit()


def search_user():
   rows = session.query(Users).all()
   print(rows)


def update_user():
   rows = session.query(Users).filter(Users.id == 1).update({Users.password: 3})
   session.commit()


def del_user():
   session.query(Users).filter(Users.id == 3).delete()
   session.commit()

   # rows = session.query(Users).filter(Users.id == 3)
   # print(rows)
   # session.delete(rows)
   # session.commit()


if __name__ == '__main__':
    add_user()
   # search_user()
   # update_user()
   # del_user()

廖大神

https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/0014320114981139589ac5f02944601ae22834e9c521415000

数据库表是一个二维表，包含多行多列。把一个表的内容用Python的数据结构表示出来的话，可以用一个list表示多行，list的每一个元素是tuple，表示一行记录，比如，包含id和name的user表：

[
    ('1', 'Michael'),
    ('2', 'Bob'),
    ('3', 'Adam')
]

Python的DB-API返回的数据结构就是像上面这样表示的。

但是用tuple表示一行很难看出表的结构。如果把一个tuple用class实例来表示，就可以更容易地看出表的结构来：

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

[
    User('1', 'Michael'),
    User('2', 'Bob'),
    User('3', 'Adam')
]

这就是传说中的ORM技术：Object-Relational Mapping，把关系数据库的表结构映射到对象上。是不是很简单？

但是由谁来做这个转换呢？所以ORM框架应运而生。

在Python中，最有名的ORM框架是SQLAlchemy。我们来看看SQLAlchemy的用法。

首先通过pip安装SQLAlchemy：

$ pip install sqlalchemy

然后，利用上次我们在MySQL的test数据库中创建的user表，用SQLAlchemy来试试：

第一步，导入SQLAlchemy，并初始化DBSession：

# 导入:
from sqlalchemy import Column, String, create_engine
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base

# 创建对象的基类:
Base = declarative_base()

# 定义User对象:
class User(Base):
    # 表的名字:
    __tablename__ = 'user'

    # 表的结构:
    id = Column(String(20), primary_key=True)
    name = Column(String(20))

# 初始化数据库连接:
engine = create_engine('mysql+mysqlconnector://root:password@localhost:3306/test')
# 创建DBSession类型:
DBSession = sessionmaker(bind=engine)

以上代码完成SQLAlchemy的初始化和具体每个表的class定义。如果有多个表，就继续定义其他class，例如School：

class School(Base):
    __tablename__ = 'school'
    id = ...
    name = ...

create_engine()用来初始化数据库连接。SQLAlchemy用一个字符串表示连接信息：

'数据库类型+数据库驱动名称://用户名:口令@机器地址:端口号/数据库名'

你只需要根据需要替换掉用户名、口令等信息即可。

下面，我们看看如何向数据库表中添加一行记录。

由于有了ORM，我们向数据库表中添加一行记录，可以视为添加一个User对象：

# 创建session对象:
session = DBSession()
# 创建新User对象:
new_user = User(id='5', name='Bob')
# 添加到session:
session.add(new_user)
# 提交即保存到数据库:
session.commit()
# 关闭session:
session.close()

可见，关键是获取session，然后把对象添加到session，最后提交并关闭。DBSession对象可视为当前数据库连接。

如何从数据库表中查询数据呢？有了ORM，查询出来的可以不再是tuple，而是User对象。SQLAlchemy提供的查询接口如下：

# 创建Session:
session = DBSession()
# 创建Query查询，filter是where条件，最后调用one()返回唯一行，如果调用all()则返回所有行:
user = session.query(User).filter(User.id=='5').one()
# 打印类型和对象的name属性:
print('type:', type(user))
print('name:', user.name)
# 关闭Session:
session.close()

运行结果如下：

type: <class '__main__.User'>
name: Bob

可见，ORM就是把数据库表的行与相应的对象建立关联，互相转换。

由于关系数据库的多个表还可以用外键实现一对多、多对多等关联，相应地，ORM框架也可以提供两个对象之间的一对多、多对多等功能。

例如，如果一个User拥有多个Book，就可以定义一对多关系如下：

class User(Base):
    __tablename__ = 'user'

    id = Column(String(20), primary_key=True)
    name = Column(String(20))
    # 一对多:
    books = relationship('Book')

class Book(Base):
    __tablename__ = 'book'

    id = Column(String(20), primary_key=True)
    name = Column(String(20))
    # “多”的一方的book表是通过外键关联到user表的:
    user_id = Column(String(20), ForeignKey('user.id'))

当我们查询一个User对象时，该对象的books属性将返回一个包含若干个Book对象的list。

小结

ORM框架的作用就是把数据库表的一行记录与一个对象互相做自动转换。

正确使用ORM的前提是了解关系数据库的原理。

533_
关注
专栏目录
sqlalchemy高级用法
下雨天__的专栏
07-10 1911
sqlalchemy高级用法 本文将介绍sqlalchemy的高级用法。 外键以及relationship 首先创建数据库，在这里一个user对应多个address，因此需要在address上增加user_id这个外键（一对多）。 #!/usr/bin/env python # encoding: utf-8 from sqlalchemy import creat
sqlalchemy与mysql区别_你真的了解SQLAlchemy吗
weixin_32060735的博客
02-22 627
SQLAlchemy作为一款强大而又实用的ORM框架，越来越频繁的出现在各类Python项目中。如果你是一名Python开发工程师，肯定可以熟练的写出SQLAlchemy的查询语句来满足自己的业务需求。然而，SQLAlchemy背后的知识你又了解多少呢？它是什么时候与数据库建立连接的呢？又是怎样的连接方式呢？SQLAlchemy中的Session与数据库的Transaction是一回事吗？如何优雅...
SQLAlchemy
go|Python的个人博客
02-26 993
SQLAlchemy是一个基于Python实现的ORM框架。该框架建立在 DB API之上，使用关系对象映射进行数据库操作，简言之便是：将类和对象转换成SQL，然后使用数据API执行SQL并获取执行结果。Engine，框架的引擎Connection Pooling ，数据库连接池Dialect，选择连接数据库的DB API种类Schema / Types，架构和类型SQL Exprression Language，SQL表达式语言。
【SQLAlchemy】第四篇——事务
芳樽里的歌的博客
06-01 2724
SQLAlchemy中提供了许多方法来利用事务
SQLAlchemy的简单使用
ieeso的博客
09-12 757
简介 SQLAlchemy是一个Python的数据库操作库，可以操作PostgreSQL, MySQL, 和SQLite 数据库。 安装 pip install SQLAlchemy 1 执行SQL语句 from sqlalchemy import create_engine eng = create_engine("sqlite:///test.db") #创建数据库引擎 #cr...
FastApi SQLAlchemy SQLite
weixin_46016309的博客
10-14 775
本文介绍了FastAPI的入门知识，并结合SQLAlchemy和SQLite来构建一个简单的Web应用。首先，阐述了FastAPI的基本概念及其安装方法，强调了其高性能和易用性。接着，介绍了如何使用SQLAlchemy作为ORM工具，与SQLite数据库进行交互。 文章详细描述了创建数据库模型、设置数据库连接以及实现基本的CRUD（创建、读取、更新和删除）操作的步骤。同时，通过示例代码展示了如何在FastAPI中集成这些功能，使用户能够方便地添加和查询数据。
SQLAlchemy使用
JReno的博客
07-11 310
SQLAlchemy概述 安装 SQLAlchemy由官方收录,可以直接安装 [root@localhost packages]# pip3 install sqlalchemy 简介 SQLAlchemy是Python编程语下的一款开源软件。提供 SQL 具包及对象关系映 射(ORM) 工具,使用MIT许可证发 SQLAlchemy“采用简单的Python语言,为高效和高性能的数据库访问...
flask-sqlalchemy快速上手
狡猾的皮球的博客
12-30 439
一、前言 本篇依然是面向有一定经验的开发者。本篇不会讲原理，一切以实用为主。 本篇主要讲述以下内容： flask-sqlalchemy的搭建 简单查询 查询指定字段 排序 分页 聚合函数 连表查询 修改 删除 二、flask-sqlalchemy练习环境准备 1.准备好我们要用的数据，这里我使用的是mysql --建表 --学生表 CREATE TABLE `Student`( `s_id` VARCHAR(20), `s_name` VARCHAR(20) NOT NUL.
SQLAlchemy使用教程
山间明月江上清风的专栏
05-06 820
SQLAlchemy是python的ORM框架，把表映射成对象，类似于java的hibernate，mybatis。 而且支持的数据库非常多： Firebird Microsoft SQL Server MySQL Oracle PostgreSQL SQLite Sybase 还支持其他数据库扩展。 下面来正式使用，首先基于之前文章在intellij idea+python plu...
python数据库操作mysql：pymysql、sqlalchemy常见用法详解
01-20
本文实例讲述了python数据库操作mysql：pymysql、sqlalchemy常见用法。分享给大家供大家参考，具体如下： 相关内容： 使用pymysql直接操作mysql 创建表 查看表 修改表 删除表 插入数据 查看数据 修改数据 ...
SQLAlchemy(2.0)完全入门
Cycloctane的博客
10-12 5572
如果我们需要的数据库表在原数据库中不存在，而我们需要新建一个，则可以选择通过继承Table类作为表。表中的列通过在Table中传入Column实例即可定义。同时也要注意表对象是需要基于Metadata的，因此我们也需要一个metadata实例并将这个表对象注册到其中，随后这个表就可以由metadata实例借助engine在原数据库中新建了。metadata,Column("id", Integer, primary_key=True), # 使用Integer类构建int数据类型。
python：sqlalchemy-快速开始
一名小测试
05-01 2715
# 一、声明模型 首先我们定义了模块级结构，这些结构将形成我们将从数据库中查询的结构。这种结构称为声明性映射，讲白了其实就是SQL表中存在的元数据。 fromsqlalchemyimportColumn fromsqlalchemyimportForeignKey fromsqlalchemyimportInteger fromsqlalchemyimportString fromsqlalchemy.ormimportdeclarative_base fromsq...
python sqlalchemy 连接池_深入研究sqlalchemy连接池
weixin_39669147的博客
12-22 1659
简介：相对于最新的MySQL5.6，MariaDB在性能、功能、管理、NoSQL扩展方面包含了更丰富的特性。比如微秒的支持、线程池、子查询优化、组提交、进度报告等。本文就主要探索MariaDB当中连接池的一些特性，配置。来配合我们的sqlalchemy。一：起因本来是不会写这个东西的，但是，写好了python--flask程序，使用sqlalchemy+mariadb，部署以后总是出问题，500错...
智慧建造总体策划方案（76页）.pptx
11-02
智慧建造总体策划方案（76页）
基于 Python2.7 和 PyQT4 开发的 modbus 通信采集软件
11-02
基于 Python2.7 和 PyQT4 开发的 modbus 通信采集软件，已在 windows、deepin linux 和树莓派上测试！
LLC simulink仿真《slx模型文件》
11-02
LLC simulink仿真《slx模型文件》 LLC谐振转换器是一种高效的直流-直流(DC-DC)电源转换器，因其独特的谐振特性而得名。在电力电子领域，LLC仿真对于理解和优化这种转换器的性能至关重要。Simulink是MATLAB环境下的一个强大工具，用于建立和仿真复杂系统，包括电力电子系统。 标题“LLC simulink仿真”指的是使用Simulink进行LLC谐振转换器的建模和仿真。通过Simulink，工程师可以模拟LLC转换器在不同工作条件下的行为，如负载变化、输入电压变动以及控制策略的影响。 **LLC电路的基本原理：** LLC谐振转换器结合了升压（Boost）、降压（Buck）和串联谐振（Series Resonant）三种拓扑结构的特点。它由主开关、副开关、电感、电容和二极管组成。谐振电容和电感形成谐振回路，使得开关器件能在零电压或零电流条件下切换，从而降低开关损耗并提高效率。 **仿真过程：** 在Simulink中，首先需要建立LLC转换器的模型，包括各个元件的参数设定。这包括主开关和副开关的开关频率、谐振电容和电感的值、二极管的反向恢复特性等。然后，设
krb5-devel-1.15.1-55.el7_9.i686.rpm
11-02
Centos7 el7.x86_64 官方离线安装包，安装指令为 sudo rpm -ivh krb5-devel-1.15.1-55.el7_9.i686.rpm
基于Matlab实现Stanley算法项目源码（下载即用）高分项目
11-02
基于Matlab实现Stanley算法项目源码（下载即用）高分项目，本资源中的源码都是经过本地编译过可运行的，评审分达到98分，资源项目的难度比较适中，内容都是经过助教老师审定过的能够满足学习、毕业设计、期末大作业和课程设计使用需求，如果有需要的话可以放心下载使用。 基于Matlab实现Stanley算法项目源码（下载即用）高分项目基于Matlab实现Stanley算法项目源码（下载即用）高分项目基于Matlab实现Stanley算法项目源码（下载即用）高分项目基于Matlab实现Stanley算法项目源码（下载即用）高分项目基于Matlab实现Stanley算法项目源码（下载即用）高分项目基于Matlab实现Stanley算法项目源码（下载即用）高分项目基于Matlab实现Stanley算法项目源码（下载即用）高分项目基于Matlab实现Stanley算法项目源码（下载即用）高分项目基于Matlab实现Stanley算法项目源码（下载即用）高分项目基于Matlab实现Stanley算法项目源码（下载即用）高分项目基于Matlab实现Stanley算法项目源码（下载即用）高分项目基
ruby-2.0.0.648-39.el7_9.x86_64.rpm
最新发布
11-02
Centos7 el7.x86_64 官方离线安装包，安装指令为 sudo rpm -ivh ruby-2.0.0.648-39.el7_9.x86_64.rpm
SQLAlchemy基础教程
"essential_sqlalchemy" 《Essential SQLAlchemy》是一本由Rick Copeland编著的关于SQLAlchemy的书籍，主要探讨了Python编程语言中的SQLAlchemy库的使用和实践。SQLAlchemy是Python中最流行的ORM（对象关系映射）...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值