python之sqlalchemy模块

面向对象的一些特殊方法：一定要记住的方法....就四个方法

class Foo:
    def __init__(self, name):
        self.name = name

    def show(self):
        print(self.name)
    #实例化出来的对象加()就会运行call函数
    def __call__(self):
        pass

    def __getitem__(self, key):
        pass

    def __setitem__(self, key, value):
        pass

    def __delitem__(self, key):
        pass


obj1 = Foo('eric')

obj1()
obj1['k']
obj1['k'] = 123
del obj[k]
obj.__dict__

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

实现对数据库的操作，如：

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

一、ORM的功能使用

1.创建表

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

Base =  declarative_base()#固定的生成一个基类
#在创建之前，需要先调用sqlalchemy模块，以及该模块中的属性，

class UserType(Base):
    __tablename__ = 'usertype'
    id = Column(Integer,primary_key=True,autoincrement=True)
    title = Column(String(32),nullable=True,index=True)


class Users(Base):#每一个类就代表着一个表
    __tablename__ = 'uses' #建立表名
    #和原生的大致是一样的，里面创建的一些方式都是一样。
    # __tablename__：设置表名称
    # Integer：整数类型
    # primary_key=True:主键
    # autoincrement=True：自增id
    # nullable=True:是否为空
    # index=True：索引
    # unique=True：唯一约束
    # ForeignKey：建立外键，绑定到你对应的表的id
    # relationship：通过建立的外键，建立关系，
         -- 正向操作：即运行users中的user_type，可以调取到外键的表内容
         -- 方向操作：即运行UserType，即可以运行主表的内容
    id = Column(Integer,primary_key = True,autoincrement=True)
    name = Column(String(32),nullable=True,index=True)
    email = Column(String(16),unique=True)
    user_type_id = Column(Integer,ForeignKey('usertype.id'))
# __table_args__：创建
    __table_args__ = (
        #建立唯一联合索引，有约束的关系，即列与列之间是相同的有关系
        UniqueConstraint('id','name',name = 'ux_id_name'),
        #建立普通联合索引，没有约束，即列与列之间是相同的也没关系
        Index('ix_n_name','name','email')
    )

#建立数据库连接
'''
mysql+pymysql:数据库+通过python中的pymysql进行连接
root：数据库的账号
1234qwer：数据库的账号密码
127.0.0.1：ip地址
3306：端口号
db1：数据库名称
charset=utf8：编码
max_overflow=5：最大连接数，
'''
# create_engine用来初始化数据库连接
engine = create_engine('mysql+pymysql://root:1234qwer@127.0.0.1:3306/db1?charset=utf8',max_overflow=5)
#根据我创建的表提交到数据库中，创建完之后可以注释掉，以免重复创建。
Base.metadata.create_all(engine)

2.增加

#创建Session类型
Session = sessionmaker(bind=engine)
#创建session对象
session = Session()

#实例化一个对象
obj1=UserType(title='普通用户')
#通过add添加到表中
session.add(obj1)

#创建多个用户，
objs=[
    UserType(title='普通用户'),
    UserType(title='高级用户'),
    UserType(title='黑金用户'),
]
#使用add_all,增加多个，进行添加
session.add_all(objs)

session.commit() #提交你对表的操作
session.close()  #关闭表

3.查找

#创建Session类型
Session = sessionmaker(bind=engine)
#创建session对象
session = Session()

#得到的是一个sql查询的语句
#session.query():session是一个对象，query()是一个方法
print(session.query(UserType))
#all()取出所有的内容
user_type_list = session.query(UserType).all()
#user_type_list，获取的是一个迭代器，需要通过遍历取出里面的内容
for row in user_type_list:
    print(row.id,row.title)

#根据筛选进行查找filter(UserType.id>2)=where UserType.id>2
user_type_list = session.query(UserType.id,UserType.title).filter(UserType.id>2)
for row in user_type_list:
    print(row.id,row.title)

4.删除

#创建Session类型
Session = sessionmaker(bind=engine)
#创建session对象,可以看做是连接当前的数据库
session = Session()

#通过filter过滤出来，然后直接使用delete方法删除你过滤出来的
session.query(UserType.id,UserType.title).filter(UserType.id>5).delete()

session.commit() #提交你对表的操作
session.close()  #关闭表

　　

5.修改

#通过不同的类型，添加不同的值
'''
update:修改，方法中一定要用字典的形式
synchronize_session=False：字符串相加
synchronize_session='evaluate'：整数相加
'''
session.query(UserType.id,UserType.title).filter(UserType.id >2).update({'title':'钻石'})
session.query(UserType.id,UserType.title).filter(UserType.id >2).update({UserType.title:UserType.title+'y'},synchronize_session=False)#字符串相加
session.query(UserType.id,UserType.title).filter(UserType.id >2).update({UserType.num:UserType.num+1},synchronize_session='evaluate') # 整数相加

问题集：

正向操作：即运行users中的user_type，可以调取到外键的表内容

反向操作：即运行UserType，即可以运行主表的内容

问题1.获取用户信息以及与其关联用户类型名称（FK，relationship=>正向操作）以下是不同的思路

#isouter=True:左连接，默认是inner,join:sql中的连表
user_list = session.query(Users,UserType).join(UserType,isouter=True)
# # print(user_list)#结果是一个连表的操作
for row in user_list:
    print(row[0].id,row[0].name,row[0].email,row[0].user_type_id,row[1].title)

#all():返回所有行，one():返回一行，不加参数是返回所有行
userlist = session.query(Users.name,UserType.title).join(UserType,isouter=True).all()
#在查询的时候查询的是Users.name,UserType.title，既可以通过索引查找，也可以通过固定的列名
for row in userlist:
    print(row[0],row[1],row.name,row.title)

正向操作：即运行users中的user_type，可以调取到外键的表内容

#上面的两个方法，都是需要进行连表，这个是通过在Users类中添加了，对外键的表建立的关联。
# user_type = relationship('UserType',backref='xxoo')，所以就可以直接查询Users表，就能读取外键表的内容
user_list = session.query(Users)
for row in user_list:
    print(row.name,row.id,row.user_type.title)

问题2.获取用户类型

#反向操作：即运行UserType，即可以运行主表的内容
type_list = session.query(UserType)
for row in type_list:
    #通过外键的表反查询主表的内容，可以通过反向操作，查询不同的用户的人数....
    print(row.id,row.title,session.query(Users).filter(Users.user_type_id==row.id).all())

#反向操作：即运行UserType，即可以运行主表的内容，user_type = relationship('UserType',backref='xxoo')，
#backref='xxoo'，代表着行。通过遍历，就能取到主表的数据
#查看的是的外键的表，row.xxoo获取的是外键的用户，是一个对象，组成的列表，可以通过遍历，显示列表中的用户
type_list = session.query(UserType)
for row in type_list:
    #通过反向操作，
    print(row.id,row.title,[i.name for i in row.xxoo])