2、MySQL数据库开发二

class Student:
    id = 某类型字段
    name = 某类型字段
    age = 某类型字段

# 数据描述器
class Column:
    def __get__(self, instance, owner):
        pass
    def __set__(self, instance, value):
        pass
# ORM映射
class Student:
    id = Column() # 描述器
    name = Column() # 描述器
    age = Column() # 描述器
    def __init__(self, id, name, age):
        self.id = id
        self.name = name
        self.age = age
# 一个对象，即一列数据
s1 = Student(id=1, name='cce', age=18)

type_:表示该字段使用的字段类型；
index:布尔值，表示当前字段是否创建普通索引；
primary_key:布尔值，设置当前字段是否为唯一主键；
autoincrement:布尔值，设置当前字段是否自动增长；
default:设置当前字段的默认值；
nullable:指定当前字段是否允许为空，默认值为True，就是可以为空；
unique:指定当前字段是否唯一，创建唯一索引；
onupdate:在做数据更新时会调用这个参数指定的函数，在一次插入数据时不会调用，只会使用default的值，常用于的字段update_time；
name:指定ORM模型中某个属性映射到表中的字段名，如果不指定，那么会使用这个属性的属性名作为字段名；
comment:字段的注视信息；

Intager:整形，映射到数据库中的int类型；
Float:浮点型，映射到数据库中的float类型，占32位字符；
Double:双精度浮点类型，映射到数据库中的double类型，占64位字符；
String:可变字符类型，映射到数据库中是varchar类型；
Boolean:布尔类型，映射到数据库中是tinyint类型；
DECLMAL:定点类型，是专门为乐解决精度丢失的问题；
Enum:枚举类型；
DateTime:存储时间，可以存储年月日时分秒毫秒等。映射到数据库中也是datetime类型；
Date:传递datetime.date()；
Text:文本类型；
LONGTEXT:长文本类型；

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

BaseModel=declarative_base() # 构建基类
class Student(BaseModel): # Student映射类，需要继承上面这个基类
    __tablename__="student" # 指定表名
    id = Column(name="id",type_=Integer,autoincrement=True,primary_key=True) # 整形，自增主键
    name = Column(name="name",type_=String(64),nullable=False) # 字符串类型，对应Varchar，不可为空
    age = Column(name="age",type_=String(64),nullable=False)

# 官网：https://docs.sqlalchemy.org/en/13/dialects/mysql.html
URL语法：dialect+driver://username:password@host:port/database[?<options>]
    dialect：表示使用的方言，如果我们需要链接MySQL，那么dialect就是mysql；
    driver：数据库驱动，用于连接数据库的，如pymysql；

# 示例
engine = sqlalchemy.create_engine("mysql+pymysql://cce:caichangen@47.104.197.46/cce?charset=utf8",encoding='utf-8', echo=True)
    # echo：显示日志，启用它后，将看到生成的所有SQL；
    # encoding：表示链接到方言的字符编码

engine = create_engine("mysql+pymysql://cce:caichangen@47.104.197.46/cce?charset=utf8",encoding='utf-8', echo=False) # echo显示日志
BaseModel=declarative_base() # 构建基类

class Student(BaseModel):
    __tablename__="student" # 指定表名
    id = Column(name="id",type_=Integer,autoincrement=True,primary_key=True) # 整形，自增主键
    name = Column(name="name",type_=String(64),nullable=False) # 字符串类型，对应Varchar，不可为空
    age = Column(name="age",type_=String(64),nullable=False)
BaseModel.metadata.drop_all(engine) # 删除BaseModel所管理的所有映射表
BaseModel.metadata.create_all(engine) # 创建BaseModel所管理的所有映射表

from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

engine = create_engine("mysql+pymysql://cce:caichangen@47.104.197.46/cce?charset=utf8",encoding='utf-8', echo=False)
# 创建Session方式一
Session=sessionmaker(bind=engine) # 创建session会话通道，并将engine以参数的方式传入，返回一个Session类
Session() # 实例化，拿到一个session链接
# 创建Session方式二
Session=sessionmaker()
Session.configure(bind=engine) # 传递Engine
Session()

# 新增单条数据
session.add(Student(name="cce",age=26))
# 批量新增数据
session.add_all([Student(name="cfj",age=14),Student(name="csw",age=70)])
# 提交事务
session.commit()
# 回滚事务
# session.rollback()
# 关闭session通道
session.close()

# 修改数据
data=session.query(Student).get(1) # 将需要修改的数据先拿到，get方法获取唯一主键，意为，在Student表中拿到主键为1的数据
data.age=25 # 修改数据
session.add(data) # 将数据修改
session.commit() # 提交事务
session.close()

# 如果不先查询，则会抛出异常
data=Student(id=1,name='cce',age=25) # 将需要修改的数据先拿到，get方法获取唯一主键，意为，在Student表中拿到主键为1的数据
session.add(data) # 将数据修改
session.commit() # 提交事务
session.close()
# 抛出异常：(1062, "Duplicate entry '1' for key 'PRIMARY'")

# 删除数据
data=session.query(Student).get(1) # 将需要修改的数据先拿到
session.delete(data)  # 删除数据
session.commit() # 提交事务
session.close()

# 如果不先查询，则会抛出异常
data=Student(id=2,name="cce",age=25)
session.delete(data)  # 删除数据
session.commit() # 提交事务
session.close()
# 抛出异常：Instance '<Student at 0x106e9e780>' is not persisted

session.query(Users).filter(Users.id==2).delete()
session.commit() # 记得提交

# inspcet对象方法
key：返回一个三元祖，第一个元素为对象的唯一值，即主键，第二个元素为当前实例所属的映射类，第三个未知；
session_id：当前实例所属的session id，即使会话ID；
modified：返回当前实例是否修改过，但是还没正式应用到数据库；
# 五大状态
transient：表示当前实例，不在会话中且未保存到数据库中的实例，说白了，就是一个新的实例，还没加入到session，同时当前对象也不在数据库中；
pending：表示当前实例已经关联了session，但是还没正式提交到数据库中；
persistent：表示当前实例已经关联了session，同时也已经应用到了数据库的表中，可以是删除，可以是修改；
deleted：表示当前实例已经存在于数据库中，当前的实例是查询出来的，我们利用SqlAlchemy进行了删除，但是只是flush(开启了事务)，但是还没有commit(未提交事务)；
detached：表示，这个数据已成功在数据库中删除，当前的实例在数据库中已经不存在，换句话说就是当前实例与数据库分离；

from sqlalchemy import inspect
def GetState(instance):
    state=inspect(instance)
    attr_names=["transient","pending","persistent","deleted","detached"]
    for attr_name in attr_names:
        if getattr(state,attr_name):
            print(attr_name)

# 当对象未关联session，也未应用到数据库，此时实例的对象就为transient
student=Student(name="cce",age=12)
GetState(student) # transient

# 当对象已关联了session，但是未应用到数据库，此时实例的对象就为pending
student=Student(name="cce",age=12)
session.add(student)
GetState(student) # pending

# 当对象已关联了session，且已应用到数据库，此时实例的对象就为persistent
student=Student(name="cce",age=12)
session.add(student)
session.commit()
GetState(student) # persistent

# 当对象已关联了session，且已在数据中开启了这么一个事务，但是事务未提交，此时实例的对象就为deleted
student=session.query(Student).get(2)
session.delete(student)
session.flush()
GetState(student) # deleted

# 当对象已关联了session，且已在数据中开启了这么一个事务，并且事务已提交，此时实例的对象就为detached
student=session.query(Student).get(2)
session.delete(student)
session.commit()
GetState(student) # detached

student=session.query(Student).get(3)
GetState(student)
session.delete(student)
GetState(student)
session.commit()
GetState(student)
# persistent
# persistent
# detached