Multi-process, multi-thread, use sqlalchemy creation engine (singleton), database session closure class methods, class model decoration carried decorator

python multi-process, multi-threaded, using sqlalchemy database operations

Create a database engine & get the session:

Use the class, then the object methods to create the database engine (the use of a single case, be sure to create only one object, the method in making a judgment on the engine, make sure to create a database engine only)

# Mysql global base method
class MysqlGlobal(object):
    __instance = None
    __engine = None

    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = object.__new__(cls)
        return cls.__instance

    def gen_engine(self):
        if not MysqlGlobal.__engine:
            engine = create_engine("mysql+{driver}://{username}:{password}@{server}/{database}?charset={charset}"
                                   .format(driver=MYSQL_DRIVER,
                                           username=MYSQL_USERNAME,
                                           password=MYSQL_PASSWORD,
                                           server=MYSQL_SERVER,
                                           database=DB_NAME,
                                           charset=DB_CHARSET),
                                   pool_size=100,
                                   max_overflow=100,
                                   # pool_recycle=7200,
                                   pool_recycle=2,
                                   echo=False)
            engine.execute("SET NAMES {charset};".format(charset=DB_CHARSET))
            MysqlGlobal.__engine = engine
        return MysqlGlobal.__engine

    @property
    def mysql_session(self):
        self.gen_engine()
        mysql_db = sessionmaker(bind=MysqlGlobal.__engine)
        return mysql_db()

 

Data table model class

# Binding engine mapping database orm
MapBase = declarative_base(bind=MysqlGlobal().gen_engine())


class WfCarInfo(MapBase):
    __tablename__ = "wf_carinfo"
    untreated_status = 0
    treated_status = 1

    id = Column(Integer, primary_key=True, nullable=True, autoincrement=True)
    status = Column (Integer, nullable = True, default = 0) # access state, 0: to be treated, 1: treated
    Created # create_time = Column (DateTime, nullable = True, default = func.now ()) # records
    # Update_time = Column (DateTime, nullable = True, default = func.now (), onupdate = func.now ()) # records updated
    . . . Omission

 

Database session closure decorator

Packing a database session session

def mysql_session(method):
    @functools.wraps(method)
    def wrapper(*args, **kwargs):
        session = MysqlGlobal().mysql_session
        return method(*args, session, **kwargs)
    return wrapper

　　

Method class model class decorative decorator

Such operation of the database when out of calling a class method, you do not need to pass over the database session (session parameter)

@classmethod
@mysql_session
def query_all(cls, session):
    carinfo_obj_list = session.query(cls).all()
    info_list = [carinfo_obj.to_dict() for carinfo_obj in carinfo_obj_list]
    return info_list

@classmethod
@mysql_session
def query_all_by_status(cls, status, session):
    carinfo_obj_list = session.query(cls).filter(cls.status == status).all()
    info_list = [carinfo_obj.to_dict() for carinfo_obj in carinfo_obj_list]
    return info_list

@classmethod
@mysql_session
def query_all_by_index(cls, current_index, next_index, session):
    carinfo_obj_list = session.query(cls).filter(and_(cls.id > current_index, cls.id <= next_index)).all()
    info_list = [carinfo_obj.to_dict() for carinfo_obj in carinfo_obj_list]
    return info_list

@classmethod
@mysql_session
def insert_one(cls, row, session):
    if not row:
        return
    new_record = cls(**row)
    session.add(new_record)
    session.commit()
    return new_record

@classmethod
@mysql_session
def update_status(cls, record_id, status, session):
    session.query(cls).filter(cls.recordId == record_id).update({"status": status})
    session.commit()
    return 1

@classmethod
@mysql_session
def delete_treated_data(cls, session):
    # session.query(cls).filter(cls.status == cls.treated_status).delete()
    treated_obj_list = session.query(cls).filter(cls.status == cls.treated_status).all()
    count = len(treated_obj_list)
    [session.delete(treated_obj) for treated_obj in treated_obj_list]
    session.commit()
    return count

　　

Additional (database initialization)

# Database initialization
def init_db_data():
    MapBase.metadata.create_all()
    logging.info("init mysql_db success")
    print("init mysql_db success")

　　

end ~