python/SQLAchemy

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

安装：

1	`pip3 install 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

ORM功能使用：

使用 ORM/Schema Type/SQL Expression Language/Engine/ConnectionPooling/Dialect 所有组件对数据进行操作。根据类创建对象，对象转换成SQL，执行SQL。

创建表单：

 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()

 #定义一个类（类==表，对象==行）

 class UserType(Base):

     __tablename__='usertype'  ##设置表名

     id=Column(Integer,primary_key=True,autoincrement=True)  ##设置表行

     title=Column(String(32),nullable=True,index=True)       ##设置表行

 class Useru(Base):

     __tablename__='useru'

     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'))

     user_type=relationship('UserType',backref='xxoo')

     ##设置关联语句 relationship找指定的表名（UserType）创建列名（xxoo）实现双向关联，而在自身的表中创建出一列。

 engine=create_engine("mysql+pymysql://root:@127.0.0.1:3306/lian?charset=utf8",max_overflow=5)

 ##设置连接引擎

 # 找到所有继承了Base得类，类-SQL语句在数据库创建表

 Base.metadata.create_all(engine)

 # 找到所有继承了Base得类，类-SQL语句在数据库删除表

 # Base.metadata.drop_all(engine)

数据行操作：

 # 操作数据行：

 # # 去引擎中获取一个连接

 Session=sessionmaker(bind=engine)

 session=Session()

 # session.commit()

 # session.close()

 ########表增加#######

 # obj=Useru(name='话梅',email='92242@qq.com',user_type_id=2)  要插入每行的内容

 # session.add(obj) 通过对象.add（要插入的变量名）进行添加

 # session.commit()  通过对象.commit（）进行提交

 #------单个增加-------

 #======多个增加=======

 # obj=[

 #         Useru(name='alex1',email='12321@qq.com'),

 #         Useru(name='alex2',email='12322@qq.com'),

 #         Useru(name='alex3',email='12323@qq.com'),

 #         Useru(name='alex4',email='12324@qq.com'),

 #         Useru(name='alex5',email='12325@qq.com')

 #

 #     ]

 #

 # session.add_all(obj)

 # session.commit()

 ########查看#########

 # user_list=session.query(Useru)

 # for row in user_list:

 #     print(row.name,row.id,row.user_type_id)

 #要进行表的修改和删除首先要查看表的内容

 ########表修改########

 # session.query(UserType).filter(UserType.id==1).update({'title':'黄金用户'})

 # session.commit()

 # session.query(UserType).filter(UserType.id==1).update({UserType.title:UserType.title+"x"},synchronize_session=False)

 # session.commit()

 # session.query(Useru).filter(Useru.id > 0).update({Useru.name: Useru.name + "x"},synchronize_session=False)

 # session.query(Useru).filter(Useru.id>2).update({'num':Users.num+1},synchronize_session='evaluate')
   # session.commit()

 ########表删除#######

 # session.query(UserType).filter(UserType.id==1).delete()

 # session.commit()

 # type_list=session.query(UserType)

 # for row in type_list:

 #     print(row.id,row.title)

 #     for j in row.xxoo:

 #         print('-----',j.name)

其他操作：

 ##其他操作##

 # 条件：

 # ret=session.query(Useru).filter_by(name='alex').all()   ##filter_by  可以接收**args类型

 # ret=session.query(Useru).filter(Useru.id>1,Useru.name=='aelx').all()

 # ret=session.query(Useru).filter(Useru.id.between(1,3),Useru.name=='alex').all()

 # ret=session.query(Useru).filter(Useru.id.in_([1,3,5])).all()   ##in_就是相当于in

 # ret=session.query(Useru).filter(~Useru.id.in_([1,3,5])).all()  ##~  相当于非的意思

 # ret=session.query(Useru).filter(Useru.id.in_(session.query(Useru.id).filter_by(name='alex'))).all() ##多层套嵌条件查询

 # from sqlalchemy import and_,or_

 # ret =session.query(Useru).filter(and_(Useru.id>3,Useru.name=='alex')).all()  ##and_ 相当于and

 # ret=session.query(Useru).filter(or_(Useru,id<2,Useru.name=='alex')).all()   ##or_  相当于or

 # ret=session.query(Useru).filter(

 #     or_(Useru.id <2,and_(Useru.name=='alex',Useru.id >3),Useru.extra !='')

 # )##or_括号里都是or的关系，但是在括号里有一个是and 的关系

 #

 # 通配符：

 #  ret=session.query(Useru).filter(Useru.name.like('e%')).all()   #查找name以e开头的

 #  ret=session.query(Useru).filter(~Useru.name.like('e%')).all()  #查找name不是以e开头的

 #

 #  限制：

 # ret=session.query(Useru)[1:2]  #通过切片的实现分页的功能

 # 排序：

 #  ret=session.query(Useru).order_by(Useru.name.desc()).all()  #以降序进行排序

 #  ret=session.query(Useru).order_by(Useru.name.desc(),Useru.id.asc()).all()   #开始以降序进行排序，如果过有重复的就按照id以升序排序

 # 分组：

 from sqlalchemy.sql import func

 # ret =session.query(Useru).group_by(Useru.name).all()  #以名字进行分组

 # ret=session.query(

 #     func.max(Useru.id),

 #     func.sum(Useru.id),

 #     func.min(Useru.id)

 # ).group_by(Useru.name).all()   #以名字进行分组，然后操作合并后的列

 # ret = session.query(

 #     func.max(Useru.id),

 #     func.sum(Useru.id),

 #     func.min(Useru.id)).group_by(Useru.name).having(func.min(Useru.id) >2).all()    #有having二次筛选的

 #

 # print(ret)

 # 连表：

 # ret=session.query(Useru,UserType).filter(UserType.id==Useru.id).all()   #进行连表操作

 # ret =session.query(Useru).join(UserType).all()                          # 这样是inner join  （不显示空）

 # ret = session.query(Useru).join(UserType,isouter=True).all()            #这样是left join     （显示空）

 #组合：

 # q1=session.query(Useru.name).filter(Useru.id >2)

 # q2=session.query(UserType.id).filter(UserType.id<1)

 # ret=q1.union(q2).all()                                                   #这是去重组合

 #

 # q1 = session.query(Useru.name).filter(Useru.id > 2)

 # q2 = session.query(UserType.id).filter(UserType.id < 1)

 # ret = q1.union_all(q2).all()                                             #这是不去

 #

 #

 # 子查询：

 # q3=session.query(Useru.name).filter(Useru.id >2).subquery()

 # restt=session.query(q3).all()

 # print(restt)

创建一对多等：

 # 一对多

 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'))

简述ORM原理：

 class User：

     def __init__(self):

             self.id=id

             self.name=name

             self.email=email

     def order_by():

             pass

 ogj=User('1.1.1.1','alex','34434@qq.com')

 --------------------------------

 obj.__dict__={'id':'1.1.1.1','name':'alex','email':'34434@qq.com'}

 --------------------------------------------------------------------------

 ORM的作用就是把类和对象方式解析成SQL语句（不进行连接，连接借助第三方模块）

 code first   通过手动写SQL语句-------->类

 db  first     通过手动写类--------------->SQL语句