目录

一、pymysql

二、SQLAchemy

　　2、操作使用

　　　　（1）连接数据库

　　　　（2）执行原生SQL语句

　　　　（3）ORM操作-数据表操作

　　　　（4）ORM操作-数据行操作

　　　　（5）更多例子

一、pymysql

1、使用

pip install pymysql

import pymysql

2、操作使用

（1）执行SQL

#!/usr/bin/env python

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

import pymysql

# 创建连接

conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='', db='t1')

# 创建游标

cursor = conn.cursor()

# 执行SQL，并返回收影响行数

effect_row = cursor.execute("update hosts set host = '1.1.1.2'")

# 执行SQL，并返回受影响行数

#effect_row = cursor.execute("update hosts set host = '1.1.1.2' where nid > %s", (1,))

# 执行SQL，并返回受影响行数

#effect_row = cursor.executemany("insert into hosts(host,color_id)values(%s,%s)", [("1.1.1.11",1),("1.1.1.11",2)])

# 提交，不然无法保存新建或者修改的数据

conn.commit()

# 关闭游标

cursor.close()

# 关闭连接

conn.close()

执行SQL

（2）获取新创建数据自增ID

#!/usr/bin/env python

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

import pymysql

conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='', db='t1')

cursor = conn.cursor()

cursor.executemany("insert into hosts(host,color_id)values(%s,%s)", [("1.1.1.11",1),("1.1.1.11",2)])

conn.commit()

cursor.close()

conn.close()

# 获取最新自增ID

new_id = cursor.lastrowid

获取新创建数据自增ID

（3）获取查询数据

#!/usr/bin/env python

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

import pymysql

conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='', db='t1')

cursor = conn.cursor()

cursor.execute("select * from hosts")

# 获取第一行数据

row_1 = cursor.fetchone()

# 获取前n行数据

# row_2 = cursor.fetchmany(3)

# 获取所有数据

# row_3 = cursor.fetchall()

conn.commit()

cursor.close()

conn.close()

获取查询数据

　　注：在fetch数据时按照顺序进行，可以使用cursor.scroll(num,mode)来移动游标位置，如：

　　　　cursor.scroll(1,mode='relative')  # 相对当前位置移动

　　　　cursor.scroll(2,mode='absolute') # 相对绝对位置移动

（4）fetch数据类型

关于默认获取的数据是元祖类型，如果想要或者字典类型的数据，即：

#!/usr/bin/env python

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

import pymysql

conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='', db='t1')

# 游标设置为字典类型

cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)

r = cursor.execute("call p1()")

result = cursor.fetchone()

conn.commit()

cursor.close()

conn.close()

fetch数据类型

二、SQLAchemy

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

1、使用

pip install SQLAlchemy

import SQLAlchemy

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

2、操作使用

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

（0）常用类型

常用的SQLAlchemy字段类型

类型名

python中类型

说明

Integer

int

普通整数，一般是32位

SmallInteger

int

取值范围小的整数，一般是16位

BigInteger

int或long

不限制精度的整数

Float

float

浮点数

Numeric

decimal.Decimal

普通整数，一般是32位

String

str

变长字符串

Text

str

变长字符串，对较长或不限长度的字符串做了优化

Unicode

unicode

变长Unicode字符串

UnicodeText

unicode

变长Unicode字符串，对较长或不限长度的字符串做了优化

Boolean

bool

布尔值

Date

datetime.date

时间

Time

datetime.datetime

日期和时间

LargeBinary

str

二进制文件

常用的SQLAlchemy列选项

选项名

说明

primary_key

如果为True，代表表的主键

unique

如果为True，代表这列不允许出现重复的值

index

如果为True，为这列创建索引，提高查询效率

nullable

如果为True，允许有空值，如果为False，不允许有空值

default

为这列定义默认值

常用的SQLAlchemy关系选项

选项名

说明

backref

在关系的另一模型中添加反向引用

primaryjoin

明确指定两个模型之间使用的联结条件

uselist

如果为False，不使用列表，而使用标量值

order_by

指定关系中记录的排序方式

secondary

指定多对多中记录的排序方式

secondaryjoin

在SQLAlchemy中无法自行决定时，指定多对多关系中的二级联结条件

（1）连接数据库

from sqlalchemy import create_engine

engine = create_engine("mysql+pymysql://user:password@127.0.0.1:3306/db_name", max_overflow=5)

（2）执行原生SQL语句

#!/usr/bin/env python

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

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，传入args，方法一

cur = engine.execute(

    "INSERT INTO hosts (host, color_id) VALUES(%s, %s)",[('1.1.1.22', 3),('1.1.1.221', 3),]

)

# 执行SQL，传入args，方法二

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()

执行原生SQL语句

（3）ORM操作-数据表操作

#!/usr/bin/env python

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

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/t1", max_overflow=5)

Base = declarative_base()

# 创建单表

class Users(Base):

    __tablename__ = 'users'

    id = Column(Integer, primary_key=True)

    name = Column(String(32))

    extra = Column(String(16))

    __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)

    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)

def drop_db():

    Base.metadata.drop_all(engine)

init_db()

新建数据表

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

（4）ORM操作-数据行操作

#!/usr/bin/env python

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

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/t1", max_overflow=5)

Base = declarative_base()

# 创建单表

class Users(Base):

    __tablename__ = 'users'

    id = Column(Integer, primary_key=True)

    name = Column(String(32))

    extra = Column(String(16))

    __table_args__ = (

    UniqueConstraint('id', 'name', name='uix_id_name'),

        Index('ix_id_name', 'name', 'extra'),

    )

    def __repr__(self):

        return "%s-%s" %(self.id, self.name)

# 一对多

class Favor(Base):

    __tablename__ = 'favor'

    nid = Column(Integer, primary_key=True)

    caption = Column(String(50), default='red', unique=True)

    def __repr__(self):

        return "%s-%s" %(self.nid, self.caption)

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"))

    # 与生成表结构无关，仅用于查询方便

    favor = relationship("Favor", backref='pers')

# 多对多

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'))

    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)

def init_db():

    Base.metadata.create_all(engine)

def drop_db():

    Base.metadata.drop_all(engine)

Session = sessionmaker(bind=engine)

session = Session()

表结构 + 数据库连接

原始表

obj = Users(name="alex0", extra='sb')

session.add(obj)

session.add_all([

    Users(name="alex1", extra='sb'),

    Users(name="alex2", extra='sb'),

])

session.commit()

增

session.query(Users).filter(Users.id > 2).delete()

session.commit()

删

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

session.query(Users).filter(Users.id > 2).update({Users.name: Users.name + ""}, synchronize_session=False)

session.query(Users).filter(Users.id > 2).update({"num": Users.num + 1}, synchronize_session="evaluate")

session.commit()

改

ret = session.query(Users).all()

ret = session.query(Users.name, Users.extra).all()

ret = session.query(Users).filter_by(name='alex').all()

ret = session.query(Users).filter_by(name='alex').first()

ret = session.query(Users).filter(text("id<:value and name=:name")).params(value=224, name='fred').order_by(User.id).all()

ret = session.query(Users).from_statement(text("SELECT * FROM users where name=:name")).params(name='ed').all()

查

#　条件

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()

查、分组、连表、组合等

补充：merge

更多功能参见文档，猛击这里

验证：

增：

删：

改：

查：略

（5）更多例子

import time

import threading

import sqlalchemy

from sqlalchemy import create_engine

from sqlalchemy.engine.base import Engine

engine = create_engine(

    "mysql+pymysql://root:123@127.0.0.1:3306/t1?charset=utf8",

    max_overflow=0,  # 超过连接池大小外最多创建的连接

    pool_size=5,  # 连接池大小

    pool_timeout=30,  # 池中没有线程最多等待的时间，否则报错

    pool_recycle=-1  # 多久之后对线程池中的线程进行一次连接的回收（重置）

)

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()

执行原生SQL语句

#!/usr/bin/env python

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

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

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'),

    )

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()

ORM创建单表

#!/usr/bin/env python

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

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

from sqlalchemy.orm import relationship

Base = declarative_base()

# ##################### 单表示例 #########################

class Users(Base):

    __tablename__ = 'users'

    id = Column(Integer, primary_key=True)

    name = Column(String(32), index=True)

    age = Column(Integer, default=18)

    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', 'extra'),

    )

class Hosts(Base):

    __tablename__ = 'hosts'

    id = Column(Integer, primary_key=True)

    name = Column(String(32), index=True)

    ctime = Column(DateTime, default=datetime.datetime.now)

# ##################### 一对多示例 #########################

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"))

    # 与生成表结构无关，仅用于查询方便

    hobby = relationship("Hobby", backref='pers')

# ##################### 多对多示例 #########################

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)

    # 与生成表结构无关，仅用于查询方便

    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():

    """

    根据类创建数据库表

    :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()

创建多个表并包含Fk、M2M关系

#!/usr/bin/env python

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

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()

操作数据库表

#!/usr/bin/env python

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

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 db 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)

def task(arg):

    session = Session()

    obj1 = Users(name="alex1")

    session.add(obj1)

    session.commit()

for i in range(10):

    t = threading.Thread(target=task, args=(i,))

    t.start()

多线程执行示例

#!/usr/bin/env python

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

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:123@127.0.0.1:3306/s6", max_overflow=0, pool_size=5)

Session = sessionmaker(bind=engine)

session = Session()

# ################ 添加 ################

"""

obj1 = Users(name="wupeiqi")

session.add(obj1)

session.add_all([

    Users(name="wupeiqi"),

    Users(name="alex"),

    Hosts(name="c1.com"),

])

session.commit()

"""

# ################ 删除 ################

"""

session.query(Users).filter(Users.id > 2).delete()

session.commit()

"""

# ################ 修改 ################

"""

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()

"""

# ################ 查询 ################

"""

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()

基本增删改查示例

#　条件

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()

常用操作

#!/usr/bin/env python

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

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 sqlalchemy.engine.result import ResultProxy

from db import Users, Hosts

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()

# 查询

# cursor = session.execute('select * from users')

# result = cursor.fetchall()

# 添加

cursor = session.execute('insert into users(name) values(:value)',params={"value":'wupeiqi'})

session.commit()

print(cursor.lastrowid)

session.close()

原生SQL语句

#!/usr/bin/env python

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

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 sqlalchemy.engine.result import ResultProxy

from db import Users, Hosts, Hobby, Person

engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/s6?charset=utf8", max_overflow=0, pool_size=5)

Session = sessionmaker(bind=engine)

session = Session()

# 添加

"""

session.add_all([

    Hobby(caption='乒乓球'),

    Hobby(caption='羽毛球'),

    Person(name='张三', hobby_id=3),

    Person(name='李四', hobby_id=4),

])

person = Person(name='张九', hobby=Hobby(caption='姑娘'))

session.add(person)

hb = Hobby(caption='人妖')

hb.pers = [Person(name='文飞'), Person(name='博雅')]

session.add(hb)

session.commit()

"""

# 使用relationship正向查询

"""

v = session.query(Person).first()

print(v.name)

print(v.hobby.caption)

"""

# 使用relationship反向查询

"""

v = session.query(Hobby).first()

print(v.caption)

print(v.pers)

"""

session.close()

基于relationship操作ForeignKey

#!/usr/bin/env python

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

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 sqlalchemy.engine.result import ResultProxy

from db import Users, Hosts, Hobby, Person, Group, Server, Server2Group

engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/s6?charset=utf8", max_overflow=0, pool_size=5)

Session = sessionmaker(bind=engine)

session = Session()

# 添加

"""

session.add_all([

    Server(hostname='c1.com'),

    Server(hostname='c2.com'),

    Group(name='A组'),

    Group(name='B组'),

])

session.commit()

s2g = Server2Group(server_id=1, group_id=1)

session.add(s2g)

session.commit()

gp = Group(name='C组')

gp.servers = [Server(hostname='c3.com'),Server(hostname='c4.com')]

session.add(gp)

session.commit()

ser = Server(hostname='c6.com')

ser.groups = [Group(name='F组'),Group(name='G组')]

session.add(ser)

session.commit()

"""

# 使用relationship正向查询

"""

v = session.query(Group).first()

print(v.name)

print(v.servers)

"""

# 使用relationship反向查询

"""

v = session.query(Server).first()

print(v.hostname)

print(v.groups)

"""

session.close()

基于relationship操作m2m

#!/usr/bin/env python

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

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, func

from sqlalchemy.engine.result import ResultProxy

from db import Users, Hosts, Hobby, Person, Group, Server, Server2Group

engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/s6?charset=utf8", max_overflow=0, pool_size=5)

Session = sessionmaker(bind=engine)

session = Session()

# 关联子查询

subqry = session.query(func.count(Server.id).label("sid")).filter(Server.id == Group.id).correlate(Group).as_scalar()

result = session.query(Group.name, subqry)

"""

SELECT `group`.name AS group_name, (SELECT count(server.id) AS sid

FROM server

WHERE server.id = `group`.id) AS anon_1

FROM `group`

"""

# 原生SQL

"""

# 查询

cursor = session.execute('select * from users')

result = cursor.fetchall()

# 添加

cursor = session.execute('insert into users(name) values(:value)',params={"value":'wupeiqi'})

session.commit()

print(cursor.lastrowid)

"""

session.close()

其他

#!/usr/bin/env python

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

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:123@127.0.0.1:3306/s6", max_overflow=0, pool_size=5)

Session = sessionmaker(bind=engine)

session = Session()

# ################ 添加 ################

"""

obj1 = Users(name="wupeiqi")

session.add(obj1)

#批量添加

session.add_all([

    Users(name="wupeiqi"),

    Users(name="alex"),

    Hosts(name="c1.com"),

])

session.commit()

"""

# ################ 删除 ################

"""

session.query(Users).filter(Users.id > 2).delete()

session.commit()

"""

# ################ 修改 ################

"""

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()

"""

# ################ 查询 ################

"""

r1 = session.query(Users).all()

r2 = session.query(Users.name.label('xx'), Users.age).all()   #lable #as xx

r3 = session.query(Users).filter(Users.name == "alex").all()

r4 = session.query(Users).filter_by(name='alex').all()   #如果里面写条件就用filter_by,和上面filter查询是一回事，只是一种不同的方式

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()  #查询里面如果有动态传参的时候，吧它包在text里面，:value,:name这样的语法后面用.params来进行格式化

r7 = session.query(Users).from_statement(text("SELECT * FROM users where name=:name")).params(name='ed').all()  #上面的这个方式也可以用这一种 ，直接可以进行SQL语句的查询

"""

session.close()

基本增删改查补充

有用的参考，还没添加进来，先mark：https://www.jb51.net/article/49789.htm

参考or转发

http://www.cnblogs.com/wupeiqi/articles/5713330.html

数据库之python操作mysql的更多相关文章

  1. python操作三大主流数据库(6)python操作mysql⑥新闻管理后台功能的完善(增、ajax异步删除新闻、改、查)

    python操作mysql⑥新闻管理后台功能的完善(增.删.改.查)安装表单验证D:\python\python_mysql_redis_mongodb\version02>pip instal ...

  2. python操作三大主流数据库(4)python操作mysql④python服务端flask和前端bootstrap框架结合实现新闻展示

    python操作mysql④python服务端flask和前端bootstrap框架结合实现新闻展示 参考文档http://flask.pocoo.org/docs/0.11/http://flask ...

  3. python操作三大主流数据库(3)python操作mysql③python操作mysql的orm工具sqlaichemy安装配置和使用

    python操作mysql③python操作mysql的orm工具sqlaichemy安装配置和使用 手册地址: http://docs.sqlalchemy.org/en/rel_1_1/orm/i ...

  4. python操作三大主流数据库(2)python操作mysql②python对mysql进行简单的增删改查

    python操作mysql②python对mysql进行简单的增删改查 1.设计mysql的数据库和表 id:新闻的唯一标示 title:新闻的标题 content:新闻的内容 created_at: ...

  5. python操作三大主流数据库(1)python操作mysql①windows环境中安装python操作mysql数据库的MySQLdb模块mysql-client

    windows安装python操作mysql数据库的MySQLdb模块mysql-client 正常情况下应该是cmd下直接运行 pip install mysql-client 命令即可,试了很多台 ...

  6. python操作三大主流数据库(5)python操作mysql⑤使用Jinja2模板提取优化页面展示

    python操作mysql⑤使用Jinja2模板提取优化页面展示 在templates目录下的index.html.cat.html等页面有一些共同的元素,代码比较冗余可以使用模板提取公共代码,在各网 ...

  7. python操作mysql数据库的相关操作实例

    python操作mysql数据库的相关操作实例 # -*- coding: utf-8 -*- #python operate mysql database import MySQLdb #数据库名称 ...

  8. Windows下安装MySQLdb, Python操作MySQL数据库的增删改查

    这里的前提是windows上已经安装了MySQL数据库,且配置完成,能正常建表能操作. 在此基础上仅仅需安装MySQL-python-1.2.4b4.win32-py2.7.exe就ok了.仅仅有1M ...

  9. 使用python操作mysql数据库

    这是我之前使用mysql时用到的一些库及开发的工具,这里记录下,也方便我查阅. python版本: 2.7.13 mysql版本: 5.5.36 几个python库 1.mysql-connector ...

随机推荐

  1. VC++中出现stack overflow错误时修改VC++的默认堆栈大小

    VC++中,在栈空间上申请存储的结构体或者类对象的数组空间时,如果数组长度过大,造成申请的栈空间超过或者逼近1MB时,程序可以编译通过,但是不能够执行起来.打到调试模式时会弹出如下图所示的栈空间越界错 ...

  2. 在centos环境下编译安装myrocksdb

    rocksdb(https://rocksdb.org.cn/)是脸书(facebook)公司开源的一个key-value存储引擎,基于leveldb开发.rocksdb使用的是LSM存储引擎,纯c+ ...

  3. [外观] Firemonkey Windows Hint 气球样式

    Firemonkey 在 Windows 平台下的 Hint 默认为距形,有些单调,现在只要加入一行代码,就可以有气球箭头样式的 Hint. 修改代码: 请将 FMX.Controls.Win.pas ...

  4. springboot-web进阶（四）——单元测试

    一.概述 基础知识,参考:https://www.cnblogs.com/ysw-go/p/5447056.html 二.springboot的单元测试 1.入门测试类 最重要的不要忘记类上面的依赖, ...

  5. Flex自定义组件开发 - jackyWHJ

    一般情况下需要组件重写都是由于以下2个原因: 1.在FLEX已有组件无法满足业务需求,或是需要更改其可视化外观等特性时,直接进行继承扩展. 2.为了模块化设计或进一步重用,需要对FLEX组件进行组合. ...

  6. 手把手教你开发chrome扩展

    转载:http://www.cnblogs.com/walkingp/archive/2011/04/04/2003875.html 手把手教你开发chrome扩展一:开发Chrome Extenst ...

  7. novaclient开发中遇到的问题小结

    1. 使用官网实例代码,并不能新建client; from novaclient import client nova = client.Client(VERSION, USERNAME, PASSW ...

  8. 1483: [HNOI2009]梦幻布丁

    1483: [HNOI2009]梦幻布丁 链接 分析: 启发式合并+链表. 代码: #include<cstdio> #include<algorithm> #include& ...

  9. POJ-2299 Ultra-QuickSort (树状数组)

    题目链接:Ultra-QuickSort 题意: 给出了一个序列,序列中有n个数,现在每次操作能交换相邻的两个数,要求操作几次可以将这个序列转换为一个从小到大排序的序列. 题解: 我的解法是先把所有的 ...

  10. bzoj 前100题计划

    bzoj前100题计划 xz布置的巨大的坑.. 有空填题解... 1002 轮状病毒 用python手动matrixtree打表. #include<bits/stdc++.h> #def ...