目录

一、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. node.js学习之post文件上传 （multer中间件）

    express为了性能考虑,采用按需加载的方式,引入各种中间件来完成需求, 平时解析post上传的数据时,是用body-parser. 但这个中间件有缺点,只能解析post的文本内容,(applica ...

  2. 联想ERP项目实施案例分析（10）：回到最初再反思IT价值

    联想ERP项目实施案例分析(10):回到最初再反思IT价值 投入上千万(未来每年的维护费也非常高),投入一年实施时间,高级副总裁亲自挂帅,各级业务部门管理者亲自负责.骨干业务人员充当区域IT实施者/推 ...

  3. Apache Shiro(一)-登录认证和权限管理初识

    What is Apache Shiro? Apache Shiro是一个功能强大.灵活的,开源的安全框架.它可以干净利落地处理身份验证.授权.企业会话管理和加密. Apache Shiro的首要目标 ...

  4. OpenGL 混合功能

    一.概念:简言之,即在颜色缓存区和深度缓存区中,新旧颜色的覆盖和替换问题:已经存在于缓存区的为目标颜色,即将进入缓存区的为源颜色: 二.应用场景:在不透明的图形前绘制一个透明的图形: 三.主要代码实现 ...

  5. 如何保障Go语言基础代码质量？

    为什么要谈这个topic? 实践中,质量保障体系的建设,主要针对两个目标: 一是不断提高目标业务测试覆盖率,保障面向客户的产品质量:二就是尽可能的提高人效,增强迭代效率.而构建全链路质量卡点就是整个体 ...

  6. HDU3045 Picnic Cows

    题面 HDU vjudge 题解 将权值排序,则分组一定是连续的 设$f[i]$表示前$i$头牛的最小代价,则($a[i]$为$i$的权值): $$ f[i] = f[j - 1] + sum[i] ...

  7. CF 1110 D. Jongmah

    D. Jongmah 链接 题意: 一些数字,有两种方式组成一个三元组,[x,x,x],[x,x+1,x+2],每个数字只能用一次,求最多组成多少三元组. 分析: 因为每三个[x,x+1,x+2]是可 ...

  8. Asp.net中使用缓存(cache)

    做了一个时间优化的项目,目的就是缩短程序过程中的时间花费,最后发现了asp.net和asp.net core 中都有缓存工具来进行缓存,以加快访问速度. 找了官方demo来进行分析: ObjectCa ...

  9. P3674 小清新人渣的本愿

    P3674 小清新人渣的本愿 一道妙不可言的题啊,,, 一看就知道是个莫队 考虑求答案 1号操作就是个大bitset,动态维护当前的bitset \(S\),把能取哪些值都搞出来,只要\(S\ and ...

  10. P4151 [WC2011]最大XOR和路径

    P4151 [WC2011]最大XOR和路径 一道妙极了的题. 首先直接从1走到n 然后现在图上有很多环 所以可以在走到n之后走到环上一个点,再走一遍环,再原路返回.这样就会xor上环的权值. 然后只 ...