ORM 与 SQLAlchemy 简介:

ORM 叫对象关系映射,ORM 将对象转换成SQL,然后使用数据API执行SQL并获取执行结果

SQLAlchemy 是Python 社区最知名的 ORM 工具之一,为高效和高性能的数据库访问设计,实现了完整的企业级持久模型。

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...]
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, INTEGER, String
from sqlalchemy.orm import sessionmaker
print(sqlalchemy.__version__) engin = create_engine('mysql+pymysql://root:123456@127.0.0.1:3306/llt_data',echo=True)#echo=True查看翻译好的sql Base = declarative_base()#生成一个sqlorm基类 #定义一个类(类==表,对象==行)
class User(Base):
__tablename__ = 'users'#声明表名
#列值
id = Column(INTEGER,primary_key=True,autoincrement=True)
name = Column(String(10),index=True)
fullname = Column(String(10))
password = Column(String(10)) __args__ = (
Index(id, name),#普通索引
uniqueContr(name,fullname)#组合唯一索引
) #可以查看处理的对象具体值
def __repr__(self):
return self.name Base.metadata.create_all(engin)#创建所有表结构
# Base.metadata.drop_all(engine)#删除所有表 ed_user = User(name='zc',fullname='zc1',password='')
print(ed_user)
#触发sessionmake类的__call__方法,return得到Session实例,赋给变量session,就可以进行(session.)等等操作
MySession = sessionmaker(bind=engin)
session = MySession()
session.add(ed_user) #插入数据
session.add_all([
User(name='zc1',fullname='zc2',password='123'),
User(name='zc1',fullname='zc2',password='123'),
User(name='zc1',fullname='zc2',password='123'),
User(name='zc1',fullname='zc2',password='123'),
]) session.commit()#每次必须提交 print(session.query(User).all())
for row in session.query(User).order_by(User.id):
print(row) for row in session.query(User).filter(User.name.in_(['zc','zc1''zc2'])):#全匹配里面的
print(row) for row in session.query(User).filter(~User.name.in_(['zc4','zc1''zc2'])):#取反,不在这三个之中的数据拿出来
print(row)
print(session.query(User).filter(User.name == 'zc').count())# 拿到数据,计数 #and_, or_必须导入
from sqlalchemy import and_, or_ for row in session.query(User).filter(and_(User.name == 'zc', User.fullname == 'zc zc2')):#and判断
print(row) for row in session.query(User).filter(or_(User.name == 'zc', User.fullname == 'zc zc2')):#or判断,
print(row)

简单操作表

创建表单:

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:123456:@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类型, .all() ret=session.query(Useru).filter(Useru.id>1,Useru.name=='aelx').all() #filter(条件判断时使用) 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")) 一对一给外键后面增加唯一:unique=True, # 多对多
class Group(Base):
__tablename__ = 'group'
id = Column(Integer, primary_key=True)
name = Column(String(64), unique=True, nullable=False)# 唯一, 不能为空
port = Column(Integer, default=22)# 端口号=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语句
  • ORM解决中文编码问题 sqlalchemy 默认使用latin-1进行编码。所以当出现中文时就会报如下错误:

    UnicodeEncodeError: 'latin-1' codec can't encode characters in position 39-41: ordinal not in range(256)
    解决方法:

    在连接数据库的时候直接指定字符编码:

    #engine = create_engine("mysql+pymysql://fuzj:123.com@127.0.0.1:3306/fuzj?charset=utf8", max_overflow=5,encoding='utf-8')
ret = session.query(UserType).filter_by(id=1).first()#.first可以取到值
print(ret.name) ret = session.query(UserType).filter_by(id=1).all()#.all取到是个列表内的对象,所以无法取到值
print(ret.name) ret = session.query(Father.name.label('kkk'),Son.name.label('ppp')).join(Son)#.label设置别名
print(ret)

使用__repr__定义返回的数据:

class User(Base):
__tablename__ = 'user'
nid = Column(Integer,primary_key=True,autoincrement=True)
name = Column(String(10),nullable=False)
role = Column(Integer,ForeignKey('role.rid'))
group = relationship("Role",backref='uuu') #Role为类名 def __repr__(self):
output = "(%s,%s,%s)" %(self.nid,self.name,self.role)
return output res = session.query(User).all()
print(res) 输出:
[(1,fuzj,1), (2,jie,2), (3,张三,2), (4,李四,1), (5,王五,3)]

ORM 一对多具体使用

mysql表中一对多指的是表A中的数据和表B中的数据存在对应的映射关系,表A中的数据在表B中对应存在多个对应关系,如表A存放用户的角色 DBA,SA,表B中存放用户,表B通过外键关联之表A中,多个用户可以属于同一个角色

  • 设计两张表,user表和role表,

    user 表中存放用户,role表中存放用户角色,role表中角色对应user表中多个用户,user表中一个用户只对应role表中一个角色,中间通过外键约束

    from sqlalchemy.ext.declarative import declarative_base
    from sqlalchemy import Column, Integer, String,ForeignKey
    from sqlalchemy.orm import sessionmaker,relationship
    from sqlalchemy import create_engine engine = create_engine("mysql+pymysql://fuzj:123.com@127.0.0.1:3306/fuzj?charset=utf8", max_overflow=5,encoding='utf-8')
    Base = declarative_base() class Role(Base):
    __tablename__ = 'role'
    rid = Column(Integer, primary_key=True, autoincrement=True) #主键,自增
    role_name = Column(String(10)) def __repr__(self):
    output = "(%s,%s)" %(self.rid,self.role_name)
    return output class User(Base):
    __tablename__ = 'user'
    nid = Column(Integer,primary_key=True,autoincrement=True)
    name = Column(String(10),nullable=False)
    role = Column(Integer,ForeignKey('role.rid')) #外键关联 def __repr__(self):
    output = "(%s,%s,%s)" %(self.nid,self.name,self.role)
    return output
    Base.metadata.create_all(engine) Session = sessionmaker(bind=engine)
    session = Session() #添加角色数据
    session.add(Role(role_name='dba'))
    session.add(Role(role_name='sa'))
    session.add(Role(role_name='net')) #添加用户数据
    session.add_all([
    User(name='fuzj',role=''),
    User(name='jie',role=''),
    User(name='张三',role=''),
    User(name='李四',role=''),
    User(name='王五',role=''),
    ])
    session.commit()
    session.close()
    普通连表查询:
    
    res = session.query(User,Role).join(Role).all()    #查询所有用户,及对应的role id
    res1 = session.query(User.name,Role.role_name).join(Role).all() #查询所有用户和角色,
    res2 = session.query(User.name,Role.role_name).join(Role,isouter=True).filter(Role.role_name=='sa').all() #查询所有DBA的用户
    print(res)
    print(res1)
    print(res2) 输出结果:
    [((1,fuzj,1), (1,dba)), ((2,jie,2), (2,sa)), ((3,张三,2), (2,sa)), ((4,李四,1), (1,dba)), ((5,王五,3), (3,net))]
    [('fuzj', 'dba'), ('jie', 'sa'), ('张三', 'sa'), ('李四', 'dba'), ('王五', 'net')]
    [('jie', 'sa'), ('张三', 'sa')]

    使用relationship 添加影射关系进行查询

    • 首先在User表中添加relationship影射关系

      class User(Base):
      __tablename__ = 'user'
      nid = Column(Integer,primary_key=True,autoincrement=True)
      name = Column(String(10),nullable=False)
      role = Column(Integer,ForeignKey('role.rid'))
      group = relationship("Role",backref='uuu') #Role为类名
      查询:
      
      #正向查询
      print('正向查询')
      res = session.query(User).all() #查询所有的用户和角色
      for i in res:
      print(i.name,i.group.role_name) #此时的i.group 就是role表对应的关系
      res = session.query(User).filter(User.name=='fuzj').first() #查询fuzj用户和角色
      print(res.name,res.group.role_name) print('反向查找')
      #反向查找
      res = session.query(Role).filter(Role.role_name =='dba').first() #查找dba组下的所有用户
      print(res.uuu) #此时 print的结果为[(1,fuzj,1), (4,李四,1)]
      for i in res.uuu:
      print(i.name,res.role_name) 输出结果:
      正向查询
      fuzj dba
      jie sa
      张三 sa
      李四 dba
      王五 net
      fuzj dba
      反向查找
      [(1,fuzj,1), (4,李四,1)]
      fuzj dba
      李四 dba
        • 说明

          relationship 在user表中创建了新的字段,这个字段只用来存放user表中和role表中的对应关系,在数据库中并不实际存在
          正向查找: 先从user表中查到符合name的用户之后,此时结果中已经存在和role表中的对应关系,group对象即role表,所以直接使用obj.group.role_name就可以取出对应的角色
          反向查找:relationship参数中backref='uuu',会在role表中的每个字段中加入uuu,而uuu对应的就是本字段在user表中对应的所有用户,所以,obj.uuu.name会取出来用户名
          所谓正向和反向查找是对于relationship关系映射所在的表而说,如果通过该表(user表)去查找对应的关系表(role表),就是正向查找,反正通过对应的关系表(role表)去查找该表(user表)即为反向查找。而relationship往往会和ForeignKey共存在一个表中。

      • ORM 多对多具体使用

        Mysql多对多关系指的是两张表A和B本没有任何关系,而是通过第三张表C建立关系,通过关系表C,使得表A在表B中存在多个关联数据,表B在表A中同样存在多个关联数据

        • 创建三张表 host表 hostuser表 host_to_hostuser表

        host表中存放主机,hostuser表中存放主机的用户, host_to_hostuser表中存放主机用户对应的主机,hostuser表中用户对应host表中多个主机,host表中主机对应hostuser表中多个用户,中间关系通过host_to_hostuser表进行关联。host_to_hostuser和host表、user表进行外键约束

        from sqlalchemy.ext.declarative import declarative_base
        from sqlalchemy import Column, Integer, String,ForeignKey
        from sqlalchemy.orm import sessionmaker,relationship
        from sqlalchemy import create_engine
        class Host(Base):
        __tablename__ = 'host'
        nid = Column(Integer, primary_key=True,autoincrement=True)
        hostname = Column(String(32))
        port = Column(String(32))
        ip = Column(String(32)) class HostUser(Base):
        __tablename__ = 'host_user'
        nid = Column(Integer, primary_key=True,autoincrement=True)
        username = Column(String(32)) class HostToHostUser(Base):
        __tablename__ = 'host_to_host_user'
        nid = Column(Integer, primary_key=True,autoincrement=True) host_id = Column(Integer,ForeignKey('host.nid'))
        host_user_id = Column(Integer,ForeignKey('host_user.nid')) Base.metadata.create_all(engine) Session = sessionmaker(bind=engine)
        session = Session() #添加数据
        session.add_all([
        Host(hostname='c1',port='',ip='1.1.1.1'),
        Host(hostname='c2',port='',ip='1.1.1.2'),
        Host(hostname='c3',port='',ip='1.1.1.3'),
        Host(hostname='c4',port='',ip='1.1.1.4'),
        Host(hostname='c5',port='',ip='1.1.1.5'),
        ]) session.add_all([
        HostUser(username='root'),
        HostUser(username='db'),
        HostUser(username='nb'),
        HostUser(username='sb'),
        ]) session.add_all([
        HostToHostUser(host_id=1,host_user_id=1),
        HostToHostUser(host_id=1,host_user_id=2),
        HostToHostUser(host_id=1,host_user_id=3),
        HostToHostUser(host_id=2,host_user_id=2),
        HostToHostUser(host_id=2,host_user_id=4),
        HostToHostUser(host_id=2,host_user_id=3),
        ]) session.commit()
        session.close()
        • 普通多次查询

          host_id = session.query(Host.nid).filter(Host.hostname=='c2').first()   #查找hostbane对应的hostid,返回结果为元组(2,)
          user_id_list = session.query(HostToHostUser.host_user_id).filter(HostToHostUser.host_id==host_id[0]).all() #查询hostid对应的所有userid
          user_id_list = zip(*user_id_list) #user_id_list 初始值为[(2,), (4,), (3,)],使用zip转换为[2,4,3]对象
          #print(list(user_id_list)) #结果为[(2, 4, 3)]
          user_list = session.query(HostUser.username).filter(HostUser.nid.in_(list(user_id_list)[0])).all() #查询符合条件的用户
          print(user_list) #或者:
          user_id_list = session.query(HostToHostUser.host_user_id).join(Host).filter(Host.hostname=='c2').all()
          user_id_list = zip(*user_id_list)
          user_list = session.query(HostUser.username).filter(HostUser.nid.in_(list(user_id_list)[0])).all()
          print(user_list)
          [('db',), ('nb',), ('sb',)]
        • 使用relationship映射关系查询

          • 首先在关系表Host_to_hostuser中加入relationship关系映射

            class HostToHostUser(Base):
            __tablename__ = 'host_to_host_user'
            nid = Column(Integer, primary_key=True,autoincrement=True) host_id = Column(Integer,ForeignKey('host.nid'))
            host_user_id = Column(Integer,ForeignKey('host_user.nid'))
            host = relationship('Host',backref='h') #对应host表
            host_user = relationship('HostUser',backref='u') #对应host_user表
            查询:
            
            #查找一个服务器上有哪些用户
            res = session.query(Host).filter(Host.hostname=='c2').first() #返回的是符合条件的服务器对象
            res2 = res.h #通过relationship反向查找 Host_to_Hostuser中的对应关系
            for i in res2: #i为host_to_hostuser表和host表中c2主机有对应关系的条目
            print(i.host_user.username) #正向查找, 通过relationship ,找到host_to_hostuser中对应的hostuser 即i.host_user #查找此用户有哪些服务器
            res = session.query(HostUser).filter(HostUser.username=='sb').first()
            for i in res.u:
            print(i.host.hostname)
              • 扩展查询

              不查询关系表,直接在hostuser表中指定关系表,然后获取host表

            在host表中使用 relationship的secondary指定关系表。

            class Host(Base):
            __tablename__ = 'host'
            nid = Column(Integer, primary_key=True,autoincrement=True)
            hostname = Column(String(32))
            port = Column(String(32))
            ip = Column(String(32))
            host_user = relationship('HostUser',secondary=lambda :HostToHostUser.__table__,backref='h') 注意使用lambda是为了使表的顺序不在闲置 查询: host_obj = session.query(Host).filter(Host.hostname=='c1').first()
            for i in host_obj.host_user:
            print(i.username)
#!/usr/bin/env python
# -*- coding:utf-8 -*-
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 engine = create_engine('sqlite:///dbyuan674uu.db', echo=True) Base = declarative_base() class Men_to_Wemon(Base):
__tablename__ = 'men_to_wemon'
nid = Column(Integer, primary_key=True)
men_id = Column(Integer, ForeignKey('men.id'))
women_id = Column(Integer, ForeignKey('women.id')) class Men(Base):
__tablename__ = 'men'
id = Column(Integer, primary_key=True)
name = Column(String(32))
age= Column(String(16)) class Women(Base):
__tablename__ ='women'
id = Column(Integer, primary_key=True)
name = Column(String(32))
age= Column(String(16))
bf=relationship("Men",secondary=Men_to_Wemon.__table__,backref='gf') Base.metadata.create_all(engine) Session = sessionmaker(bind=engine)
session = Session() m1=Men(name='alex',age=18)
m2=Men(name='wusir',age=18)
w1=Women(name='如花',age=40)
w2=Women(name='铁锤',age=45) # t1=Men_to_Wemon(men_id=1,women_id=2) m1.gf=[w1,w2]
w1.bf=[m1,m2] session.add_all([m1,m2,w1,w2]) session.commit()
#!/usr/bin/env python
# -*- coding:utf-8 -*-
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 engine = create_engine('sqlite:///dbyuan67.db?') Base=declarative_base() class Men(Base):
__tablename__ = 'men'
id = Column(Integer, primary_key=True)
name = Column(String(32))
age= Column(String(16)) # __table_args__ = (
# UniqueConstraint('id', 'name', name='uix_id_name'),
# Index('ix_id_name', 'name', 'extra'),
# ) def __repr__(self):
return self.name class Women(Base):
__tablename__ ='women'
id = Column(Integer, primary_key=True)
name = Column(String(32))
age= Column(String(16)) men_id=Column(String(20), ForeignKey('men.id'))
# def __repr__(self):
# return self.age # Base.metadata.create_all(engine)
# Base.metadata.drop_all(engine)
Session = sessionmaker(bind=engine)
session = Session()
# select * from
# select id,name from women
# sql=session.query(Women).all()
# select * from women inner join men on women.men_id = men.id
sql = session.query(Women.age,Men.name).join(Men).all()
print(sql)
# print(sql)
# r = session.query(session.query(Women.name.label('t1'), Men.name.label('t2')).join(Men).all()).all()
# print(r) # r = session.query(Women).all()
# print(r) # m1=Men(name='alex',age=18)
# w1=Women(name='如花',age=40)
# w2=Women(name='铁锤',age=45)
# m1.gf=[Women(name='如花',age=40),Women(name='铁锤',age=45)] # m1=Men(name='alex',age=18)
# w1=Women(name='如花',age=40,men_id = 1)
# w2=Women(name='铁锤',age=45,men_id = 1)
# session.add_all([w1,w2])
# session.commit()

SQLAlchemy_ORM的更多相关文章

随机推荐

  1. remmina如何上传文件到linux服务器

    1.安装filezilla 2. remmina中选择列表中的主机,点击“外部工具 -> filezilla-xfp.sh” 3. 弹出filezilla,输入主机,端口,用户名,密码,连接, ...

  2. easyui 自定义验证规则 验证用户是否已经存在 远程ajax验证

    easyui远程ajax验证 2014年09月30日 22:29:32 clj198606061111 阅读数:6130 标签: easyui 更多 个人分类: jqueryeasyui 版权声明:本 ...

  3. Gradle依赖的统一管理,解决依赖冲突

    看见别人在用implementation rootProject.ext.dependencies["xxxx"]不知道是什么意思,上网查了一下,原来是为了解决或者说预防gradl ...

  4. mysql无法生成log文件

    做服务器主从配置时,发现/var/log/mysql下面一直没有log文件,明明配置文件/etc/mysql/mysql.conf.d/mysqld.cnf也开启log了. general_log_f ...

  5. 【phpMQTT】phpMQTT详解以及处理使用过程中内存耗死问题

    参考文档: https://www.cloudmqtt.com/docs-php.html github下载 : https://github.com/bluerhinos/phpMQTT Cloud ...

  6. JS中判断一个对象是否为null、undefined、0

    1.判断undefined: var tmp = undefined; if (typeof(tmp) == "undefined"){ alert("undefined ...

  7. vue 数据管道

    文档https://cn.vuejs.org/v2/guide/filters.html html 片段 <div class="app"> <div>{{ ...

  8. Thrift版本管理

    对于健壮的服务,其中的数据类型必须一种机制来对其进行版本管理,尤其是它可以在不中断服务(或者更坏的情况,出现段错误)的前提下,增加或删除一个对象中的字段,或者改变一个函数的参数列表. 字段标识符 Th ...

  9. python爬取并批量下载图片

    import requests from lxml import etree url='http://desk.zol.com.cn/meinv/' add1='.html' urls=[] i = ...

  10. shell特殊变量,记录一下

    $0 当前脚本的文件名 $n 传递给脚本或函数的参数.n 是一个数字,表示第几个参数.例如,第一个参数是$1,第二个参数是$2. $# 传递给脚本或函数的参数个数. $* 传递给脚本或函数的所有参数. ...