ORM基本操作回顾 | 易学教程

连接数据库

默认是MySQLdb
指定引擎
dialect[+driver]: //user:password@host/dbname[?key=value..]:

from sqlalchemy import create_engine
engine = create_engine("mysql+pymysql://root:root@127.0.0.1/ormreview?charset=utf8",
                       encoding='utf8')

# 判断是否连接成功
with engine.connect() as f:
    result = f.execute("select 1")
    print(result.fetchone())
    print(type(result))
>>>
# (1,)
#<class 'sqlalchemy.engine.result.ResultProxy'>

ORM模型创建

必须继承自sqlalchemy提供的基类

from sqlalchemy.ext.declarative import declarative_base
from datetime import datetime

engine = create_engine("mysql+pymysql://root:root@127.0.0.1/ormreview?charset=utf8",
                       encoding='utf8')

Base = declarative_base(engine)

class Aticle(Base):
    __tablename__ = "article" #表名
    id = Column(Integer,primary_key=True,autoincrement=True)
    title = Column(String(100),nullable=False)
    create_time = Column(DateTime,default=datetime.now,onupdate=datetime.now)  #onupdate：更改数据，更新时间

sqlalchemy常用数据类型：

Integer：整形。
Float：浮点类型。
Boolean：传递True/False进去。
DECIMAL：定点类型。
enum：枚举类型。
Date：传递datetime.date()进去。
DateTime：传递datetime.datetime()进去。
Time：传递datetime.time()进去。
String：字符类型，使用时需要指定长度，区别于Text类型。
Text：文本类型。
LONGTEXT：长文本类型。
添加表，删除表

Column常用参数：

default：默认值。
nullable：是否可空。
primary_key：是否为主键。
unique：是否唯一。
autoincrement：是否自动增长。
onupdate：更新的时候执行的函数。
name：该属性在数据库中的字段映射。

Base.metadata.create_all()
Base.metadata.drop_all()

使用session 进行ORM操作

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

engine = create_engine("mysql+pymysql://root:root@127.0.0.1/ormreview?charset=utf8",
                       encoding='utf8')
                       
session = sessionmaker(engine)()

# session: <class 'sqlalchemy.orm.session.Session'>

#调用sessionmaker的  __call__ 方法 ， 返回使用元类创建的Session类
# type(class_.__name__, (class_,), {})

添加数据

#添加一条记录
    article = Aticle(title = '鲁班来了')  
    session.add(article)  #添加到事务中
    session.commit()
    
#添加多条记录
    article1 = Aticle(title='鲁班来了1')
    article2 = Aticle(title='鲁班来了2')
    session.add_all([article1,article2])
    session.commit()

查找

    session.query(Aticle).all()
    session.query(Aticle.title).filter(Aticle.title=="鲁班来了").first()
    session.query(Aticle).filter_by(title="鲁班来了1").first()
......

删除

    session.query(Aticle).first()

修改

    article =session.query(Aticle).first()
    article.title = "大学英语"
    session.commit()

字段类型：

    #DECIMAL 定点类型
    #小数点前6位，4为小数点位数
    max_price = Column(DECIMAL(10,4))
    
    #Boolean类型
    is_delete = Column(Boolean)
    
    #String类型
    title = Column(String(100),nullable=False)
    
    #DateTime类型
    create_time = Column(DateTime,default=datetime.now,onupdate=datetime.now)
    
    #Text类型
    content = Column(Text)
    
    #Enum类型
    tag = Column(Enum('美食','美女','美景'),default='美食')
    
    #Date类型
    join_time = Column(DATE)
    Aticle(title = '呐喊',update_time = date(2019,4,2))
    
    #Time类型
    join_time = Column(TIME)
    Aticle(title = '呐喊',join_time = time(hour=21,minute=57,second=30))

    #Longtext类型,只在Mysql中存在
    from sqlalchemy.dialects.mysql import LONGTEXT
    ......

Query 可用参数。

模型对象
模型中的属性
聚合函数 (sum , avg ,min ,max , count......)

      #统计行数量
        count = self.session.query(func.count(table.id)).all()
        
        #avg
        avg = self.session.query(func.count(table.price)).all()


        #sum
        sum = self.session.query(func.sum(table.price)).all()


        #max
        max = self.session.query(func.max(table.price)).all()

        # 调用__getattr__魔术方法，返回本身对象_FunctionGenerator
        # 调用__call__方法

过滤条件：
过滤是数据提取的一个很重要的功能，以下对一些常用的过滤条件进行解释，并且这些过滤条件都是只能通过filter方法实现的：

#equals：

query.filter(User.name == '鲁班七号')

#not equals:

query.filter(User.name != '鲁班七号')

#like：
#ilike不区分大小写

query.filter(User.name.like('%射手%'))

#in：

query.filter(User.name.in_(['ed','wendy','jack']))

# 同时，in也可以作用于一个Query
query.filter(User.name.in_(session.query(User.name).filter(User.name.like('%ed%'))))

#not in：

query.filter(~User.name.in_(['ed','wendy','jack']))

#is null：

query.filter(User.name==None)

# 或者是
query.filter(User.name.is_(None))

#is not null:

query.filter(User.name != None)
# 或者是
query.filter(User.name.isnot(None))

#and：
from sqlalchemy import and_
query.filter(and_(User.name=='ed',User.fullname=='Ed Jones'))
# 或者是传递多个参数
query.filter(User.name=='ed',User.fullname=='Ed Jones')
# 或者是通过多次filter操作
query.filter(User.name=='ed').filter(User.fullname=='Ed Jones')

or：

from sqlalchemy import or_  
query.filter(or_(User.name=='ed',User.name=='wendy'))

查找方法：

#all(): 返回全部记录的一个列表
session.query(Article).all()
# first()：返回Query中的第一个值
session.query(Article).first()
#one()：查找所有行作为一个结果集，如果结果集中只有一条数据，则会把这条数据提取出来，如果这个结果集少于或者多于一条数据，则会抛出异常。总结一句话：有且只有一条数据的时候才会正常的返回，否则抛出异常：
session.query(table).filter(Aticle.title=="呐喊").one()
# one_or_none()：跟one()方法类似，但是在结果集中没有数据的时候也不会抛出异常。

#scalar()：底层调用one()方法，并且如果one()方法没有抛出异常，会返回查询到的第一列的数据

#SQLAlchemy还提供了使用文本SQL的方式来进行查询，这种方式更加的灵活。而文本SQL要装在一个text()方法中，看以下例子：

from sqlalchemy import text
for user in session.query(User).filter(text("id<244")).order_by(text("id")).all():
    print user.name

#如果过滤条件比如上例中的244存储在变量中，这时候就可以通过传递参数的形式进行构造：

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

#在文本SQL中的变量前面使用了:来区分，然后使用params方法，指定需要传入进去的参数。另外，使用from_statement方法可以把过滤的函数和条件函数都给去掉，使用纯文本的SQL:

sesseion.query(User).from_statement(text("select * from users where name=:name")).params(name='ed').all()

#使用from_statement方法一定要注意，from_statement返回的是一个text里面的查询语句，一定要记得调用all()方法来获取所有的值。
            
#values 返回generator
session.query(table).values(table.title,table.id)

#value 返回一个字段
session.query(table).value(table.title)

#如果想实现select count(*) from users，可以通过以下方式来实现：

session.query(func.count(*)).select_from(User).scalar()

#当然，如果指定了要查找的表的字段，可以省略select_from()方法：

session.query(func.count(User.id)).scalar()

来源：https://www.cnblogs.com/donghaoblogs/p/10647531.html

标签

session

orm

sqlalchemy