第二百八十九節，MySQL數據庫-ORM之sqlalchemy模塊操作數據庫

本文轉載自查看原文 2017-06-19 16:58 1250 Python

MySQL數據庫-ORM之sqlalchemy模塊操作數據庫

sqlalchemy第三方模塊

sqlalchemy
sqlalchemy是Python編程語言下的一款ORM框架，該框架建立在數據庫API之上，使用關系對象映射進行數據庫操作，簡言之便是：將對象轉換成SQL，然后使用數據API執行SQL並獲取執行結果。

SQLAlchemy本身無法操作數據庫，其必須以pymsql等第三方插件，Dialect用於和數據API進行交流，根據配置文件的不同調用不同的數據庫API，從而實現對數據庫的操作，

如：下面是不同的第三方插件數據庫鏈接插件pymysql是我們前面說過的

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...]

一、底層處理

使用 Engine/ConnectionPooling/Dialect 進行數據庫操作，Engine使用ConnectionPooling連接數據庫，然后再通過Dialect執行SQL語句。

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from sqlalchemy import create_engine
 
 
engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/t1", max_overflow=5)
 
# 執行SQL
# cur = engine.execute(
#     "INSERT INTO hosts (host, color_id) VALUES ('1.1.1.22', 3)"
# )
 
# 新插入行自增ID
# cur.lastrowid
 
# 執行SQL
# cur = engine.execute(
#     "INSERT INTO hosts (host, color_id) VALUES(%s, %s)",[('1.1.1.22', 3),('1.1.1.221', 3),]
# )
 
 
# 執行SQL
# cur = engine.execute(
#     "INSERT INTO hosts (host, color_id) VALUES (%(host)s, %(color_id)s)",
#     host='1.1.1.99', color_id=3
# )
 
# 執行SQL
# cur = engine.execute('select * from hosts')
# 獲取第一行數據
# cur.fetchone()
# 獲取第n行數據
# cur.fetchmany(3)
# 獲取所有數據
# cur.fetchall()

注意：以上都是底層實現，因為我們操作的是上層，所以底層了解一下即可

ORM:

ORM框架的作用就是把數據庫表的一行記錄與一個對象互相做自動轉換。正確使用ORM的前提是了解關系數據庫的原理。 ORM就是把數據庫表的行與相應的對象建立關聯，互相轉換。由於關系數據庫的多個表還可以用外鍵實現一對多、多對多等關聯，相應地， ORM框架也可以提供兩個對象之間的一對多、多對多等功能。

1、創建表

create_engine方法參數('使用數據庫+數據庫鏈接模塊://數據庫用戶名:密碼@ip地址:端口/要連接的數據庫名稱?charset=utf8',echo=True表示是否查看生成的sql語句,max_overflow=5)

max_overflow=5 表示最大連接數

declarative_base()創建一個SQLORM基類
Column()設置字段屬性
create_all()向數據庫創建指定表

創建表數據類型

整數型：TINYINT，SMALLINT，INT，BIGINT
Boolean()對應TINYINT
Integer()對應INT
SMALLINT()對應SMALLINT
BIGINT()對應BIGINT

浮點型：FLOAT，DOUBLE，DECIMAL(M,D)
DECIMAL()對應DECIMAL
Float()對應FLOAT
REAL()對應DOUBLE

字符型：CHAR，VARCHAR
String(40)對應VARCHAR
CHAR()對應CHAR

日期型：DATETIME，DATE，TIMESTAMP
DATETIME()對應DATETIME
DATE()對應DATE
TIMESTAMP()對應TIMESTAMP

備注型：TINYTEXT，TEXT，
Text()對應TEXT
UnicodeText(10)對應TINYTEXT

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import sqlalchemy
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


#create_engine方法，創建數據庫鏈接，
#create_engine方法參數('使用數據庫+數據庫鏈接模塊://數據庫用戶名:密碼@ip地址:端口/要連接的數據庫名稱',echo=True表示是否查看生成的sql語句)
engine = create_engine('mysql+pymysql://root:279819@127.0.0.1:3306/cshi', echo=True)

Base = declarative_base()   #創建一個SQLORM基類

class User(Base):           #自定義類，功能生成一張表，參數必須繼承SQLORM基類
    __tablename__ = 'users' #表名稱

    #創建字段
    #字段名稱 = Column(字段屬性...)
    id = Column(Integer, primary_key=True, autoincrement=True) name = Column(String(40)) fullname = Column(String(40)) password = Column(String(40))


Base.metadata.create_all(engine) #向數據庫創建指定表

創建一張表，並且創建索引

primary_key=True給當前字段創建主鍵索引
index=True給當前字段創建普通索引
unique=True給當前字段創建唯一索引

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import sqlalchemy
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


#create_engine方法，創建數據庫鏈接，
#create_engine方法參數('使用數據庫+數據庫鏈接模塊://數據庫用戶名:密碼@ip地址:端口/要連接的數據庫名稱',echo=True表示是否查看生成的sql語句)
engine = create_engine('mysql+pymysql://root:279819@127.0.0.1:3306/cshi', echo=True)

Base = declarative_base()   #創建一個SQLORM基類

class User(Base):           #自定義類，功能生成一張表，參數必須繼承SQLORM基類
    __tablename__ = 'users' #表名稱

    #創建字段
    #字段名稱 = Column(字段屬性...)
    id = Column(Integer, primary_key=True, autoincrement=True)  #primary_key=True給當前字段創建主鍵索引
    name = Column(String(40),index=True)        #index=True給當前字段創建普通索引
    fullname = Column(String(40),unique=True)   #unique=True給當前字段創建唯一索引
    password = Column(String(40))


Base.metadata.create_all(engine) #向數據庫創建指定表

創建一張表，並且創建組合索引

UniqueConstraint('字段','字段',name='索引名稱')創建唯一組合索引
Index('索引名稱','字段','字段')創建普通組合索引

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import sqlalchemy
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


#create_engine方法，創建數據庫鏈接，
#create_engine方法參數('使用數據庫+數據庫鏈接模塊://數據庫用戶名:密碼@ip地址:端口/要連接的數據庫名稱',echo=True表示是否查看生成的sql語句)
engine = create_engine('mysql+pymysql://root:279819@127.0.0.1:3306/cshi', echo=True)

Base = declarative_base()   #創建一個SQLORM基類

class User(Base):           #自定義類，功能生成一張表，參數必須繼承SQLORM基類
    __tablename__ = 'users' #表名稱

    #創建字段
    #字段名稱 = Column(字段屬性...)
    id = Column(Integer, primary_key=True, autoincrement=True)  #primary_key=True給當前字段創建主鍵索引
    name = Column(String(40))
    fullname = Column(String(40))
    password = Column(String(40))

    __table_args__ = ( UniqueConstraint('id', 'name', name='uix_id_name'),     #UniqueConstraint('字段','字段',name='索引名稱')創建唯一組合索引
        Index('ix_id_name', 'name', 'password'),                #Index('索引名稱','字段','字段')創建普通組合索引
 )


Base.metadata.create_all(engine)  #向數據庫創建指定表

創建兩張表，並且創建外鍵鏈表，一對多

ForeignKey("連接表名稱.連接表主鍵字段")外鍵鏈表一對多

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import sqlalchemy
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


#create_engine方法，創建數據庫鏈接，
#create_engine方法參數('使用數據庫+數據庫鏈接模塊://數據庫用戶名:密碼@ip地址:端口/要連接的數據庫名稱',echo=True表示是否查看生成的sql語句)
engine = create_engine('mysql+pymysql://root:279819@127.0.0.1:3306/cshi', echo=True)

Base = declarative_base()   #創建一個SQLORM基類


class Favor(Base):          #創建連接表，自定義類，功能生成一張表，參數必須繼承SQLORM基類
    __tablename__ = 'favor' #表名稱
    id = Column(Integer, primary_key=True, autoincrement=True)  #設置主鍵，自增
    caption = Column(String(50), default='red', unique=True)    #設置字段默認值，設置字段唯一索引


class User(Base):           #創建外鍵表，自定義類，功能生成一張表，參數必須繼承SQLORM基類
    __tablename__ = 'users' #表名稱

    #創建字段
    #字段名稱 = Column(字段屬性...)
    id = Column(Integer, primary_key=True, autoincrement=True)  #設置主鍵，自增
    name = Column(String(40)) password = Column(String(40)) fullname = Column(Integer,ForeignKey("favor.id"))           #ForeignKey("連接表名稱.連接表主鍵字段")外鍵鏈表一對多


Base.metadata.create_all(engine)  #向數據庫創建指定表

創建三張表，並且創建外鍵鏈表，多對多

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import sqlalchemy
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


#create_engine方法，創建數據庫鏈接，
#create_engine方法參數('使用數據庫+數據庫鏈接模塊://數據庫用戶名:密碼@ip地址:端口/要連接的數據庫名稱',echo=True表示是否查看生成的sql語句)
engine = create_engine('mysql+pymysql://root:279819@127.0.0.1:3306/cshi', echo=True)

Base = declarative_base()   #創建一個SQLORM基類


# 多對多
class Group(Base):      #創建連接表
    __tablename__ = 'group' #表名稱
    id = Column(Integer, primary_key=True, autoincrement=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'))        #外鍵server表的主鍵
    group_id = Column(Integer, ForeignKey('group.id'))          #外鍵group表的主鍵


Base.metadata.create_all(engine)  #向數據庫創建指定表

創建表字段屬性【重點】

primary_key=True主鍵索引
autoincrement=True自增字段
index=True給當前字段創建普通索引
unique=True給當前字段創建唯一索引
UniqueConstraint('字段','字段',name='索引名稱')創建唯一組合索引
Index('索引名稱','字段','字段')創建普通組合索引
default='abc'設置字段默認值，不怎么可靠
ForeignKey("連接表名稱.連接表主鍵字段")設置外鍵鏈表
nullable=False類容不能為空
注：設置外檢的另一種方式 ForeignKeyConstraint(['other_id'], ['othertable.other_id'])

2、刪除表

drop_all(SQLORM基類)向數據庫刪除指定表

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import sqlalchemy
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


#create_engine方法，創建數據庫鏈接，
#create_engine方法參數('使用數據庫+數據庫鏈接模塊://數據庫用戶名:密碼@ip地址:端口/要連接的數據庫名稱',echo=True表示是否查看生成的sql語句)
engine = create_engine('mysql+pymysql://root:279819@127.0.0.1:3306/cshi', echo=True)

Base = declarative_base()   #創建一個SQLORM基類

class User(Base):           #自定義類，功能生成一張表，參數必須繼承SQLORM基類
    __tablename__ = 'jif' #表名稱

    #創建字段
    #字段名稱 = Column(字段屬性...)
    id = Column(Integer, primary_key=True, autoincrement=True)
    name = Column(String(40))
    fullname = Column(String(40))
    password = Column(String(40))


#Base.metadata.create_all(engine)  #向數據庫創建指定表
Base.metadata.drop_all(engine)  #向數據庫刪除指定表

3、向表添加一條數據

sessionmaker()創建sessionmaker類
add()將創建的數據添加到sessionmaker類
commit()向數據庫提交寫入添加到sessionmaker類的數據，注意:只要是向數據庫添加或者刪除都需要commit()提交

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import sqlalchemy
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


#create_engine方法，創建數據庫鏈接，
#create_engine方法參數('使用數據庫+數據庫鏈接模塊://數據庫用戶名:密碼@ip地址:端口/要連接的數據庫名稱',echo=True表示是否查看生成的sql語句)
engine = create_engine('mysql+pymysql://root:279819@127.0.0.1:3306/cshi', echo=True)

Base = declarative_base()   #創建一個SQLORM基類

class User(Base):           #自定義類，功能生成一張表，參數必須繼承SQLORM基類
    __tablename__ = 'users' #表名稱

    #創建字段
    #字段名稱 = Column(字段屬性...)
    id = Column(Integer, primary_key=True, autoincrement=True)
    name = Column(String(40))
    fullname = Column(String(40))
    password = Column(String(40))

Base.metadata.create_all(engine)  #向數據庫創建指定表，如果表存在忽略創建
 ed_user = User(name='xiaoyu', fullname='Xiaoyu Liu', password='123') #執行自定義類，創建一行數據

#創建sessionmaker類，sessionmaker(bind=數據庫鏈接變量)
MySession = sessionmaker(bind=engine) session = MySession()   #執行sessionmaker類
session.add(ed_user)    #執行sessionmaker類下的add方法，add(創建數據變量)，將創建的數據添加到sessionmaker類
 session.commit() #向數據庫提交數據

4、向表添加多條數據

add_all()添加多條數據，參數是一個列表，列表元素是自定義類創建數據

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import sqlalchemy
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


#create_engine方法，創建數據庫鏈接，
#create_engine方法參數('使用數據庫+數據庫鏈接模塊://數據庫用戶名:密碼@ip地址:端口/要連接的數據庫名稱',echo=True表示是否查看生成的sql語句)
engine = create_engine('mysql+pymysql://root:279819@127.0.0.1:3306/cshi', echo=True)

Base = declarative_base()   #創建一個SQLORM基類

class User(Base):           #自定義類，功能生成一張表，參數必須繼承SQLORM基類
    __tablename__ = 'users' #表名稱

    #創建字段
    #字段名稱 = Column(字段屬性...)
    id = Column(Integer, primary_key=True, autoincrement=True)
    name = Column(String(40))
    fullname = Column(String(40))
    password = Column(String(40))

Base.metadata.create_all(engine)  #向數據庫創建指定表，如果表存在忽略創建



#創建sessionmaker類，sessionmaker(bind=數據庫鏈接變量)
MySession = sessionmaker(bind=engine)
session = MySession()   #執行sessionmaker類
 session.add_all([ User(name='alex', fullname='Alex Li', password='456'), User(name='alex', fullname='Alex old', password='789'), User(name='peiqi', fullname='Peiqi Wu', password='sxsxsx')]) 

session.commit() #向數據庫提交數據

向外鍵表添加數據並且設置外鍵值

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import sqlalchemy
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


#create_engine方法，創建數據庫鏈接，
#create_engine方法參數('使用數據庫+數據庫鏈接模塊://數據庫用戶名:密碼@ip地址:端口/要連接的數據庫名稱',echo=True表示是否查看生成的sql語句)
engine = create_engine('mysql+pymysql://root:279819@127.0.0.1:3306/cshi?charset=utf8')

Base = declarative_base()   #創建一個SQLORM基類

class Favor(Base):          #創建連接表，自定義類，功能生成一張表，參數必須繼承SQLORM基類
    __tablename__ = 'favor' #表名稱
    id = Column(Integer, primary_key=True, autoincrement=True)  #設置主鍵，自增
    caption = Column(String(50), default='red', unique=True)    #設置字段默認值，設置字段唯一索引

class User(Base):           #創建外鍵表，自定義類，功能生成一張表，參數必須繼承SQLORM基類
    __tablename__ = 'users' #表名稱

    #創建字段
    #字段名稱 = Column(字段屬性...)
    id = Column(Integer, primary_key=True, autoincrement=True)  #設置主鍵，自增
    name = Column(String(40))
    password = Column(String(40))
    fullname = Column(Integer,ForeignKey("favor.id"))           #ForeignKey("連接表名稱.連接表主鍵字段")外鍵鏈表一對多


Base.metadata.create_all(engine)  #向數據庫創建指定表

#創建sessionmaker類，sessionmaker(bind=數據庫鏈接變量)
MySession = sessionmaker(bind=engine)
session = MySession()   #執行sessionmaker類
 session.add_all([ User(name='林貴秀1',password='123456',fullname=1), #fullname=1添加數據設置外鍵字段值為連接表的主鍵id
    User(name='林貴秀2',password='123456',fullname=2), #fullname=1添加數據設置外鍵字段值為連接表的主鍵id
    User(name='林貴秀3',password='123456',fullname=3)  #fullname=1添加數據設置外鍵字段值為連接表的主鍵id
])


session.commit()        #向數據庫提交數據

5、刪除數據

delete()刪除指定表數據

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import sqlalchemy
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


#create_engine方法，創建數據庫鏈接，
#create_engine方法參數('使用數據庫+數據庫鏈接模塊://數據庫用戶名:密碼@ip地址:端口/要連接的數據庫名稱',echo=True表示是否查看生成的sql語句)
engine = create_engine('mysql+pymysql://root:279819@127.0.0.1:3306/cshi?charset=utf8')

Base = declarative_base()   #創建一個SQLORM基類

class Favor(Base):          #創建連接表，自定義類，功能生成一張表，參數必須繼承SQLORM基類
    __tablename__ = 'favor' #表名稱
    id = Column(Integer, primary_key=True, autoincrement=True)  #設置主鍵，自增
    caption = Column(String(50), default='red', unique=True)    #設置字段默認值，設置字段唯一索引

class User(Base):           #創建外鍵表，自定義類，功能生成一張表，參數必須繼承SQLORM基類
    __tablename__ = 'users' #表名稱

    #創建字段
    #字段名稱 = Column(字段屬性...)
    id = Column(Integer, primary_key=True, autoincrement=True)  #設置主鍵，自增
    name = Column(String(40))
    password = Column(String(40))
    fullname = Column(Integer,ForeignKey("favor.id"))           #ForeignKey("連接表名稱.連接表主鍵字段")外鍵鏈表一對多


Base.metadata.create_all(engine)  #向數據庫創建指定表

#創建sessionmaker類，sessionmaker(bind=數據庫鏈接變量)
MySession = sessionmaker(bind=engine)
session = MySession()   #執行sessionmaker類
 session.query(User).filter(User.id > 2).delete()  #刪除User類對應表的id大於2的數據


session.commit()        #向數據庫提交數據

6、修改數據

synchronize_session參數詳解
synchronize_session用於query在進行刪除或者修改數據操作時，對session的同步策略。

False - 不對session進行同步，直接進行刪除或者修改操作。
'fetch' - 在刪除或者修改數據操作之前，先發一條sql到數據庫獲取符合條件的記錄。
'evaluate' - 在刪除或者修改數據操作之前，用query中的條件直接對session的identity_map中的objects進行eval操作，將符合條件的記錄下來。

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import sqlalchemy
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


#create_engine方法，創建數據庫鏈接，
#create_engine方法參數('使用數據庫+數據庫鏈接模塊://數據庫用戶名:密碼@ip地址:端口/要連接的數據庫名稱',echo=True表示是否查看生成的sql語句)
engine = create_engine('mysql+pymysql://root:279819@127.0.0.1:3306/cshi?charset=utf8')

Base = declarative_base()   #創建一個SQLORM基類

class Favor(Base):          #創建連接表，自定義類，功能生成一張表，參數必須繼承SQLORM基類
    __tablename__ = 'favor' #表名稱
    id = Column(Integer, primary_key=True, autoincrement=True)  #設置主鍵，自增
    caption = Column(String(50), default='red', unique=True)    #設置字段默認值，設置字段唯一索引

class User(Base):           #創建外鍵表，自定義類，功能生成一張表，參數必須繼承SQLORM基類
    __tablename__ = 'users' #表名稱

    #創建字段
    #字段名稱 = Column(字段屬性...)
    id = Column(Integer, primary_key=True, autoincrement=True)  #設置主鍵，自增
    name = Column(String(40))
    password = Column(String(40))
    fullname = Column(Integer,ForeignKey("favor.id"))           #ForeignKey("連接表名稱.連接表主鍵字段")外鍵鏈表一對多
    shu = Column(Integer)


Base.metadata.create_all(engine)  #向數據庫創建指定表

#創建sessionmaker類，sessionmaker(bind=數據庫鏈接變量)
MySession = sessionmaker(bind=engine)
session = MySession()   #執行sessionmaker類
 session.query(User).filter(User.id == 2).update({"name":"099"})   #將User類對應的表里id等於2的數據，name字段的值修改為"099"
session.query(User).filter(User.id == 13).update({User.name: User.name + ",會員"}, synchronize_session=False) #在原有值后面追加值，不對session進行同步
session.query(User).filter(User.id == 19).update({"name": User.name + 1}, synchronize_session="evaluate")  #將指定字段的值加1，注意：字段必須為數字類型


session.commit()        #向數據庫提交數據

7、查詢

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import sqlalchemy
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

#create_engine方法，創建數據庫鏈接，
#create_engine方法參數('使用數據庫+數據庫鏈接模塊://數據庫用戶名:密碼@ip地址:端口/要連接的數據庫名稱',echo=True表示是否查看生成的sql語句)
engine = create_engine('mysql+pymysql://root:279819@127.0.0.1:3306/cshi')

Base = declarative_base()   #創建一個SQLORM基類

class User(Base):           #自定義類，功能生成一張表，參數必須繼承SQLORM基類
    __tablename__ = 'users' #表名稱

    #創建字段
    #字段名稱 = Column(字段屬性...)
    id = Column(Integer, primary_key=True, autoincrement=True)
    name = Column(String(40))
    fullname = Column(String(40))
    password = Column(String(40))


Base.metadata.create_all(engine)  #向數據庫創建指定表，如果表存在忽略創建

#創建sessionmaker類，sessionmaker(bind=數據庫鏈接變量)
MySession = sessionmaker(bind=engine)
session = MySession()   #執行sessionmaker類

print(session.query(User))          #session.query(操作表類名稱)，執行對指定表的查詢語句，得到表的所有字段集合
print(session.query(User).all())    #session.query(操作表類名稱).all(),得到列表形式表的所有字段集合對象
print(session.query(User.id, User.name, User.fullname, User.password).all())  #查詢指定表里的指定字段
print(session.query(User.id, User.name, User.fullname, User.password).order_by(User.id.desc()).all())  #查詢指定表里的指定字段，以id排序desc()降序，asc()升序
for row in session.query(User).order_by(User.id.desc()):  #以id排序desc()降序循環表里的內容
    print(row.id, row.name, row.fullname, row.password)

__repr__將表返回對象的數據轉化為解釋器可讀取的數據，默認返回的數據對象

class UserInfo(Base):                                               #定義一個類操作數據庫userinfo表
    __tablename__ = 'userinfo'

    nid = Column(Integer, primary_key=True, autoincrement=True)
    username = Column(String(32))
    password = Column(String(32))
    email = Column(String(32))
    ctime = Column(TIMESTAMP)

    __table_args__ = (                                              #創建索引
        Index('ix_user_pwd', 'username', 'password'),               #創建普通組合索引
        Index('ix_email_pwd', 'email', 'password'),                 #創建普通組合索引
    )

    def __repr__(self):                                             #將表返回的數據轉化為解釋器可讀取的數據，默認返回的數據對象
        return "%s-%s-%s" %(self.nid, self.username, self.email)    #轉換的字段字符串格式化

relationship()表關聯

class News(Base):                                                   #定義一個類操作數據庫news表

    __tablename__ = 'news'

    nid = Column(Integer, primary_key=True, autoincrement=True)
    user_info_id = Column(Integer, ForeignKey("userinfo.nid"))
    news_type_id = Column(Integer, ForeignKey("newstype.nid"))
    ctime = Column(TIMESTAMP)
    title = Column(String(32))
    url = Column(String(128))
    content = Column(String(150))
    favor_count = Column(Integer, default=0)

    comment_count = Column(Integer, default=0)

    ##與生成表結構無關，僅用於查詢方便
    f = relationship('Favor',backref='n')                           #表示在Favor建一個n字段關聯news表的id

查詢說明

query(要取的字段)查詢數據庫數據
all()顯示數據，返回列表加元祖，查詢多條數據使用
first()顯示數據，返回元祖，查詢一條數據使用
filter(多條件)過濾數據
filter_by(a=xxx)過濾數據，只能使用條件等於
from_statement(sql語句)過濾數據
order_by(排序字段.desc())排序，desc()降序，asc()升序

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import sqlalchemy
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index,text
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy import create_engine


#create_engine方法，創建數據庫鏈接，
#create_engine方法參數('使用數據庫+數據庫鏈接模塊://數據庫用戶名:密碼@ip地址:端口/要連接的數據庫名稱',echo=True表示是否查看生成的sql語句)
engine = create_engine('mysql+pymysql://root:279819@127.0.0.1:3306/cshi?charset=utf8',echo=True)

Base = declarative_base()   #創建一個SQLORM基類

class Favor(Base):          #創建連接表，自定義類，功能生成一張表，參數必須繼承SQLORM基類
    __tablename__ = 'favor' #表名稱
    id = Column(Integer, primary_key=True, autoincrement=True)  #設置主鍵，自增
    caption = Column(String(50), default='red', unique=True)    #設置字段默認值，設置字段唯一索引

class User(Base):           #創建外鍵表，自定義類，功能生成一張表，參數必須繼承SQLORM基類
    __tablename__ = 'users' #表名稱

    #創建字段
    #字段名稱 = Column(字段屬性...)
    id = Column(Integer, primary_key=True, autoincrement=True)  #設置主鍵，自增
    name = Column(String(40))
    password = Column(String(40))
    fullname = Column(Integer,ForeignKey("favor.id"))           #ForeignKey("連接表名稱.連接表主鍵字段")外鍵鏈表一對多


Base.metadata.create_all(engine)  #向數據庫創建指定表

#創建sessionmaker類，sessionmaker(bind=數據庫鏈接變量)
MySession = sessionmaker(bind=engine)
session = MySession()   #執行sessionmaker類
 ret = session.query(User.id,User.name, User.password,User.fullname).all()  #指定表里的所有字段
print(ret) ret = session.query(User.id,User.name, User.password,User.fullname).filter_by(id = 13).all()  #查詢表里的id字段等於指定值的數據,返回列表加元祖
print(ret) ret = session.query(User.id,User.name, User.password,User.fullname).filter_by(id=15).first()  #查詢表里的id字段等於指定值的數據，返回元祖
print(ret) ret = session.query(User.id,User.name, User.password,User.fullname).filter(User.id > 15).order_by(User.id.desc()).all()  #查找表里id大於15的數據，以id排序desc()降序
print(ret) ret = session.query(User.id,User.name, User.password,User.fullname).from_statement(text("SELECT * FROM users where name = '林貴秀2'")).all() #查詢表里ame = '林貴秀2'的數據
print(ret)

查詢條件

between(1, 16)之間
in_([1,3,4])里為1,3,4的
~取反，非的意思

from sqlalchemy import and_, or_ #注意：在條件里如果要使用and_(並且)，or_(或者),必須先引入這兩個方法

and_(並且)，
or_(或者)

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import sqlalchemy
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index,text
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy import create_engine


#create_engine方法，創建數據庫鏈接，
#create_engine方法參數('使用數據庫+數據庫鏈接模塊://數據庫用戶名:密碼@ip地址:端口/要連接的數據庫名稱',echo=True表示是否查看生成的sql語句)
engine = create_engine('mysql+pymysql://root:279819@127.0.0.1:3306/cshi?charset=utf8')

Base = declarative_base()   #創建一個SQLORM基類

class Favor(Base):          #創建連接表，自定義類，功能生成一張表，參數必須繼承SQLORM基類
    __tablename__ = 'favor' #表名稱
    id = Column(Integer, primary_key=True, autoincrement=True)  #設置主鍵，自增
    caption = Column(String(50), default='red', unique=True)    #設置字段默認值，設置字段唯一索引

class User(Base):           #創建外鍵表，自定義類，功能生成一張表，參數必須繼承SQLORM基類
    __tablename__ = 'users' #表名稱

    #創建字段
    #字段名稱 = Column(字段屬性...)
    id = Column(Integer, primary_key=True, autoincrement=True)  #設置主鍵，自增
    name = Column(String(40))
    password = Column(String(40))
    fullname = Column(Integer,ForeignKey("favor.id"))           #ForeignKey("連接表名稱.連接表主鍵字段")外鍵鏈表一對多


Base.metadata.create_all(engine)  #向數據庫創建指定表

#創建sessionmaker類，sessionmaker(bind=數據庫鏈接變量)
MySession = sessionmaker(bind=engine)
session = MySession()   #執行sessionmaker類
 ret = session.query(User.id, User.name, User.password, User.fullname).filter_by(name='林貴秀2').all()    #查詢表里name字段等於林貴秀2的數據
print(ret) ret = session.query(User.id, User.name, User.password, User.fullname).filter(User.id > 20, User.name == '林貴秀1').all()   #查詢表里id大於20，name等於林貴秀1的數據
print(ret) ret = session.query(User.id, User.name, User.password, User.fullname).filter(User.id.between(1, 16), User.name == '林貴秀1').all() #查詢表里id為1至16之間，name等於林貴秀1的數據
print(ret) ret = session.query(User.id, User.name, User.password, User.fullname).filter(User.id.in_([1,3,4])).all()    #查詢表里id為1,3,4的數據
print(ret) ret = session.query(User.id, User.name, User.password, User.fullname).filter(~User.id.in_([1,3,4])).all()   #查詢表里id不為1,3,4的數據
print(ret) ret = session.query(User.id, User.name, User.password, User.fullname).filter(User.id.in_(session.query(User.id).filter_by(name='林貴秀1'))).all()  #查找一張表里的id作為參數，再次查找數據
print(ret) from sqlalchemy import and_, or_ #注意：在條件里如果要使用and_(並且)，or_(或者),必須先引入這兩個方法
 ret = session.query(User.id, User.name, User.password, User.fullname).filter(and_(User.id > 3, User.name == '林貴秀1')).all()  #查找表里id大於3，並且name等於林貴秀1的數據
print(ret) ret = session.query(User.id, User.name, User.password, User.fullname).filter(or_(User.id < 3, User.name == '林貴秀1')).all()   #查找表里id小於3或者name等於林貴秀1的數據
print(ret) ret = session.query(User.id, User.name, User.password, User.fullname).filter( or_( User.id < 2,    #id小於2
        and_(User.name == '林貴秀1', User.id > 3), #name等於林貴秀1並且id大於3
        User.password != "" #password不為空
 )).all() print(ret)

查詢通配符

like()通配符
e% 開頭的所有（%表示多個字符串,表示查詢開頭為e后面可以是多個字符的數據）
%e% 表示查詢中間為e前后可以是多個字符的數據
e_ 開頭的所有（_表示一個字符,表示查詢開頭為e后面可以是一個字符的數據）
_e_ 表示查詢中間為e前后可以是一個字符的數據

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import sqlalchemy
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index,text
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy import create_engine


#create_engine方法，創建數據庫鏈接，
#create_engine方法參數('使用數據庫+數據庫鏈接模塊://數據庫用戶名:密碼@ip地址:端口/要連接的數據庫名稱',echo=True表示是否查看生成的sql語句)
engine = create_engine('mysql+pymysql://root:279819@127.0.0.1:3306/cshi?charset=utf8')

Base = declarative_base()   #創建一個SQLORM基類

class Favor(Base):          #創建連接表，自定義類，功能生成一張表，參數必須繼承SQLORM基類
    __tablename__ = 'favor' #表名稱
    id = Column(Integer, primary_key=True, autoincrement=True)  #設置主鍵，自增
    caption = Column(String(50), default='red', unique=True)    #設置字段默認值，設置字段唯一索引

class User(Base):           #創建外鍵表，自定義類，功能生成一張表，參數必須繼承SQLORM基類
    __tablename__ = 'users' #表名稱

    #創建字段
    #字段名稱 = Column(字段屬性...)
    id = Column(Integer, primary_key=True, autoincrement=True)  #設置主鍵，自增
    name = Column(String(40))
    password = Column(String(40))
    fullname = Column(Integer,ForeignKey("favor.id"))           #ForeignKey("連接表名稱.連接表主鍵字段")外鍵鏈表一對多


Base.metadata.create_all(engine)  #向數據庫創建指定表

#創建sessionmaker類，sessionmaker(bind=數據庫鏈接變量)
MySession = sessionmaker(bind=engine)
session = MySession()   #執行sessionmaker類

# 通配符
"""
e%  開頭的所有（%表示多個字符串,表示查詢開頭為e后面可以是多個字符的數據）
%e% 表示查詢中間為e前后可以是多個字符的數據
e_  e開頭的所有（_表示一個字符,表示查詢開頭為e后面可以是一個字符的數據）
_e_ 表示查詢中間為e前后可以是一個字符的數據
""" ret = session.query(User.id, User.name, User.password, User.fullname).filter(User.name.like('林貴秀%')).all()  #查找表里name字段開頭為林貴秀后面可以是多個字符的數據
print(ret) ret = session.query(User.id, User.name, User.password, User.fullname).filter(~User.name.like('林貴秀%')).all() #查找表里name字段開頭不為林貴秀后面可以是多個字符的數據
print(ret)

查詢限制

限制一般做分頁

[13:18]從第13行開始到18行結束，也就是取5行

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import sqlalchemy
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index,text
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy import create_engine


#create_engine方法，創建數據庫鏈接，
#create_engine方法參數('使用數據庫+數據庫鏈接模塊://數據庫用戶名:密碼@ip地址:端口/要連接的數據庫名稱',echo=True表示是否查看生成的sql語句)
engine = create_engine('mysql+pymysql://root:279819@127.0.0.1:3306/cshi?charset=utf8')

Base = declarative_base()   #創建一個SQLORM基類

class Favor(Base):          #創建連接表，自定義類，功能生成一張表，參數必須繼承SQLORM基類
    __tablename__ = 'favor' #表名稱
    id = Column(Integer, primary_key=True, autoincrement=True)  #設置主鍵，自增
    caption = Column(String(50), default='red', unique=True)    #設置字段默認值，設置字段唯一索引

class User(Base):           #創建外鍵表，自定義類，功能生成一張表，參數必須繼承SQLORM基類
    __tablename__ = 'users' #表名稱

    #創建字段
    #字段名稱 = Column(字段屬性...)
    id = Column(Integer, primary_key=True, autoincrement=True)  #設置主鍵，自增
    name = Column(String(40))
    password = Column(String(40))
    fullname = Column(Integer,ForeignKey("favor.id"))           #ForeignKey("連接表名稱.連接表主鍵字段")外鍵鏈表一對多


Base.metadata.create_all(engine)  #向數據庫創建指定表

#創建sessionmaker類，sessionmaker(bind=數據庫鏈接變量)
MySession = sessionmaker(bind=engine)
session = MySession()   #執行sessionmaker類

# 限制
ret = session.query(User.id, User.name, User.password, User.fullname)[13:18]    #從第13行開始到18行結束，也就是取5行
print(ret)

查詢排序

一般默認是從第一列id排序的

order_by(排序字段.asc())排序,desc()降序，asc()升序

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import sqlalchemy
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index,text
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy import create_engine


#create_engine方法，創建數據庫鏈接，
#create_engine方法參數('使用數據庫+數據庫鏈接模塊://數據庫用戶名:密碼@ip地址:端口/要連接的數據庫名稱',echo=True表示是否查看生成的sql語句)
engine = create_engine('mysql+pymysql://root:279819@127.0.0.1:3306/cshi?charset=utf8')

Base = declarative_base()   #創建一個SQLORM基類

class Favor(Base):          #創建連接表，自定義類，功能生成一張表，參數必須繼承SQLORM基類
    __tablename__ = 'favor' #表名稱
    id = Column(Integer, primary_key=True, autoincrement=True)  #設置主鍵，自增
    caption = Column(String(50), default='red', unique=True)    #設置字段默認值，設置字段唯一索引

class User(Base):           #創建外鍵表，自定義類，功能生成一張表，參數必須繼承SQLORM基類
    __tablename__ = 'users' #表名稱

    #創建字段
    #字段名稱 = Column(字段屬性...)
    id = Column(Integer, primary_key=True, autoincrement=True)  #設置主鍵，自增
    name = Column(String(40))
    password = Column(String(40))
    fullname = Column(Integer,ForeignKey("favor.id"))           #ForeignKey("連接表名稱.連接表主鍵字段")外鍵鏈表一對多


Base.metadata.create_all(engine)  #向數據庫創建指定表

#創建sessionmaker類，sessionmaker(bind=數據庫鏈接變量)
MySession = sessionmaker(bind=engine)
session = MySession()   #執行sessionmaker類

# 排序
ret = session.query(User.id, User.name, User.password, User.fullname).order_by(User.id.desc()).all()    #根據 “列” 從大到小排列
print(ret) ret = session.query(User.id, User.name, User.password, User.fullname).order_by(User.id.asc()).all()     #根據 “列” 從小到大排列
print(ret) ret = session.query(User.id, User.name, User.password, User.fullname).order_by(User.id.desc(), User.name.asc()).all()   #根據 “列1” 從大到小排列，如果排序列1數據有相同，則按列2從小到大排序
print(ret)

查詢分組

分組一般就是一個分組列記錄每條數據所屬什么類型如：普通會員、超級會員、黃金會員

注意：group by 必須在where之后，order by之前

from sqlalchemy.sql import func 注意：分組必須sqlalchemy.sql模塊里的func方法
group_by(分組字段)分組
func.count()統計所屬當前分組的數據列數
func.max()顯示當前組里指定列最大的數據
func.min()顯示當前組里指定列最小的數據
func.sum()顯示當前組指定列相加的和
func.avg()顯示當前組指定列的平均數
having(條件)帥選統計

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import sqlalchemy
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index,text
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy import create_engine


#create_engine方法，創建數據庫鏈接，
#create_engine方法參數('使用數據庫+數據庫鏈接模塊://數據庫用戶名:密碼@ip地址:端口/要連接的數據庫名稱',echo=True表示是否查看生成的sql語句)
engine = create_engine('mysql+pymysql://root:279819@127.0.0.1:3306/cshi?charset=utf8')

Base = declarative_base()   #創建一個SQLORM基類

class Favor(Base):          #創建連接表，自定義類，功能生成一張表，參數必須繼承SQLORM基類
    __tablename__ = 'favor' #表名稱
    id = Column(Integer, primary_key=True, autoincrement=True)  #設置主鍵，自增
    caption = Column(String(50), default='red', unique=True)    #設置字段默認值，設置字段唯一索引

class User(Base):           #創建外鍵表，自定義類，功能生成一張表，參數必須繼承SQLORM基類
    __tablename__ = 'users' #表名稱

    #創建字段
    #字段名稱 = Column(字段屬性...)
    id = Column(Integer, primary_key=True, autoincrement=True)  #設置主鍵，自增
    name = Column(String(40))
    password = Column(String(40))
    fullname = Column(Integer,ForeignKey("favor.id"))           #ForeignKey("連接表名稱.連接表主鍵字段")外鍵鏈表一對多
    fzu = Column(String(40))


Base.metadata.create_all(engine)  #向數據庫創建指定表

#創建sessionmaker類，sessionmaker(bind=數據庫鏈接變量)
MySession = sessionmaker(bind=engine)
session = MySession()   #執行sessionmaker類

# 分組
from sqlalchemy.sql import func ret = session.query(User.fzu).group_by(User.fzu).all()  #查看分組類容
print(ret) #查看分組所有統計信息
ret = session.query( User.fzu, #顯示當前分組
    func.count(User.fzu),   #統計所屬當前分組的數據,統計當前分組的列數
    func.max(User.id),      #顯示當前組里指定列最大的數據
    func.min(User.id),      #顯示當前組里指定列最小的數據
    func.sum(User.id),      #顯示當前組指定列相加的和
    func.avg(User.id)       #顯示當前組指定列的平均數
).group_by(User.fzu).all()  #查看分組所有統計信息
print(ret) #查看分組指定統計值大於3的信息
ret = session.query( User.fzu, #顯示當前分組
    func.count(User.fzu),   #統計所屬當前分組的數據,統計當前分組的列數
    func.max(User.id),      #顯示當前組里指定列最大的數據
    func.min(User.id),      #顯示當前組里指定列最小的數據
    func.sum(User.id),      #顯示當前組指定列相加的和
    func.avg(User.id)       #顯示當前組指定列的平均數
).group_by(User.fzu).having(func.min(User.id) > 3).all()    #查看分組指定統計值大於3的信息
print(ret)

外鍵鏈表查詢

外鍵鏈表數據類型必須一致
a表里創建外鍵連接b表的主鍵，首先檢查a表里要設置外鍵的字段、和b表里的主鍵字段數據類型是否一致，兩者數據類型必須一致，不然無法建立索引【重點】

外鍵鏈表約束
a表和b表鏈表后，兩表之間建立了鏈表關系，a表受b表約束，也就是當a表添加或者修改一條數據時、這條數據的外鍵字段值如果是b表主鍵字段不存在的，將無法添加，會報錯【重點】

外鍵連表查詢
query(外鍵表, 連接表).filter(外鍵表.外鍵字段 == 連接表.主鍵字段)

join()外鍵連表查詢【推薦】
query(外鍵表, 連接表).join(連接表)

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import sqlalchemy
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index,text
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy import create_engine


#create_engine方法，創建數據庫鏈接，
#create_engine方法參數('使用數據庫+數據庫鏈接模塊://數據庫用戶名:密碼@ip地址:端口/要連接的數據庫名稱',echo=True表示是否查看生成的sql語句)
engine = create_engine('mysql+pymysql://root:279819@127.0.0.1:3306/cshi?charset=utf8',echo=True)

Base = declarative_base()   #創建一個SQLORM基類

class Favor(Base):          #創建連接表，自定義類，功能生成一張表，參數必須繼承SQLORM基類
    __tablename__ = 'favor' #表名稱
    id = Column(Integer, primary_key=True, autoincrement=True)  #設置主鍵，自增
    caption = Column(String(50), default='red', unique=True)    #設置字段默認值，設置字段唯一索引

class User(Base):           #創建外鍵表，自定義類，功能生成一張表，參數必須繼承SQLORM基類
    __tablename__ = 'users' #表名稱

    #創建字段
    #字段名稱 = Column(字段屬性...)
    id = Column(Integer, primary_key=True, autoincrement=True)  #設置主鍵，自增
    name = Column(String(40))
    password = Column(String(40))
    fullname = Column(Integer,ForeignKey("favor.id"))           #ForeignKey("連接表名稱.連接表主鍵字段")外鍵鏈表一對多
    fzu = Column(String(40))


Base.metadata.create_all(engine)  #向數據庫創建指定表

#創建sessionmaker類，sessionmaker(bind=數據庫鏈接變量)
MySession = sessionmaker(bind=engine)
session = MySession()   #執行sessionmaker類

# 外鍵連表查詢
# query(外鍵表, 連接表).filter(外鍵表.外鍵字段 == 連接表.主鍵字段)，
ret = session.query(User.id, User.name, User.password, User.fullname, Favor.id, Favor.caption).filter(User.fullname == Favor.id).all() print(ret)  #查看外鍵表和連接表組合后的信息

# join()外鍵連表查詢
# query(外鍵表, 連接表).join(連接表)，只顯示有關聯的數據[推薦]
ret = session.query(User.id, User.name, User.password, User.fullname,Favor.id, Favor.caption).join(Favor).all() print(ret)    #查看join()外鍵連表后的信息

查詢組合

組合就是將兩張表數據顯示出來，注意兩張表顯示的列數量要是一樣的
union()組合表，對兩個結果集進行並集操作，不包括重復行，同時進行默認規則的排序；
union_all()組合表，對兩個結果集進行並集操作，包括重復行，不進行排序；

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import sqlalchemy
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index,text
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy import create_engine


#create_engine方法，創建數據庫鏈接，
#create_engine方法參數('使用數據庫+數據庫鏈接模塊://數據庫用戶名:密碼@ip地址:端口/要連接的數據庫名稱',echo=True表示是否查看生成的sql語句)
engine = create_engine('mysql+pymysql://root:279819@127.0.0.1:3306/cshi?charset=utf8',echo=True)

Base = declarative_base()   #創建一個SQLORM基類

class Favor(Base):          #創建連接表，自定義類，功能生成一張表，參數必須繼承SQLORM基類
    __tablename__ = 'favor' #表名稱
    id = Column(Integer, primary_key=True, autoincrement=True)  #設置主鍵，自增
    caption = Column(String(50), default='red', unique=True)    #設置字段默認值，設置字段唯一索引

class User(Base):           #創建外鍵表，自定義類，功能生成一張表，參數必須繼承SQLORM基類
    __tablename__ = 'users' #表名稱

    #創建字段
    #字段名稱 = Column(字段屬性...)
    id = Column(Integer, primary_key=True, autoincrement=True)  #設置主鍵，自增
    name = Column(String(40))
    password = Column(String(40))
    fullname = Column(Integer,ForeignKey("favor.id"))           #ForeignKey("連接表名稱.連接表主鍵字段")外鍵鏈表一對多
    fzu = Column(String(40))


Base.metadata.create_all(engine)  #向數據庫創建指定表

#創建sessionmaker類，sessionmaker(bind=數據庫鏈接變量)
MySession = sessionmaker(bind=engine)
session = MySession()   #執行sessionmaker類

# 組合
q1 = session.query(User.id, User.name).filter(User.id > 1) q2 = session.query(Favor.id, Favor.caption).filter(Favor.id > 1) ret = q1.union(q2).all() print(ret)  #將表1和表2組合后查看
 q1 = session.query(User.id, User.name).filter(User.id > 1) q2 = session.query(Favor.id, Favor.caption).filter(Favor.id > 1) ret = q1.union_all(q2).all() print(ret)  #將表1里id大於1的數據和，表2里id大於1的數據組合查看

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 第二百八十七節，MySQL數據庫-條件語句、循環語句、動態執行SQL語句 SQLAlchemy 操作數據庫 04：sqlalchemy操作數據庫 pandas+sqlAlchemy操作數據庫 Laravel使用Eloquent ORM操作數據庫 laravel使用ORM操作數據庫 django_ORM操作數據庫 Python操作數據庫及hashlib模塊 pandas操作數據庫 mongoose操作數據庫