SqlAlchemy 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:password@host:port/dbname[?key=value&key=value...]
	
更多详见：http://docs.sqlalchemy.org/en/latest/dialects/index.html

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

# create_engine() 初始化数据库连接
# ‘数据库类型+数据库驱动名称://用户名:口令@机器地址:端口号/数据库名‘
# charset=utf-8 设置表支持中文字符、echo=True打印创建过程
engine = create_engine("mysql+pymysql://root:123456@localhost/oldboy?charset=utf-8",
                       encoding="utf-8",echo=True)

Base = declarative_base()   # 创建orm的基类

# 定义User对象
class User(Base):
    __tablename__ = "user"   # 表的名字

    # 表的结构
    id = Column(Integer,primary_key=True)
    name = Column(String(32))
    password = Column(String(64))

Base.metadata.create_all(engine)   # 创建表结构

from sqlalchemy import Table,MetaData,Column,Integer,String,create_engine
from sqlalchemy.orm import mapper

engine = create_engine("mysql+pymysql://root:123456@localhost/oldboy?charset=utf8",echo=True) 

metadata = MetaData()

user = Table("user",metadata,
             Column("id",Integer,primary_key=True),
             Column("name",String(50)),
             Column("fullname",String(50)),
             Column("password",String(12))
             )

class User(object):
    def __init__(self,name,fullname,password):
        self.name = name
        self.fullname = fullname
        self.password = password

mapper(User,user)  # 创建映射关系

metadata.create_all(engine)   # 创建表结构

Session_class = sessionmaker(bind=engine)  # 创建与数据库的会话session class,返回的是个class,不是实例
Session = Session_class()   # 生成session实例

user_obj = User(name="alex",password="alex3714")  # 生成要创建的数据对象
print(user_obj.name,user_obj.id)  # 此时还没创建对象,user_obj.id返回None

Session.add(user_obj)  # 把要创建的数据对象添加到session里,统一创建
print(user_obj.name,user_obj.id)  # 此时也依然没创建

Session.commit()  # 统一提交,创建数据

# query：查询对象、filter_by：过滤条件、first：显示第一个

my_user = Session.query(User).filter_by(name="alex").first()

print(my_user)   # 返回的是内存地址<__main__.User object at 0x7f92d89ef518>

在User类中加入__repr__函数，可将内存地址中相应数据返回

# 重构__repr__方法后，不管直接输出对象还是通过print打印的信息都按我们__repr__方法中定义的格式进行显示

def __repr__(self):   # __repr__ 和 __str__这两个方法都是用于显示的,__str__是面向用户的，而__repr__面向程序员
　　return "<%s(name=%s,password=%s)>" %(self.__class__.name,self.name,self.password)

my_user = Session.query(User).filter_by(name="alex").filter_by(password="sb1234").first()  # 多个条件时可加多个filter_by

my_user.name="Alex Li"    # 修改mysql_user中name的值

Session.commit()  # 提交

my_user = Session.query(User).filter_by(id=1).first()  # 查id=1的数据
my_user.name = "Jack"  # 修改id=1数据中的name

fake_user = User(name="Rain",password="123456")  # 插入数据
Session.add(fake_user)  # 要插入的数据添加到Session里面

# filter与filter_by都是过滤条件,用法类似,里面的条件语句不同
print(Session.query(User).filter(User.name.in_(["Jack","rain"])).all()) # 查询出所有User对象中name为Jack、rain的

Session.rollback()  # 事务回滚

print(Session.query(User).filter(User.name.in_(["Jack","rain"])).all())

# all()获取所有数据
Session.query(User.name,User.id).all()

# 多条件查询
Session.query(User).filter(User.id>1).filter(User.id<7).all()

# 统计次数
Session.query(User).filter(User.name.like("Ra%")).count()

# 分组
from sqlalchemy import func

Session.query(User.name,func.count(User.name)).group_by(User.name).all() # 按User.name分组

相当于sql: select user.name,count(user.name) from user group by user.name;

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

engine = create_engine("mysql+pymysql://root:123456@localhost/oldboy?charset=utf8",
                       encoding="utf8")

Base = declarative_base()  # 创建ORM基类

session_class = sessionmaker(bind=engine)  # 对表的操作交给session_class来操作,返回的是一个class
session = session_class()  # 创建一个session对象,在session中完成多个事务


class User(Base):
    __tablename__ = "user"
    id = Column(Integer,primary_key=True)
    name = Column(String(32))
    password = Column(String(64))

    def __repr__(self):
        return "<User(name=%s,password=%s)>" %(self.name,self.password)

class Address(Base):
    __tablename__ = "addresses"
    id = Column(Integer,primary_key=True)
    email_address = Column(String(32),nullable=False)
	#注意点：增加用户时user_id只能是表user中存在的id,否则会报错
    user_id = Column(Integer,ForeignKey("user.id"))  # addresses表中的外键关联user表中的id
	
	# relationship函数是sqlalchemy对关系之间提供的一种便利的调用方式
    user = relationship("User",backref="addresses")  # 通过user调用user表中的变量, user表中通过addresses调用addresses表中的变量

    def __repr__(self):
        return "<Address(email_address=%s)>" %self.email_address


Base.metadata.create_all(engine)   # 构造表结构

obj = session.query(User).all()[0]  # 查询user表语句

print("obj.addresses:",obj.addresses)

obj.addresses = [Address(email_address="r1@126.com"),
                 Address(email_address="r2@126.com")]  # 通过user对象反查关联的addresses插入数据

for i in obj.addresses:  # 通过user对象反查关联的addresses记录
　　print(i)

session.commit()  # 事务提交

addr_obj = session.query(Address).all()[-1]  # 查看address表中的数据
print(addr_obj.user)  # 通过user查看user表中的数据

	equals:
		query.filter(User.name == "ed")
	not equals:
		query.filter(User.name != "ed")
	like:
		query.filter(User.name.like("%ed%"))
	in:
		query.filter(User.name.in_(["ed","wendy","jack"]))
	not in:
		query.filter(~User.name.in_(["ed","wendy","jack"]))
	is null / is not null:
		query.filter(User.name == None)
		query.filter(User.name.is_(None))
		query.filter(User.name != None)
		query.filter(User.name.isnot(None))
	and:
		from sqlalchemy import and_
		query.filter(and_(User.name == "ed",User.fullname == "Ed Jones"))
		query.filter(User.name == "ed",User.fullname == "Ed Jones")
		query.filter(User.name == "ed").filter(User.fullname == "Ed Jones")
	or:
		from sqlalchemy import or_
		query.filter(or_(User.name == "ed",User.fullname == "Ed Jones"))
	match:
		query.filter(User.name.match("wendy"))

删除数据时不用管boo_m2m_authors　， sqlalchemy会自动帮你把对应的数据删除

通过书删除作者

author_obj =s.query(Author).filter_by(name="Jack").first()
 
book_obj = s.query(Book).filter_by(name="跟Alex学把妹").first()
 
book_obj.authors.remove(author_obj) #从一本书里删除一个作者

s.commit()

author_obj =s.query(Author).filter_by(name="Alex").first()

# print(author_obj.name , author_obj.books)

s.delete(author_obj)

s.commit()