SQLAlachemy ORM 初识

SQLAlachemy

简介 : 是一个ORM的库

安装

pip install sqlalchemy

简单使用

# 导入 sqlalchemy
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)  # 字符长度20 ,主键
    name = Column(String(20))

# 初始化数据库链接

engine = create_engine('mysql+mysqlconnector://root:password@locahost:3306/test')
# '数据库类型+数据库驱动名称://用户名:口令@机器地址:端口号/数据库名'
# 解释:  'mysql+mysqlconnector://root:password@locahost:3306/test'
#  mysql -->数据库类型
# mysqlconnector --> 数据库连接驱动
# root --> 数据库用户
# password --> 数据库密码
# localhost --> ip地址
# test --> 数据名称

# 创建DBSession , 绑定引擎: -->建立数据库链接类
DBSession = sessionmaker(bind=engine,)

# 创建session 连接对象
session = DBSession() # 实例化一个链接,可以使用 单例模式,保证只有一个链接存在

# 创建user对象
new_user = User(id='5',name='Bob')

# 添加session链接中
session.add(new_user)

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

# 关闭链接
session.close()

查询数据

#### 查询数据
# 1. 建立数据库链接
session2 = DBSession()
# 2. 创建Query查询, filter是where条件, one()获取一个数据,all()获取全部数据
user = session2.query(User).filter(User.id=='5').one()
print(type(user)) # <class '__main__.User'>
print (user.name) # Bob

一对多,多对多

# 一对多 , 多对多
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))
    # '多'的一方
    user_id = Column(String(20),ForeignKey=('user.id'))
    

ORM字段

String   str   字符 

Integer  int   整型

BigInterger int 长整型

Float    float 浮点型, 当参数asdecimal=True时,强制转换成decimal.Decimal类型

Boolean  bool  布尔

Text     str   可变大小的字符串类型

Date     datetime.date  日期类型

Time     date  time.time  时间戳类型

Date Time datetime.datetime  格式化时间,年月日时分秒

Interval  datetime.timedelta 处理 datetime.timedelta对象,时间计算

LargeBinary binary 大型二进制字节数据

Numeric 默认是decimal.Decimal类型，asdecimal=False时转float 固定精度数字的类型

Pickle Type  pickle.dumpls 序列化二进制字段

Array  数组

Unicode  unicode 可变长度的Unicode字符串类型

UnicodeText  unicode  不限长度

Enum     python的任何对象 枚举类型 # 不常用
# 枚举例子:
import enum 
class MyEnum(enum.Enum):
	one = 1
	two = 2

t = Table('data',MetaDate(),Column('value',Enum(MyEnum)))
connection.execute(t.insert(),{
	'value':MyEnum.two
})
# 断言去判断值是否相等
assert connection.scalar(t.select()) is MyEnum.two

orm常用参数

primary_key  布尔类型  主键
unique       布尔类型  唯一
index        布尔类型  索引
nullable     布尔类型  允许为空
default      默认值

ORM常用关系

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

primary join  明确指定两个魔性之间使用的联结条件

uselist   如果为False , 不是用列表,使用标量值

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

secondary  指定多对多种关系表的名字

secondary join  当SQLAlchemy无法自行决定时,指定多对多关系中的二级联结条件

relationshio  一对多关系

# 示例
class Role(db.Model):
    __tablename__ = 'roles'
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(64))
    user = db.relationship('User', backref='role')

    def __repr__(self):
        return '<Role %r>' % self.name


class User(db.Model):
    __tablename__ = 'users'
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(64), unique=True, index=True)
    email = db.Column(db.String(64), unique=True)
    pswd = db.Column(db.String(64))
    role_id = db.Column(db.Integer, db.ForeignKey('roles.id'))

    def __repr__(self):
        return 'User:%s' % self.name

ORM的方法

filter_by(name='ed') # 按照字段查询,关键字阐述

filter()   # 自定义条件

first()   # 第一个

add_all()   # 批量添加数据

dirty   # 查看修改的数据

new     # 查看修改后的所有数据

commit() # 提交保存

rollback() # 回滚

order_by(User.id) # 排序

query() # 查询  返回元祖数据

query(User.name.label('name_label')) # 给查询的字段附上变量名


aliased() # 给表附上名字, 通过query查询时,可以使用
user_alias = aliased(User, name='user_alias')
for row in session.query(user_alias, user_alias.name).all()
	print(row.user_alias)

# in_  条件搜索
.filter(User.name.in_(['Edwardo', 'fakeuser']))

ORM查询方法

在filter()使用的:

• == ---> ColumnOperators.__eq__()

  query.filter(User.name == 'ed')
  

• != ---> ColumnOperators.__ne__()

  query.filter(User.name != 'ed')
  

• like --->ColumnOperators.like()

  query.filter(User.name.like('%ed%'))
  

• ilike ---> ColumnOperators.ilike()

  query.filter(User.name.ilike('%ed%'))
  

• in_ ---> ColumnOperators.in_()

  query.filter(User.name.in_(['ed', 'wendy', 'jack']))
  
  # works with query objects too:
  query.filter(User.name.in_(
      session.query(User.name).filter(User.name.like('%ed%'))
  ))
  
  # use tuple_() for composite (multi-column) queries
  from sqlalchemy import tuple_
  query.filter(
      tuple_(User.name, User.nickname).
      in_([('ed', 'edsnickname'), ('wendy', 'windy')])
  )
  

开启sqlAlachemy新窗口

# 实例 , 根据实际情况修改
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

from models import 表名

engine = create_engine('postgresql+psycopg2://数据库帐号:密码@localhost:8888/数据库名称')
DBSession = sessionmaker(bind=engine, )

eg_dict = {"k":"v"} # 额外参数

session = DBSession()
growth_list = session.query(表名).filter(表母名.字段.in_(eg_dict.get('k')),