pymysql-sqlalchemy-orm

時間  2019-11-26
標籤 pymysql sqlalchemy orm 欄目 MySQL 简体版
原文   原文鏈接

sqlalchemy示例代碼python

多對多外鍵mysql

場景：一個做者映射多個書籍，一個書籍有多個做者

做者表：
id name email   sex
1  Alex alex@..  M
2  Rail rail@..  W

書籍表：
id name
1  book1
2  book2

做者書籍映射關係表：
id  book_id  anthor_id
1   1           1
2   1           2
3   2           1
【Alex同時參與了兩本書的創做】
【book1 有兩個做者參與創做】
多對多例子說明 
#!/usr/bin/env python
# Author:zhangmingda
''''''
from sqlalchemy import create_engine,ForeignKey,DATE,Table
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String
from sqlalchemy.orm import relationship,sessionmaker
engine = create_engine("mysql+pymysql://zhangmingda:Wyf@1314@120.92.133.227/oldboy_db?charset=utf8",encoding='utf8',echo=False)
'''說明：engine 若是想寫入中文，在庫名後面加入?charset=utf8 encoding=utf-8 不起做用'''
'''生成基類'''
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'))
)

class Book(Base):
    __tablename__ = 'books' #表的名字
    __table_args__ = {'mysql_charset': 'utf8'}
    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'
    __table_args__ = {'mysql_charset': 'utf8'} #建立表的字符編碼設置
    id = Column(Integer,primary_key=True)
    name = Column(String(32))
    # books = relationship('Book',secondary=book_m2m_author,backref='authors')#如何對應第三張表，做者表或書籍表有一個寫了便可
    def __repr__(self):
        return self.name

Base.metadata.create_all(engine)
多對多外鍵create_table 
#!/usr/bin/env python
# Author:zhangmingda
import orm_many_to_many_foreign_key as m2m
from sqlalchemy.orm import sessionmaker

SessionClass = sessionmaker(bind=m2m.engine)
session = SessionClass()
'''做者數據'''
au1 = m2m.Author(name='Alex')
au2 = m2m.Author(name='Rain')
au3 = m2m.Author(name='Jack')
'''書籍數據'''
b1 = m2m.Book(name='跟Alex學Python',pub_date ='2018-09-17' )
b2 = m2m.Book(name='跟Alex學裝逼',pub_date ='2018-09-20' )
b3 = m2m.Book(name='跟Alex學把妹',pub_date ='2018-09-22' )
b4 = m2m.Book(name='跟Alex學把妹',pub_date ='2018-09-22' )
'''映射關係'''
b1.authors = [au1,au2,au3]
b2.authors = [au1,au3]
b3.authors = [au2,au3]

# session.add_all([au1,au2,au3,b1,b2,b3])#建立數據
session.commit()

'''============查詢:經過書看做者都有誰/經過做者看都建立了啥書===================='''
b1 = session.query(m2m.Book).filter_by(name='跟Alex學Python').first()
print(b1,'的做者是：',b1.authors)

a1 = session.query(m2m.Author).filter_by(name='Alex').first()
print(a1,'創做的書籍有：',a1.books)

'''====刪除：多對多刪除數據時不用管book_m2m_author　， sqlalchemy會自動幫你把對應的數據刪除 經過書刪除做者'''
b3 = session.query(m2m.Book).filter_by(name='跟Alex學裝逼').first()
print(b3,'的做者有：',b3.authors)
print('刪除做者Jack')
jack = session.query(m2m.Author).filter_by(name='Jack').first()
b3.authors.remove(jack)
print(b3,'創做的書籍有：',b3.authors)
session.commit()#提交更改。
'''==============多對多增長數據==========='''
b3 = session.query(m2m.Book).filter_by(name='跟Alex學把妹').first()
print('增長以前，',b3.name,'做者有：',b3.authors)
author  = session.query(m2m.Author).filter_by(name='Alex').first() #找到做者
b3.authors.append(author) #向書籍中append做者
print('增長做者',author.name)
print(b3,'的做者有：',b3.authors)
session.commit()
'''增刪改查，第三張表會自動跟着修改。無需多管'''
多對多外鍵增刪改查

多對一外鍵sql

#!/usr/bin/env python
# Author:zhangmingda
'''一張表中有兩個字段同時外鍵到另一個表'''
from sqlalchemy import create_engine,ForeignKey,DATE
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String
from sqlalchemy.orm import relationship,sessionmaker
engine = create_engine("mysql+pymysql://zhangmingda:Wyf@1314@120.92.133.227/oldboy_db?charset=utf8",encoding='utf8',echo=False)
'''生成基類'''
Base = declarative_base()
class Customer(Base):
    '''顧客'''
    __tablename__ = 'customer' #要建立的表名
    __table_args__ = {'mysql_charset':'utf8'}
    id = Column(Integer,primary_key=True)
    name = Column(String(32),nullable=False)
    billing_address_id = Column(Integer,ForeignKey('addresses.id'))
    shipping_address_id = Column(Integer,ForeignKey('addresses.id'))
    '''下面的foregin_keys 指的是經過哪一個外鍵字段去找數據。'''
    billing_address = relationship("Addresses",foreign_keys=[billing_address_id])
    shipping_address = relationship("Addresses",foreign_keys=[shipping_address_id])

class Addresses(Base):
    __tablename__ = 'addresses'
    __table_args__ = {'mysql_charset': 'utf8'}
    id = Column(Integer,primary_key=True)
    street = Column(String(64))
    city = Column(String(64))
    state = Column(String(64))

    def __repr__(self):
        '''被關聯的數據正向查詢時，return內容做爲返回值'''
        return "Address is: state:%s city:%s street:%s " % (self.state,self.city,self.street)
# Base.metadata.create_all(engine)  # 建立表結構
多對一外鍵create_table 
#!/usr/bin/env python
# Author:zhangmingda
from day12.多對一外鍵到同一張表 import foreginkey_many_orm
from sqlalchemy.orm import sessionmaker
Session_class = sessionmaker(bind=foreginkey_many_orm.engine) #生成數據庫鏈接類(這裏的返回值是個類)
session = Session_class() #生成Session實例
'''爲addresses表準備數據'''
addr1 = foreginkey_many_orm.Addresses(street='Zhuxinzhuang', city="ChangPing", state="BJ")
addr2 = foreginkey_many_orm.Addresses(street='Wudaokou', city="Haidian", state="BJ")
addr3 = foreginkey_many_orm.Addresses(street='YanJiao', city="Langfang", state="HB")
# session.add_all([addr1,addr2,addr3]) #建立數據
'''爲Customer表準備人員數據'''
c1 = foreginkey_many_orm.Customer(name='Alex', billing_address=addr1, shipping_address=addr2)
c2 = foreginkey_many_orm.Customer(name='Rain', billing_address=addr3, shipping_address=addr3)
c3 = foreginkey_many_orm.Customer(name='K', billing_address_id=1, shipping_address_id=2)
c4 = foreginkey_many_orm.Customer(name='Jack', billing_address_id=3, shipping_address_id=3)
# session.add_all([c1,c2,c3,c4]) #c1,c2 和c3,c4兩種方式的寫法都行，實際應用可能爲前者#建立數據

obj = session.query(foreginkey_many_orm.Customer).filter_by(name='Jack').first()
print(obj.name,'billing_address:',obj.billing_address,'\n','shipping_address:',obj.shipping_address)
session.commit()
多對一外鍵表，建立數據/查詢

sqlalchemy 數據庫

#!/usr/bin/env python
# Author:zhangmingda
'''數據的增刪改查'''
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://zhangmingda:Wyf@1314@120.92.133.227/oldboy_db",encoding='utf-8',echo=False)
'''生成基類'''
Base = declarative_base()
'''子類'''
class sub_base(Base):
    __tablename__ = 'user_talbe' #要建立的表名
    id = Column(Integer,primary_key=True)
    username = Column(String(32))
    password = Column(String(64))
'''建立表'''
Base.metadata.create_all(engine) #建立表結構

'''插入數據之 建立session實例'''
Session_class = sessionmaker(bind=engine) #生成數據庫鏈接類(這裏的返回值是個類)
Session = Session_class() #生成Session實例
'''準備數據對象'''
data_obj = sub_base(username='Qjj',password='test14413432')#生成建立的數據對象
# Session.add(data_obj) #將數據寫入到鏈接的實例裏面
print(data_obj.username,data_obj.id) #還沒建立
Session.commit() #提交建立數據
# print(data_obj.username,data_obj.id)

'''查詢數據'''
users = Session.query(sub_base).filter_by(username='Qjj')
print(users,'type users',type(users)) #返回全部數據對象
for user in users:
    print(user.id,user.username,user.password)
user_one = Session.query(sub_base).filter_by(username='zhangmingda').first()
print(user_one.id,user_one.username,user_one.password)
'''修改數據'''
user_one.username = 'ZHANGMINGDA'
Session.commit()
'''回滾測試'''
my_user = Session.query(sub_base).filter_by(id=1).first()
my_user.username = 'alex'
new_user = sub_base(username='ALEX',password='12345')
Session.add(new_user)
print('回滾前',Session.query(sub_base).filter(sub_base.username.in_(['LAEX','alex'])).all())
Session.rollback()
print('回滾後',Session.query(sub_base).filter(sub_base.username.in_(['LAEX','alex'])).all())
Session.commit()
'''獲取全部數據(每一個數據做爲元組，多個數據組成元組爲元素的列表)'''
print(Session.query(sub_base.id,sub_base.username,sub_base.password).all())

'''多條件查詢'''
objs = Session.query(sub_base).filter(sub_base.id>0).filter(sub_base.id<7).all()
print('多條件查詢結果')
for obj in objs:
    print(obj.id,obj.username,obj.password)
'''統計個數'''
count = Session.query(sub_base).filter(sub_base.username.like('Zhangmingda')).count()
print('統計符合條件的個數：',count)
'''分組查詢'''
from sqlalchemy import func
print('分組查詢統計：',Session.query(sub_base.username,func.count(sub_base.username)).group_by(sub_base.username).all())
'''注意這裏query 裏面的結構：寫的是查詢出來的結果顯示順序，本例(sub_base.username,func.count(sub_base.username) 爲用戶名和統計的數字'''
'''刪除數據'''
obj_del = Session.query(sub_base).filter(sub_base.id>5).filter(sub_base.username=='Qjj').all()
for d_obj in obj_del:
    Session.delete(d_obj)
Session.commit()
單條數據增刪改查 
#!/usr/bin/env python
# Author:zhangmingda
'''外鍵兩張表的正反向查詢'''
from sqlalchemy import create_engine,ForeignKey,DATE
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String
from sqlalchemy.orm import relationship,sessionmaker
engine = create_engine("mysql+pymysql://zhangmingda:Wyf@1314@120.92.133.227/oldboy_db?charset=utf8",encoding='utf8',echo=False)
'''生成基類'''
Base = declarative_base()
class Students(Base):
    '''學生類'''
    __tablename__ = 'students' #要建立的表名
    __table_args__ = {'mysql_charset':'utf8'}
    id = Column(Integer,primary_key=True)
    name = Column(String(32),nullable=False)
    register_date = Column(DATE,nullable=False)
    def __repr__(self):
        return "<%s name:%s>"%(self.id,self.name)
class Students_Record(Base):
    __tablename__ = 'stu_record'
    __table_args__ = {'mysql_charset': 'utf8'}
    id = Column(Integer,primary_key=True)
    day = Column(Integer,nullable=False)
    status = Column(String(32),nullable=False)
    stu_id = Column(Integer,ForeignKey("students.id"))
    student = relationship('Students',backref = 'record')
    def __repr__(self):
        '''被關聯的數據正向查詢時，return內容做爲返回值'''
        return "record_id:%s %s: day:%s status:%s" % (self.id,self.student.name,self.day,self.status)
Base.metadata.create_all(engine)  # 建立表結構

Session_class = sessionmaker(bind=engine) #生成數據庫鏈接類(這裏的返回值是個類)
session = Session_class() #生成Session實例

stu1 = Students(name='Alex',register_date="2018-09-16")
stu2 = Students(name='Jack',register_date='2018-09-17')
stu3 = Students(name='Rain',register_date='2018-09-18')
stu4 = Students(name='Eric',register_date='2018-09-19')
stu5 = Students(name='Qjj',register_date='2018-09-10')
record1 = Students_Record(day=1,status='YES',stu_id=1)
record2 = Students_Record(day=2,status='YES',stu_id=1)
record3 = Students_Record(day=3,status='No',stu_id=1)
record4 = Students_Record(day=4,status='YES',stu_id=2)
record5 = Students_Record(day=1,status='YES',stu_id=3)
# session.add_all([record1,record2,record3,record4,record5])
session.commit()
s1 =  session.query(Students).first() #查詢符合條件的單條數據
print(s1)
print(s1.record)#經過外鍵關係反向調第二張表裏面和這個數據有關的全部數據，做爲列表返回
for record in s1.record:
    print(record)

record_status = session.query(Students_Record).filter_by(status='YES').all() #找全部沒上課的記錄，返回列表
for r in record_status: #循環列表，經過上課記錄的表沒上課的記錄反向找學生表裏面這我的是誰
    print('%s day %s 沒上課'% (r.student.name,r.day))

s2 =  session.query(Students).all() #查詢符合條件的全部數據
# print(s2)
# print(s2.record)#經過外鍵關係反向調第二張表裏面和這個數據有關的全部數據，做爲列表返回
for s in s2:
    for record in s.record:
        print(record)
外鍵兩張表的正反向查詢 
#!/usr/bin/env python
# Author:zhangmingda
import sqlalchemy
'''表的建立 查詢'''
from sqlalchemy import create_engine,ForeignKey
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String
from sqlalchemy.orm import relationship,sessionmaker
engine = create_engine("mysql+pymysql://zhangmingda:Wyf@1314@120.92.133.227/oldboy_db",encoding='utf-8',echo=False)
'''生成基類'''
Base = declarative_base()
class sub_base(Base):
    __tablename__ = 'user_talbe' #要建立的表名
    id = Column(Integer,primary_key=True)
    username = Column(String(32))
    password = Column(String(64))

class Address(Base):
    __tablename__ = 'addresses'
    id = Column(Integer,primary_key=True)
    email_address = Column(String(32),nullable=False)
    user_id = Column(Integer,ForeignKey('user_talbe.id'))

    user = relationship('sub_base',backref='addresses')
    def __repr__(self):
        '''被關聯的數據正向查詢時，return內容做爲返回值'''
        return "Address(email_address='%s')" % self.email_address

Base.metadata.create_all(engine)  # 建立表結構

Session_class = sessionmaker(bind=engine) #生成數據庫鏈接類(這裏的返回值是個類)
Session = Session_class() #生成Session實例
'''在user_talbe表中查詢addresses表中的數據'''
obj = Session.query(sub_base).first()
for address in obj.addresses:
    print(address)
'''反向查詢'''
add_obj = Session.query(Address).first()
print(add_obj.user.username)

'''連表查詢'''
# ret = Session.query(sub_base,Address).filter(sub_base.id == Address.id).all()
# ret = Session.query(sub_base).join(Address).all()
ret = Session.query(sub_base).join(Address,isouter=True).all()
# print(ret)
for obj in ret:
    # print(dir(obj))
    print(obj.addresses,obj.username,obj.password,obj.id)
連表查詢

 

 

pymysql  read wirte 查詢 & 建立數據session

#!/usr/bin/env python
# Author:zhangmingda

import pymysql
#讀取數據庫中的數據
conn = pymysql.connect(host='120.92.133.227',port=3306,user='zhangmingda',passwd='Wyf@1314',db='oldboy_db')
# cursor = conn.cursor() #默認獲取的每行數據爲元組，多個數據組成嵌套試元組
cursor = conn.cursor(cursor=pymysql.cursors.DictCursor) #每行數據做爲一個字典出現，多個數據字典組成列表
cursor.execute("select * from students")
# rown = cursor.fetchmany(3)#只獲取三條數據
rowall = cursor.fetchall()

# print('只獲取三條數據：',rown)
print('獲取所有數據',rowall)
for i in rowall:
    print(i)
conn.commit() #提交保存
cursor.close() #關閉光標
conn.close()#關閉鏈接
pymysql讀取數據 
#!/usr/bin/env python
# Author:zhangmingda

import pymysql
#向數據庫中寫入數據
conn = pymysql.connect(host='120.92.133.227',port=3306,user='zhangmingda',passwd='Wyf@1314',db='oldboy_db')
cursor = conn.cursor()
cursor.execute("delete from students where name='Zahangmiaochen' and 5< id <9;") #刪除符合條件的數據from表中
cursor.execute("update students set age = 1 where  id >= %s",(4,)) #更改原有數據
cursor.execute("insert into students (name,age,sex)values(%s,%s,%s)",('Zhangmiaochen',1,'girl'))#插入新數據
cursor.executemany("insert into students (name,age,sex)values(%s,%s,%s)",[('Zhangmiaochen',1,'girl'),('Gongzhu',1,'girl')])#插入多行新數據

conn.commit() #提交保存，不然數據庫不會更改生效
cursor.close()
conn.close()
print('自增最新ID',cursor.lastrowid)
pymysql建立數據
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程