python操作mysql(ORM)（转）

1.https://www.baidu.com/link?url=YPRHwbVIUWG08RvvQnigWIDAwO6ml61SQwnA2KyQkSwKe0Djcp2NNOkXKz422GNL&wd=&eqid=bdd8b5890004f6e6000000025e6b42c8

安装方法
pip install SQLAlchemy

from sqlalchemy import create_engine

from sqlalchemy.ext.declarative import declarative_base 
from sqlalchemy import Column, Integer, String ,DateTime, Boolean

# 连接数据库
engine = create_engine('mysql://root:password@localhost:3306/school?charset=utf8')
## 编码问题

# # 获取基类
Base = declarative_base()

class News(Base): # 继承基类
    __tablename__ = 'students1'
    id = Column(Integer, primary_key = True)
    nickname = Column(String(20))
    name = Column(String(20), nullable = False)
    sex = Column(String(1))
    in_time = Column(DateTime)
    is_vaild = Column(Boolean)
    idcard = Column(Integer, unique = True)
        
News.metadata.create_all(engine)   # 创建表格

## 新增数据
from sqlalchemy.orm import sessionmaker
Session = sessionmaker(bind=engine)

class OrmTest(object):
    def __init__(self):
        self.session = Session()

    def add_one(self):
        new_obj = News(
            nickname = '123',
            name = '321',
            sex = '男',
        )
        self.session.add(new_obj)
        self.session.commit()
        return new_obj

    def add_more(self):
        new_obj = News(
            nickname = '123',
            name = '321',
            sex = '男',
        )
        new_obj2 = News(
            nickname = 'wei',
            name = 'lai',
            sex = '女',
        )
        self.session.add_all([new_obj,
                        new_obj2])
        self.session.commit()
        return new_obj

## 查询数据        
    def get_one(self):
        return self.session.query(News).get(10)  # get 是选id为2的

    def get_more(self):
        return self.session.query(News).filter_by(is_vaild=True)


## 修改数据
## 将一条当作多条的一种情况
    def update_data(self):
        data_list = self.session.query(News).filter(News.id >= 5)
        for item in data_list:
            if item:
                item.is_vaild = 0 
                self.session.add(item)  # 加入
        self.session.commit()  # 提交
## filter 与 filter_by 的区别


## 删除数据
    def delete_data(self):
        data = self.session.query(News).get(8)
        if data:
            self.session.delete(data)
            self.session.commit()
        else:
            return False

    def delete_data_more(self):
        delete_list = self.session.query(News).filter(News.id <= 5)
        for item in delete_list:
            if item:
                self.session.delete(item)       
            else:
                return False
        self.session.commit() 



def main():
    obj = OrmTest()
    obj.add_one()
    obj.add_more()

    data = obj.get_one() 

    ## 防止查询失误
    if data:  
        print('ID:{0}  {1}'.format(data.id,data.sex))
    else:
        print('Not exist')

    data_more = obj.get_more()
    print(data_more.count())  # 计数
    for new_obj in data_more:
        print('ID:{0}  {1} {2} {3}'.format(new_obj.id,new_obj.sex,new_obj.name,new_obj.nickname))

    obj.update_data()
    print('数据修改成功')
    
    obj.delete_data()
    print('数据删除成功')

    obj.delete_data_more()


if __name__ == '__main__':
    main()

2.https://www.cnblogs.com/iexperience/p/9511462.html

ORM 对象映射关系程序。

通过orm将编程语言的对象模型和数据库的关系模型建立映射关系，这样我们在使用编程语言对数据库进行操作的时候可以直接使用编程语言的对象模型进行操作就可以了，而不用直接使用sql语言。

orm的优点：

1. 隐藏了数据访问细节，“封闭”的通用数据库交互，ORM的核心。他使得我们的通用数据库交互变得简单易行，并且完全不用考虑该死的SQL语句。快速开发，由此而来。
2. ORM使我们构造固化数据结构变得简单易行。

缺点：

1. 无可避免的，自动化意味着映射和关联管理，代价是牺牲性能（早期，这是所有不喜欢ORM人的共同点）。现在的各种ORM框架都在尝试使用各种方法来减轻这块（LazyLoad，Cache），效果还是很显著的。

最有名的ORM框架是SQLAlchemy，系统中没有该模块的需要安装 pip  install sqlalchemy （或easy_install SQLAlchemy）

如果在pip  install sqlalchemy 中报ReadTimeoutError: HTTPSConnectionPool(host='files.pythonhosted.org'错，需要先设置超时时间：pip --default-timeout=100 install -U Pillow，再重新安装 pip  install sqlalchemy，通过imort sqlalchemy验证是否安装正常。

ORM框架SQLAlchemy 使用，创建表：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

#conding:utf-8 import  sqlalchemy from sqlalchemy import  create_engine from sqlalchemy.ext.declarative import declarative_base from sqlalchemy import Column,Integer,String #区分大小写 #创建连接 engine=create_engine("mysql+pymysql://root:123456@localhost/ceshi",encoding='utf-8',echo=True) #生成orm基类 base=declarative_base() class user(base):     __tablename__ = 'users' #表名     id = Column(Integer, primary_key=True)     name = Column(String(32))     password = Column(String(64)) base.metadata.create_all(engine) #创建表结构

注：pymysql设置编码字符集一定要在数据库访问的URL上增加?charset=utf8，否则数据库的连接就不是utf8的编码格式

1	engine=create_engine("mysql+pymysql://root:123456@localhost/ceshi",encoding='utf-8',echo=True)

ORM框架SQLAlchemy 使用，插入数据：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

#conding: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 #创建连接 engine=create_engine("mysql+pymysql://root:123456@localhost/ceshi",encoding='utf-8',echo=True) #生成orm基类 base=declarative_base() class user(base):     __tablename__ = 'users' #表名     id = Column(Integer, primary_key=True)     name = Column(String(32))     password = Column(String(64)) base.metadata.create_all(engine) #创建表结构 Session_class=sessionmaker(bind=engine) ##创建与数据库的会话，class,不是实例 Session=Session_class()   #生成session实例 user_obj = user(name="rr",password="123456") #插入你要创建的数据对象，每执行一次都会新增一次数据。 print user_obj.name,user_obj.id   #此时还没创建对象呢，不信你打印一下id发现还是None Session.add(user_obj)  #把要创建的数据对象添加到这个session里 print user_obj.name,user_obj.id  #此时也依然还没创建 Session.commit() #提交，使前面修改的数据生效。

　结果：

查询：

1 2 3

my_user = Session.query(user).filter_by(name="ee").first() #创建查询对象 print(my_user.id,my_user.name,my_user.password)  #输出查询内容 print my_user  #内存地址

结果：

修改：

1 2 3

my_user = Session.query(user).filter_by(name="yy").first() #根据指定条件创建符合条件的对象 my_user.name='uu' #将name='yy'的name修改为uu print(my_user.id,my_user.name,my_user.password)  #输出查询内容

结果：

参考数据表：

回滚：

1 2 3 4 5 6 7

user_obj = user(name="kk",password="99999") #插入你要创建的数据对象 Session.add(user_obj)  #把要创建的数据对象添加到这个session里 my_user = Session.query(user).filter_by(name="rr").first() #根据指定条件创建符合条件的对象，first()是指name='rr'的第一条记录 my_user.name="gg" #将name='yy'的name修改为uu print(Session.query(user).filter(user.name.in_(["gg","kk"])).all())  #显示修改后的数据 Session.rollback() #回滚 print(Session.query(user).filter(user.name.in_(["gg","kk"])).all()) #显示回滚后的内容

结果：

获取所有数据

1	print Session.query(user.id,user.name).all()  #只显示id,name

结果：

多条件查询

1 2	objs = Session.query(user).filter(user.id>0).filter(user.id<=3).all() #注意：filter()中的关键字不能是表达式user.id=0 print objs

filter的关系相当于 user.id >0 AND user.id <=3 的效果

结果： 

 

 统计和分组

1 2	objs = Session.query(user).filter(user.name.like('r%')).count()  #统计 print objs

结果：

1 2	from sqlalchemy import func print(Session.query(func.count(user.name),user.name).group_by(user.name).all() ) #分组

结果：

外键关联

参照表：两张表是一对多的关系。

1

users（一）

 

addresses（多）

创建表addresses，将users表中的id作为addresses表的外键。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

import  sqlalchemy from sqlalchemy import  create_engine from sqlalchemy.ext.declarative import declarative_base from sqlalchemy import Column,Integer,String,ForeignKey #区分大小写 from sqlalchemy.orm import sessionmaker,relationship #创建连接 engine=create_engine("mysql+pymysql://root:123456@localhost/ceshi",encoding='utf-8',echo=True) #生成orm基类 base=declarative_base() class user(base):     __tablename__ = 'users' #表名     id = Column(Integer, primary_key=True)     name = Column(String(32))     password = Column(String(64))     def __repr__(self):         return "<user(id='%d',name='%s',  password='%s')>" % (self.id,         self.name, self.password)       class Address(base):     __tablename__ = 'addresses'     id = Column(Integer, primary_key=True)     email_address = Column(String(32), nullable=False)     user_id = Column(Integer, ForeignKey('users.id'))     user = relationship("user", backref="addresses")      '''允许你在user表里通过backref字段反向查出所有它在addresses表里的关联项，在内存中创建。在addresses表中可以使用user来查询users表中的数据，在users表中可以使用backref后的addresses来查询assresses表中的数据。'''       def __repr__(self):         return "<Address(email_address='%s',id='%d',user_id='%d')>" % (self.email_address,self.id,self.user_id) base.metadata.create_all(engine) #创建表结构 Session_class=sessionmaker(bind=engine) #创建与数据库的会话，class,不是实例 Session=Session_class()   #生成session实例 obj = Session.query(user).first() print obj.addresses  #在users表里面通过addresses来查询addresses表中的数据。   for i in obj.addresses:     print i       addr_obj = Session.query(Address).first() print(addr_obj.user)  #在addresses表中通过user来查询users表中的数据。 print(addr_obj.user.name)   Session.commit() #提交，使前面修改的数据生效。

　　

 结果：

 输出的结果1是列表形式，print 多行记录时以列表的形式显示。

 注：在定义表的类下面加 def __repr__(self):    return ... 是为了在print时输出哪些数据，以及输出后的显示形式。

补充：1.主键：是唯一标识一条记录，不能有重复的，不允许为空，用来保证数据完整性

　　   2.外键：是另一表的主键, 外键可以有重复的, 可以是空值，用来和其他表建立联系用的。所以说，如果谈到了外键，一定是至少涉及到两张表。例如下面这两张表：

 设定条件向指定表中添加记录：

1 2 3 4 5

obj = Session.query(user).filter(user.name=='ee').all()[0]  #设定条件 print(obj.addresses)   obj.addresses = [Address(email_address="ertttt"), #向addresses表中添加2列。                 Address(email_address="dddd")]

结果：

多外键关联

在Customer表有2个字段都关联了Address表

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

class Customer(base):     __tablename__ = 'customer'     id = Column(Integer, primary_key=True)     name = Column(String)        billing_address_id = Column(Integer, ForeignKey("address.id"))      shipping_address_id = Column(Integer, ForeignKey("address.id"))  '''#创建的列billing_address_id、shipping_address_id都作为外键关联address表中id列'''     billing_address = relationship("Address")     shipping_address = relationship("Address")#创建两个关联项    class Address(base):     __tablename__ = 'address'     id = Column(Integer, primary_key=True)     street = Column(String)     city = Column(String)     state = Column(String)

如果报错：

sqlalchemy.exc.AmbiguousForeignKeysError: Could not determine join

condition between parent/child tables on relationship

Customer.billing_address - there are multiple foreign key

 

需要在

1 2	illing_address = relationship("Address", foreign_keys=[billing_address_id]) shipping_address = relationship("Address", foreign_keys=[shipping_address_id])

使pymysql分清哪个外键是对应哪个字段。

多对多关系

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

from sqlalchemy import Table, Column, Integer,String,DATE, ForeignKey from sqlalchemy.orm import relationship from sqlalchemy.ext.declarative import declarative_base from sqlalchemy import create_engine from sqlalchemy.orm import sessionmaker   engine=create_engine("mysql+pymysql://root:123456@localhost/ceshi",encoding='utf-8',echo=True) base = declarative_base()   book_m2m_author = Table('book_m2m_author', base.metadata,                         Column('book_id',Integer,ForeignKey('books.id')),                         Column('author_id',Integer,ForeignKey('authors.id')),                         )  #创建book_m2m_author表，关联另外两张表。   class Book(base):     __tablename__ = 'books'     id = Column(Integer,primary_key=True)     name = Column(String(64))     pub_date = Column(DATE)     authors = relationship('Author',secondary=book_m2m_author,backref='books')       def __repr__(self):         return self.name   class Author(base):     __tablename__ = 'authors'     id = Column(Integer, primary_key=True)     name = Column(String(32))       def __repr__(self):         return self.name base.metadata.create_all(engine) #创建表结构 Session_class=sessionmaker(bind=engine) #创建与数据库的会话，class,不是实例 Session=Session_class() b1 = Book(name="跟A学Python") b2 = Book(name="跟A学linux") b3 = Book(name="跟A学java") b4 = Book(name="跟C学开发")    a1 = Author(name="A") a2 = Author(name="B") a3 = Author(name="C")    b1.authors = [a1,a2]  #建立关系 b2.authors = [a1,a2,a3] Session.add_all([b1,b2,b3,b4,a1,a2,a3]) Session.commit()

结果：

 

 用orm查一下数据

1 2 3 4 5

book_obj = Session.query(Book).filter_by(name="跟A学Python").first() print(book_obj.name, book_obj.authors)#这里book_obj.authors只输出name,因为定义类Author时在__repr__(self):定义了返回值    author_obj =Session.query(Author).filter_by(name="A").first() print(author_obj.name , author_obj.books)

结果：

多对多删除

1.通过书删除作者,删除的是关系。

1 2 3

author_obj =Session.query(Author).filter_by(name="C").first() book_obj = Session.query(Book).filter_by(name="跟A学linux").first() book_obj.authors.remove(author_obj) #通过指定书里删除作者，删除的是关系，作者不受影响。

2.删除作者的同时也删除关系。

1 2	author_obj =Session.query(Author).filter_by(name="A").first() Session.delete(author_obj) #delete删除作者A，关系也会删除掉。

结果：

books表

 

1

authors表

book_m2m_author表