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

1、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])