import time
import threading
import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.engine.base import Engine
 
engine = create_engine(
    "mysql+pymysql://root:123@127.0.0.1:3306/t1?charset=utf8",
    max_overflow=0,  # 超过连接池大小外最多创建的连接
    pool_size=5,  # 连接池大小
    pool_timeout=30,  # 池中没有线程最多等待的时间，否则报错
    pool_recycle=-1  # 多久之后对线程池中的线程进行一次连接的回收（重置）
)
 
 

conn = engine.raw_connection()
cursor = conn.cursor()   # pymysql的对象
cursor.execute("select * from t1")
result = cursor.fetchall()
cursor.close()
conn.close()

#################
或：

cur = engine.execute("select * from t1")
result = cur.fetchall()
cur.close()

import datetime
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, Text, ForeignKey, DateTime, UniqueConstraint, Index

Base = declarative_base()


class Users(Base):
    __tablename__ = 'users'

    id = Column(Integer, primary_key=True)
    name = Column(String(32), index=True, nullable=False)
    # email = Column(String(32), unique=True)
    ctime = Column(DateTime, default=datetime.datetime.now)  # default可以写一个callable对象
    # extra = Column(Text, nullable=True)
    
    __table_args__ = (
        # UniqueConstraint('id', 'name', name='uix_id_name'),  # 约束
        # Index('ix_id_name', 'name', 'email'),
    )
    __table_args__ = {
        'mysql_engine': 'InnoDB',  # 用InnoDB
        'mysql_charset': 'utf8'  
    }

association_table = Table('association', Base.metadata,
    Column('left_id', Integer, ForeignKey('left.id')),
    Column('right_id', Integer, ForeignKey('right.id'))
)

# 多对一
class Hobby(Base):
    __tablename__ = 'hobby'
    id = Column(Integer, primary_key=True)
    caption = Column(String(50), default='篮球')


class Person(Base):
    __tablename__ = 'person'
    nid = Column(Integer, primary_key=True)
    name = Column(String(32), index=True, nullable=True)
    hobby_id = Column(Integer, ForeignKey("hobby.id"),nullable=False)  # 这个尽量别让他为空，保证数据不会误删除

    # 与生成表结构无关，仅用于查询方便
    hobby = relationship("Hobby", backref='pers')   # backref在有一个relationship的时候用
　　 # back_populates有同样的效果但是两个表都需要relationship字段
　　 # 例如：
class Parent(Base):
    __tablename__ = 'parent'
    id = Column(Integer, primary_key=True)
)

class Child(Base):
    __tablename__ = 'child'
    id = Column(Integer, primary_key=True)
    parent_id = Column(Integer, ForeignKey('parent.id'))
    parent = relationship("Parent", back_populates="children")

# 关于backref ，主要目的是用来反向关联用的。如果两张表都有relationship字段就不要写backref属性。
# backref本质是用来替代另一个表中的relationship字段，如果仅仅是反查名称直接backref="字符串"就可以;
# 如果需要相关参数可以：backref=backref=backref("articles",cascade="all"),这样相当于在另一张表中写articles = relationship("Article",cascade='all')


# 多对多

class Server2Group(Base): 
　　　　__tablename__ = 'server2group' 
　　　　id = Column(Integer, primary_key=True, autoincrement=True) 
　　　　server_id = Column(Integer, ForeignKey('server.id')) 
　　　　group_id = Column(Integer, ForeignKey('group.id')) 
class Group(Base): 
　　　　__tablename__ = 'group' 
　　　　id = Column(Integer, primary_key=True) 
　　　　name = Column(String(64), unique=True, nullable=False) 
　　　　# 与生成表结构无关，仅用于查询方便 
　　　　servers = relationship('Server', secondary='server2group', backref='groups') 
class Server(Base): 
　　　　__tablename__ = 'server' 
　　　　id = Column(Integer, primary_key=True, autoincrement=True) 
　　　　hostname = Column(String(64), unique=True, nullable=False)


# 使用table定义中间表

article_tag = Table(
　　"article_tag",
　　Base.metadata,
　　Column("article_id",Integer,ForeignKey("article.id"),primary_key=True),
　　Column("tag_id",Integer,ForeignKey("tag.id"),primary_key=True)
)

class Article(Base):
　　__tablename__ = 'article'
　　id = Column(Integer,primary_key=True,autoincrement=True)
　　title = Column(String(50),nullable=False)

  # tags = relationship("Tag",backref="articles",secondary=article_tag) 有一个模型定义了就好

　　def __repr__(self):
　　　　return "<Article(title:%s)>" % self.title

class Tag(Base):
　　__tablename__ = 'tag'
　　id = Column(Integer, primary_key=True, autoincrement=True)
　　name = Column(String(50), nullable=False)

　　articles = relationship("Article",backref="tags",secondary=article_tag)

　　def __repr__(self):
　　　　return "<Tag(name:%s)>" % self.name

# 一对一，通过=True)
更多参见：http://docs.sqlalchemy.org/en/latest/orm/basic_relationships.html#many-to-one

Base = declarative_base()


class Users(Base):
    __tablename__ = 'users'


engine = create_engine(
        "mysql+pymysql://root:123@127.0.0.1:3306/s6?charset=utf8",
        max_overflow=0,  # 超过连接池大小外最多创建的连接
        pool_size=5,  # 连接池大小
        pool_timeout=30,  # 池中没有线程最多等待的时间，否则报错
        pool_recycle=-1  # 多久之后对线程池中的线程进行一次连接的回收（重置）
    )

Base.metadata.create_all(engine)   # 创建继承base的所有的表

engine = create_engine(
        "mysql+pymysql://root:123@127.0.0.1:3306/s6?charset=utf8",
        max_overflow=0,  # 超过连接池大小外最多创建的连接
        pool_size=5,  # 连接池大小
        pool_timeout=30,  # 池中没有线程最多等待的时间，否则报错
        pool_recycle=-1  # 多久之后对线程池中的线程进行一次连接的回收（重置）
    )

Base.metadata.drop_all(engine)   # 删除所有继承base的表

from sqlalchemy.orm import sessionmaker
Session=sessionmaker(bind=egine)
session=Session()

session.add(row_obj)
session.add_all([
    Dep(dname='技术'),
    Dep(dname='运营'),
])
# session.add对应的操作是session.expunge(对象) 仅仅是从session删除掉，不修改数据库
# session.merge
session.commit()

session.add_all([
    Emp(ename='fa',dep_id=1),
　　　　.....
    Emp(ename='iuo',dep_id=2),
])
session.commit()

# 依靠relationship插
person = Emp(name='张九', dep=Dep(dname='产品部'))  # 如果设置了relationship可以这么用
session.add(person)

hd = Dep(dname='产品部')
hd.emp = [Emp(name='fa'), Person(name='sa')]
session.add(hb)
session.commit()
session.close()  # session一定要关闭


# 多对多利用append

# article1 = Article(title="article1")
# article2 = Article(title="article2")
#
# tag1 = Tag(name='tag1')
# tag2 = Tag(name='tag2')
#
# article1.tags.append(tag1)
# article1.tags.append(tag2)
#
# article2.tags.append(tag1)
# article2.tags.append(tag2)
#
# session.add(article1)
# session.add(article2)

session.query(Users).filter(Users.id > 2).delete()
session.commit()

session.query(Users).filter(Users.id > 0).update({"name" : "099"})
session.query(Users).filter(Users.id > 0).update({Users.name: Users.name + "099"}, synchronize_session=False)
session.query(Users).filter(Users.id > 0).update({"age": Users.age + 1}, synchronize_session="evaluate")
session.commit()

用于query在进行delete or update操作时，对session的同步策略。
false代表直接同步或删除，还有"fetch","evaluate"选项