SQLAlchemy:
It is an ORM framework implemented based on Python, built on the DB API, and uses relational object mapping for database operations
component:
.Engine frame engine
.Connection Pooling database connection pool
.Dialect selects the DB API type of the linked database
.Schema/Type schema and type
.SQL Expression Language SQL Expression Language
1. Execute native SQL
import time
import threading
import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.engine.base import Engine
engine = create_engine(
"mysql+pymysql://root:[email protected]:3306/t1?charset=utf8",
max_overflow=0, # The maximum number of connections created outside the connection pool size
pool_size=5, # connection pool size
pool_timeout=30, # The maximum waiting time for no threads in the pool, otherwise an error will be reported
pool_recycle=-1 # How long to recycle (reset) the connection for the threads in the thread pool
)
def task(arg):
conn = engine.raw_connection()
cursor = conn.cursor()
cursor.execute(
"select * from t1"
)
result = cursor.fetchall()
cursor.close()
conn.close()
for i in range(20):
t = threading.Thread(target=task, args=(i,))
t.start()
SNAKE:
Single table:
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'),
)
One-to-many:
class Hobby(Base):
__tablename__ = 'hobby'
id = Column(Integer, primary_key=True)
caption = Column(String(50), default='篮球')
class Person(Base):
__tablename__ = 'person'
nid = Column(Integer, primary_key=True)
name = Column(String(32), index=True, nullable=True)
hobby_id = Column(Integer, ForeignKey("hobby.id"))
# has nothing to do with the structure of the generated table, it is only used for query convenience
hobby = relationship("Hobby", backref='pers')
Many-to-many:
class Server2Group(Base):
__tablename__ = 'server2group'
id = Column(Integer, primary_key=True, autoincrement=True)
server_id = Column(Integer, ForeignKey('server.id'))
group_id = Column(Integer, ForeignKey('group.id'))
class Group(Base):
__tablename__ = 'group'
id = Column(Integer, primary_key=True)
name = Column(String(64), unique=True, nullable=False)
# has nothing to do with the structure of the generated table, it is only used for query convenience
servers = relationship('Server', secondary='server2group', backref='groups')
class Server(Base):
__tablename__ = 'server'
id = Column(Integer, primary_key=True, autoincrement=True)
hostname = Column(String(64), unique=True, nullable=False)
def init_db():
"""
Create database table from class
:return:
"""
engine = create_engine(
"mysql+pymysql://root:[email protected]:3306/s6?charset=utf8",
max_overflow=0, # The maximum number of connections created outside the connection pool size
pool_size=5, # connection pool size
pool_timeout=30, # The maximum waiting time for no threads in the pool, otherwise an error will be reported
pool_recycle=-1 # How long to recycle (reset) the connection for the threads in the thread pool
)
Base.metadata.create_all(engine)
def drop_db():
"""
Drop database table based on class
:return:
"""
engine = create_engine(
"mysql+pymysql://root:[email protected]:3306/s6?charset=utf8",
max_overflow=0, # The maximum number of connections created outside the connection pool size
pool_size=5, # connection pool size
pool_timeout=30, # The maximum waiting time for no threads in the pool, otherwise an error will be reported
pool_recycle=-1 # How long to recycle (reset) the connection for the threads in the thread pool
)
Base.metadata.drop_all(engine)
if __name__ == '__main__':
drop_db()
init_db()
Basic operation:
import time
import threading
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
from sqlalchemy.sql import text
from db import Users, Hosts
engine = create_engine("mysql+pymysql://root:[email protected]:3306/s6", max_overflow=0, pool_size=5)
Session = sessionmaker(bind=engine)
session = Session()
# ################ Add to################
"""
obj1 = Users(name="wupeiqi")
session.add(obj1)
session.add_all([
Users(name="wupeiqi"),
Users(name="alex"),
Hosts(name="c1.com"),
])
session.commit()
"""
# ################ delete################
"""
session.query(Users).filter(Users.id > 2).delete()
session.commit()
"""
# ################ Revise################
"""
session.query(Users).filter(Users.id > 0).update({"name" : "099"})
session.query(Users).filter(Users.id > 0).update({Users.name: Users.name + "099"}, synchronize_session=False)
session.query(Users).filter(Users.id > 0).update({"age": Users.age + 1}, synchronize_session="evaluate")
session.commit()
"""
# ################ Inquire################
"""
r1 = session.query(Users).all()
r2 = session.query(Users.name.label('xx'), Users.age).all()
r3 = session.query(Users).filter(Users.name == "alex").all()
r4 = session.query(Users).filter_by(name='alex').all()
r5 = session.query(Users).filter_by(name='alex').first()
r6 = session.query(Users).filter(text("id<:value and name=:name")).params(value=224, name='fred').order_by(Users.id).all()
r7 = session.query(Users).from_statement(text("SELECT * FROM users where name=:name")).params(name='ed').all()
"""
session.close()
# condition
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()
# wildcard
ret = session.query(Users).filter(Users.name.like('e%')).all()
ret = session.query(Users).filter(~Users.name.like('e%')).all()
# limit
ret = session.query(Users)[1:2]
# sort
ret = session.query(Users).order_by(Users.name.desc()).all()
ret = session.query(Users).order_by(Users.name.desc(), Users.id.asc()).all()
# grouping
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()
# concatenated table
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()
# Combination
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()
Query by relation:
engine = create_engine("mysql+pymysql://root:[email protected]:3306/s6?charset=utf8", max_overflow=0, pool_size=5)
Session = sessionmaker(bind=engine)
session = Session()
# Add to
"""
session.add_all([
Hobby(caption='table tennis'),
Hobby(caption='Badminton'),
Person(name='Zhang San', hobby_id=3),
Person(name='Li Si', hobby_id=4),
])+
person = Person(name='Zhang Jiu', hobby=Hobby(caption='Girl'))
session.add(person)
hb = Hobby(caption='shemale')
hb.pers = [Person(name='Wenfei'), Person(name='Boya')]
session.add(hb)
session.commit()
"""
# Use relationship forward query
"""
v = session.query(Person).first()
print(v.name)
print(v.hobby.caption)
"""
# Use relationship reverse query
"""
v = session.query(Hobby).first()
print(v.caption)
print(v.pers)
"""
session.close()