from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select, text, cast, Integer, and_, or_, outerjoin, func, join, update, desc
from module_admin.entity.vo.meta_vo import MetaPageObject, MetaColObject
from module_admin.entity.do.meta_do import MetadataExtractInfo, MetadataSuppInfo, MetadataFldTabExtractInfo, \
    MetadataFldSuppInfo, MetadataClas, MetadataSuppInfoVett, MetadataFldSuppInfoVett, MetaBatchTabClas, MetaBatchFldClas
from utils.common_util import CamelCaseUtil
import uuid
from utils.page_util import PageUtil


class MetaDao:

    @classmethod
    async def get_meta_tab_clas(cls, db: AsyncSession, sysCode: str, mdlName: str, tabName: str):
        query_result = (
            (
                await db.execute(
                    select(
                        MetaBatchTabClas.onum,
                        MetaBatchTabClas.ssys_cd,
                        MetaBatchTabClas.data_whs_name,
                        MetaBatchTabClas.mdl_name,
                        MetaBatchTabClas.tab_no,
                        MetaBatchTabClas.tab_eng_name,
                        MetaBatchTabClas.clas_onum,
                        MetaBatchTabClas.clas_value,
                        MetadataClas.clas_pri_clas,
                        MetadataClas.clas_scd_clas,
                        MetadataClas.clas_thre_clas,
                        MetadataClas.clas_eff_flag,
                        MetadataClas.rec_subm_prsn,
                        MetadataClas.clas_name
                    ).join(
                        MetadataClas, MetaBatchTabClas.clas_onum == MetadataClas.clas_onum
                    )
                    .where(MetaBatchTabClas.ssys_cd == sysCode,
                           MetaBatchTabClas.mdl_name == mdlName,
                           MetaBatchTabClas.tab_eng_name == tabName).distinct()
                )
            ).fetchall()
        )
        return query_result

    @classmethod
    async def get_meta_fld_clas(cls, db: AsyncSession, sysCode: str, mdlName: str, tabName: str, fldName: str):
        query_result = (
            (
                await db.execute(
                    select(
                        MetaBatchFldClas.onum,
                        MetaBatchFldClas.ssys_cd,
                        MetaBatchFldClas.data_whs_name,
                        MetaBatchFldClas.mdl_name,
                        MetaBatchFldClas.tab_no,
                        MetaBatchFldClas.tab_eng_name,
                        MetaBatchFldClas.fld_eng_name,
                        MetaBatchFldClas.clas_onum,
                        MetaBatchFldClas.clas_value,
                        MetadataClas.clas_pri_clas,
                        MetadataClas.clas_scd_clas,
                        MetadataClas.clas_thre_clas,
                        MetadataClas.clas_eff_flag,
                        MetadataClas.rec_subm_prsn,
                        MetadataClas.clas_name
                    ).join(
                        MetadataClas, MetaBatchFldClas.clas_onum == MetadataClas.clas_onum
                    )
                    .where(MetaBatchFldClas.ssys_cd == sysCode,
                           MetaBatchFldClas.mdl_name == mdlName,
                           MetaBatchFldClas.tab_eng_name == tabName,
                           MetaBatchFldClas.fld_eng_name == fldName).distinct()
                )
            ).fetchall()
        )
        return query_result

    @classmethod
    async def get_meta_rel_list(cls, db: AsyncSession, query_object: MetaPageObject):
        """
        根据查询参数获取用户列表信息
        """
        # 主查询
        query = (
            select(
                MetadataExtractInfo.onum.label('extract_onum'),
                MetadataExtractInfo.extract_ver_num,
                MetadataExtractInfo.ver_desc.label('extract_ver_desc'),
                MetadataExtractInfo.ssys_cd,
                MetadataExtractInfo.data_whs_name,
                MetadataExtractInfo.mdl_name,
                MetadataExtractInfo.tab_no,
                MetadataExtractInfo.tab_type,
                MetadataExtractInfo.tab_eng_name,
                MetadataExtractInfo.tab_cn_name,
                MetadataExtractInfo.tab_rec_num,
                MetadataExtractInfo.upd_time.label('extract_upd_time'),
                MetadataSuppInfo.onum.label('supp_onum'),
                MetadataSuppInfo.crrct_ver_num.label('supp_crrct_ver_num'),
                MetadataSuppInfo.tab_crrct_name,
                MetadataSuppInfo.tab_desc,
                MetadataSuppInfo.pic,
                MetadataSuppInfo.gov_flag,
                MetadataSuppInfo.rec_stat.label('supp_rec_stat'),
                MetadataSuppInfo.tab_clas,
                MetadataSuppInfo.rec_subm_prsn,
                MetadataSuppInfo.upd_time.label('supp_upd_time'),
            ).join(MetadataSuppInfo,
                   and_(
                       MetadataExtractInfo.ssys_cd == MetadataSuppInfo.ssys_cd,
                       MetadataExtractInfo.mdl_name == MetadataSuppInfo.mdl_name,
                       MetadataExtractInfo.tab_eng_name == MetadataSuppInfo.tab_eng_name
                   ), isouter=True)
            .join(
                MetadataFldTabExtractInfo,
                and_(
                    MetadataExtractInfo.ssys_cd == MetadataFldTabExtractInfo.ssys_cd,
                    MetadataExtractInfo.mdl_name == MetadataFldTabExtractInfo.mdl_name,
                    MetadataExtractInfo.tab_eng_name == MetadataFldTabExtractInfo.tab_eng_name
                ), isouter=True)
            .join(
                MetadataFldSuppInfo,
                and_(
                    MetadataExtractInfo.ssys_cd == MetadataFldSuppInfo.ssys_cd,
                    MetadataExtractInfo.mdl_name == MetadataFldSuppInfo.mdl_name,
                    MetadataExtractInfo.tab_eng_name == MetadataFldSuppInfo.tab_eng_name
                ), isouter=True)
            .where(
                MetadataExtractInfo.ssys_cd == query_object.ssys_cd if query_object.ssys_cd else True,
                MetadataExtractInfo.mdl_name == query_object.mdl_name if query_object.mdl_name else True,
                or_(MetadataExtractInfo.tab_eng_name.like(f'%{query_object.tab_name}%'),
                    MetadataExtractInfo.tab_cn_name.like(f'%{query_object.tab_name}%'),
                    MetadataSuppInfo.tab_eng_name.like(f'%{query_object.tab_name}%'),
                    MetadataSuppInfo.tab_crrct_name.like(f'%{query_object.tab_name}%'),
                    ) if query_object.tab_name else True,
                or_(
                    MetadataFldTabExtractInfo.fld_eng_name.like(f'%{query_object.col_name}%'),
                    MetadataFldTabExtractInfo.fld_cn_name.like(f'%{query_object.col_name}%'),
                    MetadataFldSuppInfo.fld_eng_name.like(f'%{query_object.col_name}%'),
                    MetadataFldSuppInfo.fld_crrct_name.like(f'%{query_object.col_name}%'),
                ) if query_object.col_name else True,
                MetadataExtractInfo.tab_type == query_object.tab_type if query_object.tab_type else True,
                MetadataExtractInfo.rec_stat == query_object.rec_stat if query_object.rec_stat else True,
            ).distinct()
        )
        result = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size, True)
        return result

    @classmethod
    async def get_meta_col_list(cls, db: AsyncSession, query_object: MetaColObject):
        query_result = (
            (
                await db.execute(
                    select(
                        MetadataFldTabExtractInfo.onum.label('extract_onum'),
                        MetadataFldTabExtractInfo.extract_ver_num,
                        MetadataFldTabExtractInfo.ssys_cd,
                        MetadataFldTabExtractInfo.data_whs_name,
                        MetadataFldTabExtractInfo.mdl_name,
                        MetadataFldTabExtractInfo.tab_no,
                        MetadataFldTabExtractInfo.tab_eng_name,
                        MetadataFldTabExtractInfo.fld_no,
                        MetadataFldTabExtractInfo.fld_eng_name,
                        MetadataFldTabExtractInfo.fld_cn_name,
                        MetadataFldTabExtractInfo.fld_type,
                        MetadataFldTabExtractInfo.pk_flag,
                        MetadataFldTabExtractInfo.require_flag,
                        MetadataFldTabExtractInfo.idx_flag,
                        MetadataFldTabExtractInfo.upd_time.label('extract_upd_time'),
                        MetadataFldSuppInfo.onum.label('supp_onum'),
                        MetadataFldSuppInfo.crrct_ver_num,
                        MetadataFldSuppInfo.fld_crrct_name,
                        MetadataFldSuppInfo.crrct_pk_flag,
                        MetadataFldSuppInfo.fld_desc,
                        MetadataFldSuppInfo.pic,
                        MetadataFldSuppInfo.fld_clas,
                        MetadataFldSuppInfo.fld_null_rate,
                        MetadataFldSuppInfo.rec_stat.label('supp_rec_stat'),
                        MetadataFldSuppInfo.upd_time.label('supp_upd_time')
                    ).select_from(
                        join(
                            MetadataFldTabExtractInfo,
                            MetadataFldSuppInfo,
                            and_(
                                MetadataFldTabExtractInfo.ssys_cd == MetadataFldSuppInfo.ssys_cd,
                                MetadataFldTabExtractInfo.mdl_name == MetadataFldSuppInfo.mdl_name,
                                MetadataFldTabExtractInfo.tab_eng_name == MetadataFldSuppInfo.tab_eng_name,
                                MetadataFldTabExtractInfo.fld_eng_name == MetadataFldSuppInfo.fld_eng_name
                            ), isouter=True
                        )
                    ).where(
                        MetadataFldTabExtractInfo.ssys_cd == query_object.ssys_cd,
                        MetadataFldTabExtractInfo.mdl_name == query_object.mdl_name,
                        MetadataFldTabExtractInfo.tab_eng_name == query_object.tab_name
                    ).distinct()
                )
            ).all()
        )
        return [row._asdict() for row in query_result]

    @classmethod
    async def get_meta_clas_list(cls, db: AsyncSession):
        query_result = (
            (
                await db.execute(
                    select(MetadataClas).where(MetadataClas.clas_eff_flag == 1).distinct()
                )
            ).scalars().all()
        )
        return query_result

    @classmethod
    async def get_lastest_meta_data_supp_vett(cls, db: AsyncSession, ssys_cd: str, mdl_name: str, tab_eng_name: str):
        query_result = (
            (
                await db.execute(
                    select(MetadataSuppInfoVett).where(MetadataSuppInfoVett.ssys_cd == ssys_cd,
                                                       MetadataSuppInfoVett.mdl_name == mdl_name,
                                                       MetadataSuppInfoVett.tab_eng_name == tab_eng_name)
                    .order_by(desc(MetadataSuppInfoVett.apply_time))
                    .distinct().limit(1)
                )
            ).scalars().first()
        )
        return query_result

    @classmethod
    async def insertMetadataSuppInfoVett(cls, table: MetadataSuppInfoVett, db: AsyncSession):
        db.add(table)
        await db.flush()
        return table

    @classmethod
    async def updateMetadataSuppInfoVett(cls, onum: str, operateType: str, db: AsyncSession):
        table = dict(
            onum=onum,
            apply_status=operateType
        )
        await db.execute(update(MetadataSuppInfoVett), [table])

    @classmethod
    async def insertMetadataSuppInfo(cls, table: MetadataSuppInfoVett, db: AsyncSession):
        suppTable = MetadataSuppInfo()
        suppTable.onum = uuid.uuid4()
        suppTable.ssys_cd = table.ssys_cd
        suppTable.mdl_name = table.mdl_name
        suppTable.tab_eng_name = table.tab_eng_name
        suppTable.tab_crrct_name = table.tab_crrct_name
        suppTable.tab_desc = table.tab_desc
        suppTable.pic = table.pic
        suppTable.gov_flag = table.gov_flag
        suppTable.rec_stat = table.rec_stat
        suppTable.tab_clas = table.tab_clas
        suppTable.rec_subm_prsn = table.rec_subm_prsn
        suppTable.upd_time = table.upd_time
        db.add(suppTable)
        await db.flush()
        return suppTable

    @classmethod
    async def updateMetadataSuppInfo(cls, onum: str, table: MetadataSuppInfoVett, db: AsyncSession):
        suppTable = dict(
            onum=onum,
            tab_crrct_name=table.tab_crrct_name,
            tab_desc=table.tab_desc,
            pic=table.pic,
            gov_flag=table.gov_flag,
            rec_stat=table.rec_stat,
            tab_clas=table.tab_clas,
            rec_subm_prsn=table.rec_subm_prsn,
            upd_time=table.upd_time
        )
        await db.execute(update(MetadataSuppInfo), [suppTable])

    @classmethod
    async def get_supp_table_vett_by_id(cls, suppId: str, db: AsyncSession):
        query_result = (
            (
                await db.execute(
                    select(MetadataSuppInfoVett).where(MetadataSuppInfoVett.onum == suppId).distinct()
                )
            ).scalars().first()
        )
        return query_result

    @classmethod
    async def get_supp_column_vett_by_tableInfo(cls, db: AsyncSession, tableInfo: MetadataSuppInfoVett):
        query_result = (
            (
                await db.execute(
                    select(MetadataFldSuppInfoVett).where(
                        MetadataFldSuppInfoVett.ssys_cd == tableInfo.ssys_cd,
                        MetadataFldSuppInfoVett.mdl_name == tableInfo.mdl_name,
                        MetadataFldSuppInfoVett.tab_eng_name == tableInfo.tab_eng_name,
                        MetadataFldSuppInfoVett.apply_time == tableInfo.apply_time
                    )
                )
            ).scalars().all()
        )
        return query_result

    @classmethod
    async def get_supp_table_by_vett(cls, sysCode: str, mdlName: str, tableName: str, db: AsyncSession):
        query_result = (
            (
                await db.execute(
                    select(MetadataSuppInfo).where(MetadataSuppInfo.ssys_cd == sysCode,
                                                   MetadataSuppInfo.mdl_name == mdlName,
                                                   MetadataSuppInfo.tab_eng_name == tableName).distinct()
                )
            ).scalars().first()
        )
        return query_result

    @classmethod
    async def get_meta_table(cls, sysCode: str, mdlName: str, tableName: str, db: AsyncSession):
        query_result = (
            (
                await db.execute(
                    select(MetadataExtractInfo).where(MetadataExtractInfo.ssys_cd == sysCode,
                                                      MetadataExtractInfo.mdl_name == mdlName,
                                                      MetadataExtractInfo.tab_eng_name == tableName).distinct()
                )
            ).scalars().first()
        )
        return query_result

    @classmethod
    async def insertMetadataFldSuppInfoVett(cls, column: MetadataFldSuppInfoVett, db: AsyncSession):
        db.add(column)
        await db.flush()
        return column

    @classmethod
    async def updateMetadataFldSuppInfoVett(cls, onum: str, operateType: str, db: AsyncSession):
        updateColumn = dict(
            onum=onum, apply_status=operateType
        )
        await db.execute(update(MetadataFldSuppInfoVett), [updateColumn])

    @classmethod
    async def updateMetadataFldSuppInfo(cls, onum: str, column: MetadataFldSuppInfoVett, db: AsyncSession):
        updateColumn = dict(
            onum=onum,
            fld_crrct_name=column.fld_crrct_name,
            crrct_pk_flag=column.crrct_pk_flag,
            fld_desc=column.fld_desc,
            pic=column.pic,
            fld_clas=column.fld_clas,
            fld_null_rate=column.fld_null_rate,
            rec_stat=column.rec_stat,
            upd_time=column.upd_time,
        )
        await db.execute(update(MetadataFldSuppInfo), [updateColumn])

    @classmethod
    async def insertMetadataFldSuppInfo(cls, column: MetadataFldSuppInfoVett, db: AsyncSession):
        suppColumn = MetadataFldSuppInfo()
        suppColumn.onum = uuid.uuid4()
        suppColumn.ssys_cd = column.ssys_cd
        suppColumn.mdl_name = column.mdl_name
        suppColumn.tab_eng_name = column.tab_eng_name
        suppColumn.fld_eng_name = column.fld_eng_name
        suppColumn.fld_crrct_name = column.fld_crrct_name
        suppColumn.crrct_pk_flag = column.crrct_pk_flag
        suppColumn.fld_desc = column.fld_desc
        suppColumn.pic = column.pic
        suppColumn.fld_clas = column.fld_clas
        suppColumn.fld_null_rate = column.fld_null_rate
        suppColumn.rec_stat = column.rec_stat
        suppColumn.upd_time = column.upd_time
        db.add(suppColumn)
        await db.flush()
        return suppColumn

    @classmethod
    async def get_meta_col_supp_vett(cls, table: MetadataSuppInfoVett, db: AsyncSession):
        sql_query = text("select max(apply_time) from t_metadata_fld_supp_info_vett where ssys_cd ='" + table.ssys_cd +
                         "' and mdl_name = '" + table.mdl_name + "' and tab_eng_name = '" + table.tab_eng_name +
                         "'")
        maxTime = (await db.execute(sql_query)).scalar()

        query_result = (
            (
                await db.execute(
                    select(MetadataFldSuppInfoVett)
                    .where(MetadataFldSuppInfoVett.ssys_cd == table.ssys_cd,
                           MetadataFldSuppInfoVett.mdl_name == table.mdl_name,
                           MetadataFldSuppInfoVett.tab_eng_name == table.tab_eng_name,
                           MetadataFldSuppInfoVett.apply_time == maxTime).distinct()
                )
            ).scalars().all()
        )
        return query_result

    @classmethod
    async def get_supp_column_by_vett(cls, column: MetadataFldSuppInfoVett, db: AsyncSession):
        query_result = (
            (
                await db.execute(
                    select(MetadataFldSuppInfo)
                    .where(MetadataFldSuppInfo.ssys_cd == column.ssys_cd,
                           MetadataFldSuppInfo.mdl_name == column.mdl_name,
                           MetadataFldSuppInfo.tab_eng_name == column.tab_eng_name,
                           MetadataFldSuppInfo.fld_eng_name == column.fld_eng_name).distinct()
                )
            ).scalars().first()
        )
        return query_result

    @classmethod
    async def get_supp_column_by_columnInfo(cls, sysCode, mdlName, tabEngName, fldEngName, db: AsyncSession):
        query_result = (
            (
                await db.execute(
                    select(MetadataFldSuppInfo)
                    .where(MetadataFldSuppInfo.ssys_cd == sysCode,
                           MetadataFldSuppInfo.mdl_name == mdlName,
                           MetadataFldSuppInfo.tab_eng_name == tabEngName,
                           MetadataFldSuppInfo.fld_eng_name == fldEngName).distinct()
                )
            ).scalars().first()
        )
        return query_result

    @classmethod
    async def get_meta_column(cls, sysCode, mdlName, tabEngName, fldEngName, db: AsyncSession):
        query_result = (
            (
                await db.execute(
                    select(MetadataFldTabExtractInfo)
                    .where(MetadataFldTabExtractInfo.ssys_cd == sysCode,
                           MetadataFldTabExtractInfo.mdl_name == mdlName,
                           MetadataFldTabExtractInfo.tab_eng_name == tabEngName,
                           MetadataFldTabExtractInfo.fld_eng_name == fldEngName).distinct()
                )
            ).scalars().first()
        )
        return query_result

    @classmethod
    async def get_meta_table_by_id(cls, tableId: int, db: AsyncSession):
        """
        根据查询参数获取用户列表信息
        """
        # 主查询

        result = (await db.execute(
            select(
                MetadataExtractInfo.onum.label('extract_onum'),
                MetadataExtractInfo.extract_ver_num,
                MetadataExtractInfo.ver_desc.label('extract_ver_desc'),
                MetadataExtractInfo.ssys_cd,
                MetadataExtractInfo.data_whs_name,
                MetadataExtractInfo.mdl_name,
                MetadataExtractInfo.tab_no,
                MetadataExtractInfo.tab_type,
                MetadataExtractInfo.tab_eng_name,
                MetadataExtractInfo.tab_cn_name,
                MetadataExtractInfo.tab_rec_num,
                MetadataExtractInfo.upd_time.label('extract_upd_time'),
                MetadataSuppInfo.onum.label('supp_onum'),
                MetadataSuppInfo.crrct_ver_num.label('supp_crrct_ver_num'),
                MetadataSuppInfo.tab_crrct_name,
                MetadataSuppInfo.tab_desc,
                MetadataSuppInfo.pic,
                MetadataSuppInfo.gov_flag,
                MetadataSuppInfo.rec_stat.label('supp_rec_stat'),
                MetadataSuppInfo.tab_clas,
                MetadataSuppInfo.rec_subm_prsn,
                MetadataSuppInfo.upd_time.label('supp_upd_time'),
            ).join(MetadataSuppInfo,
                   and_(
                       MetadataExtractInfo.ssys_cd == MetadataSuppInfo.ssys_cd,
                       MetadataExtractInfo.mdl_name == MetadataSuppInfo.mdl_name,
                       MetadataExtractInfo.tab_eng_name == MetadataSuppInfo.tab_eng_name
                   ), isouter=True)
            .join(
                MetadataFldTabExtractInfo,
                and_(
                    MetadataExtractInfo.ssys_cd == MetadataFldTabExtractInfo.ssys_cd,
                    MetadataExtractInfo.mdl_name == MetadataFldTabExtractInfo.mdl_name,
                    MetadataExtractInfo.tab_eng_name == MetadataFldTabExtractInfo.tab_eng_name
                ), isouter=True)
            .join(
                MetadataFldSuppInfo,
                and_(
                    MetadataExtractInfo.ssys_cd == MetadataFldSuppInfo.ssys_cd,
                    MetadataExtractInfo.mdl_name == MetadataFldSuppInfo.mdl_name,
                    MetadataExtractInfo.tab_eng_name == MetadataFldSuppInfo.tab_eng_name
                ), isouter=True)
            .where(
                MetadataExtractInfo.onum == tableId
            ).distinct()
        )).first()
        return CamelCaseUtil.transform_result(result)

    @classmethod
    async def get_meta_col_name_list(cls, db: AsyncSession, query_object: MetaColObject):
        query_result = (
            (
                await db.execute(
                    select(
                        MetadataFldTabExtractInfo.ssys_cd,
                        MetadataFldTabExtractInfo.mdl_name,
                        MetadataFldTabExtractInfo.tab_eng_name,
                        MetadataFldTabExtractInfo.fld_eng_name,
                        MetadataFldTabExtractInfo.fld_cn_name,
                        MetadataFldTabExtractInfo.fld_type,
                        MetadataFldTabExtractInfo.pk_flag,
                    ).where(
                        MetadataFldTabExtractInfo.ssys_cd == query_object.ssys_cd,
                        MetadataFldTabExtractInfo.mdl_name == query_object.mdl_name,
                        MetadataFldTabExtractInfo.tab_eng_name == query_object.tab_name
                    ).distinct()
                )
            ).all()
        )
        return [row._asdict() for row in query_result]

    @classmethod
    async def get_er_relation_by_table(cls, result_db: AsyncSession, ssys_cd: str, mdl_name: str, tab_eng_name: str):
        sql = text("select a1.*,case when a2.rela_value = '1' then 'A' when a2.rela_value = '2' then 'B' end AS father "
                   "from ( select a_ssys_cd,a_mdl_name,a_tab_eng_name,a_fld_eng_name,b_ssys_cd,b_mdl_name,"
                   "b_tab_eng_name,b_fld_eng_name from t_batch_fld_relation "
                   "where rela_type  = 'sub_flag' and rela_value ='1') a1 "
                   "left join t_batch_fld_relation a2 "
                   "on a1.a_ssys_cd = a2.a_ssys_cd and a1.a_mdl_name = a2.a_mdl_name "
                   "and a1.a_tab_eng_name = a2.a_tab_eng_name "
                   "and a1.a_fld_eng_name      =  a2.a_fld_eng_name "
                   "and a1.b_ssys_cd           =  a2.b_ssys_cd "
                   "and a1.b_mdl_name          =  a2.b_mdl_name "
                   "and a1.b_tab_eng_name      =  a2.b_tab_eng_name "
                   "and a1.b_fld_eng_name      =  a2.b_fld_eng_name "
                   "and a2.rela_type = 'set_flag' "
                   "where ((a1.a_ssys_cd,a1.a_mdl_name,a1.a_tab_eng_name,a1.a_fld_eng_name) in "
                   "(select ssys_cd,mdl_name,tab_eng_name,clas_value from  t_batch_tab_clas)"
                   "or (a1.b_ssys_cd,a1.b_mdl_name,a1.b_tab_eng_name,a1.b_fld_eng_name) in "
                   "(select ssys_cd,mdl_name,tab_eng_name,clas_value from  t_batch_tab_clas))"
                   "and ((a1.a_ssys_cd = :sysCode and a1.a_mdl_name = :mdlName and a1.a_tab_eng_name = :tabName)"
                   " or (a1.b_ssys_cd = :sysCode and a1.b_mdl_name = :mdlName and a1.b_tab_eng_name = :tabName))")
        result = (await result_db.execute(sql, {"sysCode": ssys_cd,
                                                "mdlName": mdl_name, "tabName": tab_eng_name}))
        # 获取列名
        columns = result.keys()  # 返回列名列表

        # 将结果转换为字典列表
        result_as_dict = [dict(zip(columns, row)) for row in result.fetchall()]
        return result_as_dict

    @classmethod
    async def get_op_relation_by_table(cls, result_db: AsyncSession, ssys_cd: str, mdl_name: str, tab_eng_name: str):
        sql = text("select  a_ssys_cd,a_mdl_name,a_tab_eng_name,a_fld_eng_name,b_ssys_cd,b_mdl_name,b_tab_eng_name,"
                   "b_fld_eng_name,case when max(case when rela_type = 'sub_flag' then rela_value  end) = '1' and "
                   "max(case when rela_type = 'set_flag' then rela_value  end) = '1' then 'A' "
                   "when max(case when rela_type = 'sub_flag' then rela_value  end) = '1' and "
                   "max(case when rela_type = 'set_flag' then rela_value  end) = '2' then 'B' "
                   "when max(case when rela_type = 'op2_relation' then rela_value  end) <> '[]' AND "
                   "max(case when rela_type = 'op_relation' then rela_value  end) <> 0 and "
                   "max(case when rela_type = 'set_flag' then rela_value  end) = '1' then 'A' "
                   "when max(case when rela_type = 'op2_relation' then rela_value  end) <> '[]' AND "
                   "max(case when rela_type = 'op_relation' then rela_value  end) <> 0 and "
                   "max(case when rela_type = 'set_flag' then rela_value  end) = '2' then 'B' END as father "
                   "from t_batch_fld_relation "
                   "where ((a_ssys_cd = :sysCode and a_mdl_name = :mdlName and a_tab_eng_name = :tabName) "
                   " or (b_ssys_cd = :sysCode and b_mdl_name = :mdlName and b_tab_eng_name = :tabName))"
                   "group by a_ssys_cd,a_mdl_name,a_tab_eng_name,a_fld_eng_name,b_ssys_cd,b_mdl_name,b_tab_eng_name"
                   ",b_fld_eng_name "
                   "having max(case when rela_type = 'op2_relation' then rela_value  end) <> '[]'"
                   " or max(case when rela_type = 'sub_flag' then rela_value  end) = '1'")
        result = (await result_db.execute(sql, {"sysCode": ssys_cd,
                                                "mdlName": mdl_name, "tabName": tab_eng_name}))
        # 获取列名
        columns = result.keys()  # 返回列名列表

        # 将结果转换为字典列表
        result_as_dict = [dict(zip(columns, row)) for row in result.fetchall()]
        return result_as_dict

    @classmethod
    async def get_er_relation_by_column(cls, result_db: AsyncSession, column: {}, module: str):
        sql = text("select a1.*,case when a2.rela_value = '1' then 'A' when a2.rela_value = '2' then 'B' end AS father "
                   "from ( select a_ssys_cd,a_mdl_name,a_tab_eng_name,a_fld_eng_name,b_ssys_cd,b_mdl_name,"
                   "b_tab_eng_name,b_fld_eng_name from t_batch_fld_relation "
                   "where rela_type  = 'sub_flag' and rela_value ='1') a1 "
                   "left join t_batch_fld_relation a2 "
                   "on a1.a_ssys_cd = a2.a_ssys_cd and a1.a_mdl_name = a2.a_mdl_name "
                   "and a1.a_tab_eng_name = a2.a_tab_eng_name "
                   "and a1.a_fld_eng_name      =  a2.a_fld_eng_name "
                   "and a1.b_ssys_cd           =  a2.b_ssys_cd "
                   "and a1.b_mdl_name          =  a2.b_mdl_name "
                   "and a1.b_tab_eng_name      =  a2.b_tab_eng_name "
                   "and a1.b_fld_eng_name      =  a2.b_fld_eng_name "
                   "and a2.rela_type = 'set_flag' "
                   "where ((a1.a_ssys_cd,a1.a_mdl_name,a1.a_tab_eng_name,a1.a_fld_eng_name) "
                   "in (select ssys_cd,mdl_name,tab_eng_name,clas_value from  t_batch_tab_clas)"
                   "or (a1.b_ssys_cd,a1.b_mdl_name,a1.b_tab_eng_name,a1.b_fld_eng_name) "
                   "in (select ssys_cd,mdl_name,tab_eng_name,clas_value from  t_batch_tab_clas))"
                   "and ((a1.a_ssys_cd = :sysCode and a1.a_mdl_name = :mdlName "
                   "and a1.a_tab_eng_name = :tabName and a1.a_fld_eng_name = :fldName "
                   "and a2.rela_value = :rela_value)"
                   " or (a1.b_ssys_cd = :sysCode and a1.b_mdl_name = :mdlName "
                   "and a1.b_tab_eng_name = :tabName and a1.b_fld_eng_name = :fldName "
                   "and a2.rela_value = :rela_value2))")
        result = (await result_db.execute(sql, {"sysCode": column['ssys_cd'],
                                                "mdlName": column['mdl_name'], "tabName": column['tab_eng_name'],
                                                "fldName": column['fld_eng_name'],
                                                "rela_value": '2' if module == 'pre' else '1',
                                                "rela_value2": '1' if module == 'pre' else '2'
                                                }))
        # 获取列名
        columns = result.keys()  # 返回列名列表

        # 将结果转换为字典列表
        result_as_dict = [dict(zip(columns, row)) for row in result.fetchall()]
        return result_as_dict

    @classmethod
    async def get_op_relation_by_column(cls, result_db: AsyncSession, column: {}, module: str):
        sql = text("select a1.* ,case when a2.rela_value = '1' then 'A' when a2.rela_value = '2' then 'B' end AS father"
                   " from ( select  a_ssys_cd ,a_mdl_name ,a_tab_eng_name ,a_fld_eng_name ,b_ssys_cd ,b_mdl_name "
                   ",b_tab_eng_name,b_fld_eng_name from t_batch_fld_relation where rela_type  = 'op2_relation' "
                   "and rela_value <> '[]') a1 left join  t_batch_fld_relation a2 on a1.a_ssys_cd = a2.a_ssys_cd "
                   " and a1.a_mdl_name = a2.a_mdl_name and a1.a_tab_eng_name = a2.a_tab_eng_name and "
                   "a1.a_fld_eng_name = a2.a_fld_eng_name and a1.b_ssys_cd = a2.b_ssys_cd "
                   "and a1.b_mdl_name =  a2.b_mdl_name and a1.b_tab_eng_name = a2.b_tab_eng_name "
                   "and a1.b_fld_eng_name = a2.b_fld_eng_name and a2.rela_type = 'set_flag' and a2.rela_value <> 0 "
                   " where ((a1.a_ssys_cd,a1.a_mdl_name,a1.a_tab_eng_name,a1.a_fld_eng_name) in "
                   "(select ssys_cd,mdl_name,tab_eng_name,clas_value from  t_batch_tab_clas) "
                   "or (a1.b_ssys_cd,a1.b_mdl_name,a1.b_tab_eng_name,a1.b_fld_eng_name) in "
                   "(select ssys_cd,mdl_name,tab_eng_name,clas_value from  t_batch_tab_clas)) "
                   "and ((a1.a_ssys_cd = :sysCode and a1.a_mdl_name = :mdlName and a1.a_tab_eng_name = :tabName "
                   " and a1.a_fld_eng_name = :fldName and a2.rela_value = :rela_value) "
                   " or (a1.b_ssys_cd = :sysCode and a1.b_mdl_name = :mdlName and a1.b_tab_eng_name = :tabName "
                   " and a1.b_fld_eng_name = :fldName and a2.rela_value = :rela_value2))")
        result = (await result_db.execute(sql, {"sysCode": column['ssys_cd'],
                                                "mdlName": column['mdl_name'], "tabName": column['tab_eng_name'],
                                                "fldName": column['fld_eng_name'],
                                                "rela_value": '2' if module == 'pre' else '1',
                                                "rela_value2": '1' if module == 'pre' else '2'
                                                }))
        # 获取列名
        columns = result.keys()  # 返回列名列表

        # 将结果转换为字典列表
        result_as_dict = [dict(zip(columns, row)) for row in result.fetchall()]
        return result_as_dict