601 lines
21 KiB
Python
601 lines
21 KiB
Python
from datetime import datetime
|
|
from typing import Any, Literal
|
|
|
|
from pydantic import BaseModel
|
|
from sqlalchemy import ColumnElement, Select, and_, delete, func, or_, select, update
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
from sqlalchemy.orm.attributes import InstrumentedAttribute
|
|
|
|
from common.vo import PageModel
|
|
from module_admin.entity.do.user_do import SysUser
|
|
from module_business.domain.enums import PalletFlowState
|
|
from module_business.entity.do.master_do import (
|
|
BizCustomer,
|
|
BizCustomerSite,
|
|
BizPallet,
|
|
BizProductionLine,
|
|
BizStrain,
|
|
BizUserSite,
|
|
BizUserWarehouse,
|
|
BizWarehouse,
|
|
)
|
|
from module_business.entity.do.operation_do import (
|
|
BizFillingRecord,
|
|
BizInboundItem,
|
|
BizInboundOrder,
|
|
BizPalletEvent,
|
|
BizPalletInventory,
|
|
BizReturnItem,
|
|
BizReturnOrder,
|
|
BizShipmentItem,
|
|
BizShipmentOrder,
|
|
BizUsageRecord,
|
|
)
|
|
from module_business.entity.vo.master_vo import (
|
|
CustomerModel,
|
|
CustomerPageQueryModel,
|
|
LineModel,
|
|
LinePageQueryModel,
|
|
PalletEditModel,
|
|
PalletPageQueryModel,
|
|
SiteModel,
|
|
SitePageQueryModel,
|
|
StrainModel,
|
|
StrainPageQueryModel,
|
|
WarehouseModel,
|
|
WarehousePageQueryModel,
|
|
)
|
|
from utils.page_util import PageUtil
|
|
|
|
MasterResource = Literal['strain', 'customer', 'site', 'line', 'warehouse']
|
|
|
|
|
|
_REFERENCE_COLUMNS: dict[MasterResource, tuple[tuple[InstrumentedAttribute, ...], ...]] = {
|
|
'strain': ((BizFillingRecord.strain_id,),),
|
|
'customer': ((BizCustomerSite.customer_id,),),
|
|
'site': (
|
|
(BizProductionLine.site_id,),
|
|
(BizUserSite.site_id,),
|
|
(BizShipmentOrder.target_site_id,),
|
|
(BizUsageRecord.site_id,),
|
|
(BizReturnOrder.source_site_id,),
|
|
(BizPalletInventory.site_id,),
|
|
(BizPalletEvent.before_site_id, BizPalletEvent.after_site_id),
|
|
),
|
|
'line': (
|
|
(BizUsageRecord.line_id,),
|
|
(BizPalletInventory.current_line_id,),
|
|
(BizPalletEvent.before_line_id, BizPalletEvent.after_line_id),
|
|
),
|
|
'warehouse': (
|
|
(BizUserWarehouse.warehouse_id,),
|
|
(BizInboundOrder.warehouse_id,),
|
|
(BizFillingRecord.warehouse_id,),
|
|
(BizShipmentOrder.source_warehouse_id,),
|
|
(BizReturnOrder.target_warehouse_id,),
|
|
(BizPalletInventory.warehouse_id,),
|
|
(BizPalletEvent.before_warehouse_id, BizPalletEvent.after_warehouse_id),
|
|
),
|
|
}
|
|
|
|
_PALLET_REMOVAL_BLOCKING_COLUMNS: tuple[InstrumentedAttribute, ...] = (
|
|
BizInboundItem.pallet_id,
|
|
BizFillingRecord.pallet_id,
|
|
BizShipmentItem.pallet_id,
|
|
BizUsageRecord.pallet_id,
|
|
BizReturnItem.pallet_id,
|
|
BizPalletEvent.pallet_id,
|
|
)
|
|
|
|
|
|
class MasterDao:
|
|
"""菌种、客户、现场、产线和仓库主数据数据库操作层。"""
|
|
|
|
@staticmethod
|
|
async def _paginate(
|
|
db: AsyncSession,
|
|
statement: Select,
|
|
query_object: BaseModel,
|
|
is_page: bool,
|
|
) -> PageModel | list[dict[str, Any]]:
|
|
return await PageUtil.paginate(
|
|
db,
|
|
statement,
|
|
query_object.page_num,
|
|
query_object.page_size,
|
|
is_page,
|
|
)
|
|
|
|
@staticmethod
|
|
async def _get(
|
|
db: AsyncSession,
|
|
model: type[Any],
|
|
id_column: InstrumentedAttribute,
|
|
resource_id: int,
|
|
*,
|
|
for_update: bool = False,
|
|
) -> Any | None:
|
|
statement = select(model).where(id_column == resource_id)
|
|
if for_update:
|
|
statement = statement.with_for_update().execution_options(populate_existing=True)
|
|
result = await db.execute(statement)
|
|
return result.scalar_one_or_none()
|
|
|
|
@staticmethod
|
|
async def _find(
|
|
db: AsyncSession,
|
|
model: type[Any],
|
|
code_column: InstrumentedAttribute,
|
|
code: str,
|
|
*scope_predicates: ColumnElement[bool],
|
|
) -> Any | None:
|
|
result = await db.execute(select(model).where(code_column == code, *scope_predicates))
|
|
return result.scalar_one_or_none()
|
|
|
|
@staticmethod
|
|
async def _add(
|
|
db: AsyncSession,
|
|
model: type[Any],
|
|
id_field: str,
|
|
page_object: BaseModel,
|
|
) -> Any:
|
|
payload = page_object.model_dump(exclude={id_field})
|
|
record = model(**payload)
|
|
db.add(record)
|
|
await db.flush()
|
|
return record
|
|
|
|
@staticmethod
|
|
async def _update(
|
|
db: AsyncSession,
|
|
model: type[Any],
|
|
id_column: InstrumentedAttribute,
|
|
id_field: str,
|
|
page_object: BaseModel,
|
|
) -> None:
|
|
payload = page_object.model_dump(
|
|
exclude_unset=True,
|
|
exclude={'create_by', 'create_time'},
|
|
)
|
|
resource_id = payload.pop(id_field)
|
|
await db.execute(update(model).where(id_column == resource_id).values(**payload))
|
|
|
|
@staticmethod
|
|
async def _delete(
|
|
db: AsyncSession,
|
|
model: type[Any],
|
|
id_column: InstrumentedAttribute,
|
|
resource_id: int,
|
|
) -> None:
|
|
await db.execute(delete(model).where(id_column == resource_id))
|
|
|
|
@classmethod
|
|
async def list_strain(
|
|
cls,
|
|
db: AsyncSession,
|
|
query_object: StrainPageQueryModel,
|
|
is_page: bool = True,
|
|
) -> PageModel | list[dict[str, Any]]:
|
|
conditions = []
|
|
if query_object.strain_code:
|
|
conditions.append(BizStrain.strain_code.like(f'%{query_object.strain_code}%'))
|
|
if query_object.strain_name:
|
|
conditions.append(BizStrain.strain_name.like(f'%{query_object.strain_name}%'))
|
|
if query_object.status:
|
|
conditions.append(BizStrain.status == query_object.status)
|
|
statement = select(BizStrain).where(*conditions).order_by(BizStrain.strain_id)
|
|
return await cls._paginate(db, statement, query_object, is_page)
|
|
|
|
@classmethod
|
|
async def get_strain(
|
|
cls,
|
|
db: AsyncSession,
|
|
strain_id: int,
|
|
*,
|
|
for_update: bool = False,
|
|
) -> BizStrain | None:
|
|
return await cls._get(
|
|
db,
|
|
BizStrain,
|
|
BizStrain.strain_id,
|
|
strain_id,
|
|
for_update=for_update,
|
|
)
|
|
|
|
@classmethod
|
|
async def find_strain_by_code(cls, db: AsyncSession, strain_code: str) -> BizStrain | None:
|
|
return await cls._find(db, BizStrain, BizStrain.strain_code, strain_code)
|
|
|
|
@classmethod
|
|
async def add_strain(cls, db: AsyncSession, strain: StrainModel) -> BizStrain:
|
|
return await cls._add(db, BizStrain, 'strain_id', strain)
|
|
|
|
@classmethod
|
|
async def update_strain(cls, db: AsyncSession, strain: StrainModel) -> None:
|
|
await cls._update(db, BizStrain, BizStrain.strain_id, 'strain_id', strain)
|
|
|
|
@classmethod
|
|
async def delete_strain(cls, db: AsyncSession, strain_id: int) -> None:
|
|
await cls._delete(db, BizStrain, BizStrain.strain_id, strain_id)
|
|
|
|
@classmethod
|
|
async def list_customer(
|
|
cls,
|
|
db: AsyncSession,
|
|
query_object: CustomerPageQueryModel,
|
|
is_page: bool = True,
|
|
) -> PageModel | list[dict[str, Any]]:
|
|
conditions = []
|
|
if query_object.customer_code:
|
|
conditions.append(BizCustomer.customer_code.like(f'%{query_object.customer_code}%'))
|
|
if query_object.customer_name:
|
|
conditions.append(BizCustomer.customer_name.like(f'%{query_object.customer_name}%'))
|
|
if query_object.status:
|
|
conditions.append(BizCustomer.status == query_object.status)
|
|
statement = select(BizCustomer).where(*conditions).order_by(BizCustomer.customer_id)
|
|
return await cls._paginate(db, statement, query_object, is_page)
|
|
|
|
@classmethod
|
|
async def get_customer(cls, db: AsyncSession, customer_id: int) -> BizCustomer | None:
|
|
return await cls._get(db, BizCustomer, BizCustomer.customer_id, customer_id)
|
|
|
|
@classmethod
|
|
async def find_customer_by_code(cls, db: AsyncSession, customer_code: str) -> BizCustomer | None:
|
|
return await cls._find(db, BizCustomer, BizCustomer.customer_code, customer_code)
|
|
|
|
@classmethod
|
|
async def add_customer(cls, db: AsyncSession, customer: CustomerModel) -> BizCustomer:
|
|
return await cls._add(db, BizCustomer, 'customer_id', customer)
|
|
|
|
@classmethod
|
|
async def update_customer(cls, db: AsyncSession, customer: CustomerModel) -> None:
|
|
await cls._update(db, BizCustomer, BizCustomer.customer_id, 'customer_id', customer)
|
|
|
|
@classmethod
|
|
async def delete_customer(cls, db: AsyncSession, customer_id: int) -> None:
|
|
await cls._delete(db, BizCustomer, BizCustomer.customer_id, customer_id)
|
|
|
|
@classmethod
|
|
async def list_site(
|
|
cls,
|
|
db: AsyncSession,
|
|
query_object: SitePageQueryModel,
|
|
is_page: bool = True,
|
|
) -> PageModel | list[dict[str, Any]]:
|
|
conditions = []
|
|
if query_object.customer_id:
|
|
conditions.append(BizCustomerSite.customer_id == query_object.customer_id)
|
|
if query_object.site_code:
|
|
conditions.append(BizCustomerSite.site_code.like(f'%{query_object.site_code}%'))
|
|
if query_object.site_name:
|
|
conditions.append(BizCustomerSite.site_name.like(f'%{query_object.site_name}%'))
|
|
if query_object.status:
|
|
conditions.append(BizCustomerSite.status == query_object.status)
|
|
statement = select(BizCustomerSite).where(*conditions).order_by(BizCustomerSite.site_id)
|
|
return await cls._paginate(db, statement, query_object, is_page)
|
|
|
|
@classmethod
|
|
async def get_site(
|
|
cls,
|
|
db: AsyncSession,
|
|
site_id: int,
|
|
*,
|
|
for_update: bool = False,
|
|
) -> BizCustomerSite | None:
|
|
return await cls._get(
|
|
db,
|
|
BizCustomerSite,
|
|
BizCustomerSite.site_id,
|
|
site_id,
|
|
for_update=for_update,
|
|
)
|
|
|
|
@classmethod
|
|
async def find_site_by_code(
|
|
cls,
|
|
db: AsyncSession,
|
|
site_code: str,
|
|
customer_id: int,
|
|
) -> BizCustomerSite | None:
|
|
return await cls._find(
|
|
db,
|
|
BizCustomerSite,
|
|
BizCustomerSite.site_code,
|
|
site_code,
|
|
BizCustomerSite.customer_id == customer_id,
|
|
)
|
|
|
|
@classmethod
|
|
async def add_site(cls, db: AsyncSession, site: SiteModel) -> BizCustomerSite:
|
|
return await cls._add(db, BizCustomerSite, 'site_id', site)
|
|
|
|
@classmethod
|
|
async def update_site(cls, db: AsyncSession, site: SiteModel) -> None:
|
|
await cls._update(db, BizCustomerSite, BizCustomerSite.site_id, 'site_id', site)
|
|
|
|
@classmethod
|
|
async def delete_site(cls, db: AsyncSession, site_id: int) -> None:
|
|
await cls._delete(db, BizCustomerSite, BizCustomerSite.site_id, site_id)
|
|
|
|
@classmethod
|
|
async def list_line(
|
|
cls,
|
|
db: AsyncSession,
|
|
query_object: LinePageQueryModel,
|
|
is_page: bool = True,
|
|
) -> PageModel | list[dict[str, Any]]:
|
|
conditions = []
|
|
if query_object.site_id:
|
|
conditions.append(BizProductionLine.site_id == query_object.site_id)
|
|
if query_object.line_code:
|
|
conditions.append(BizProductionLine.line_code.like(f'%{query_object.line_code}%'))
|
|
if query_object.line_name:
|
|
conditions.append(BizProductionLine.line_name.like(f'%{query_object.line_name}%'))
|
|
if query_object.status:
|
|
conditions.append(BizProductionLine.status == query_object.status)
|
|
statement = select(BizProductionLine).where(*conditions).order_by(BizProductionLine.line_id)
|
|
return await cls._paginate(db, statement, query_object, is_page)
|
|
|
|
@classmethod
|
|
async def get_line(cls, db: AsyncSession, line_id: int) -> BizProductionLine | None:
|
|
return await cls._get(db, BizProductionLine, BizProductionLine.line_id, line_id)
|
|
|
|
@classmethod
|
|
async def find_line_by_code(
|
|
cls,
|
|
db: AsyncSession,
|
|
line_code: str,
|
|
site_id: int,
|
|
) -> BizProductionLine | None:
|
|
return await cls._find(
|
|
db,
|
|
BizProductionLine,
|
|
BizProductionLine.line_code,
|
|
line_code,
|
|
BizProductionLine.site_id == site_id,
|
|
)
|
|
|
|
@classmethod
|
|
async def add_line(cls, db: AsyncSession, line: LineModel) -> BizProductionLine:
|
|
return await cls._add(db, BizProductionLine, 'line_id', line)
|
|
|
|
@classmethod
|
|
async def update_line(cls, db: AsyncSession, line: LineModel) -> None:
|
|
await cls._update(db, BizProductionLine, BizProductionLine.line_id, 'line_id', line)
|
|
|
|
@classmethod
|
|
async def delete_line(cls, db: AsyncSession, line_id: int) -> None:
|
|
await cls._delete(db, BizProductionLine, BizProductionLine.line_id, line_id)
|
|
|
|
@classmethod
|
|
async def list_warehouse(
|
|
cls,
|
|
db: AsyncSession,
|
|
query_object: WarehousePageQueryModel,
|
|
is_page: bool = True,
|
|
) -> PageModel | list[dict[str, Any]]:
|
|
conditions = []
|
|
if query_object.warehouse_code:
|
|
conditions.append(BizWarehouse.warehouse_code.like(f'%{query_object.warehouse_code}%'))
|
|
if query_object.warehouse_name:
|
|
conditions.append(BizWarehouse.warehouse_name.like(f'%{query_object.warehouse_name}%'))
|
|
if query_object.status:
|
|
conditions.append(BizWarehouse.status == query_object.status)
|
|
statement = select(BizWarehouse).where(*conditions).order_by(BizWarehouse.warehouse_id)
|
|
return await cls._paginate(db, statement, query_object, is_page)
|
|
|
|
@classmethod
|
|
async def get_warehouse(
|
|
cls,
|
|
db: AsyncSession,
|
|
warehouse_id: int,
|
|
*,
|
|
for_update: bool = False,
|
|
) -> BizWarehouse | None:
|
|
return await cls._get(
|
|
db,
|
|
BizWarehouse,
|
|
BizWarehouse.warehouse_id,
|
|
warehouse_id,
|
|
for_update=for_update,
|
|
)
|
|
|
|
@classmethod
|
|
async def find_warehouse_by_code(cls, db: AsyncSession, warehouse_code: str) -> BizWarehouse | None:
|
|
return await cls._find(db, BizWarehouse, BizWarehouse.warehouse_code, warehouse_code)
|
|
|
|
@classmethod
|
|
async def add_warehouse(cls, db: AsyncSession, warehouse: WarehouseModel) -> BizWarehouse:
|
|
return await cls._add(db, BizWarehouse, 'warehouse_id', warehouse)
|
|
|
|
@classmethod
|
|
async def update_warehouse(cls, db: AsyncSession, warehouse: WarehouseModel) -> None:
|
|
await cls._update(db, BizWarehouse, BizWarehouse.warehouse_id, 'warehouse_id', warehouse)
|
|
|
|
@classmethod
|
|
async def delete_warehouse(cls, db: AsyncSession, warehouse_id: int) -> None:
|
|
await cls._delete(db, BizWarehouse, BizWarehouse.warehouse_id, warehouse_id)
|
|
|
|
@classmethod
|
|
async def list_pallet(
|
|
cls,
|
|
db: AsyncSession,
|
|
query_object: PalletPageQueryModel,
|
|
is_page: bool = True,
|
|
) -> PageModel | list[dict[str, Any]]:
|
|
conditions = []
|
|
if query_object.pallet_code:
|
|
conditions.append(BizPallet.pallet_code.like(f'%{query_object.pallet_code}%'))
|
|
if query_object.asset_status:
|
|
conditions.append(BizPallet.asset_status == query_object.asset_status)
|
|
statement = select(BizPallet).where(*conditions).order_by(BizPallet.pallet_id)
|
|
return await cls._paginate(db, statement, query_object, is_page)
|
|
|
|
@classmethod
|
|
async def get_pallet(
|
|
cls,
|
|
db: AsyncSession,
|
|
pallet_id: int,
|
|
*,
|
|
for_update: bool = False,
|
|
) -> BizPallet | None:
|
|
statement = select(BizPallet).where(BizPallet.pallet_id == pallet_id)
|
|
if for_update:
|
|
statement = statement.with_for_update()
|
|
result = await db.execute(statement)
|
|
return result.scalar_one_or_none()
|
|
|
|
@classmethod
|
|
async def get_pallet_removability(
|
|
cls,
|
|
db: AsyncSession,
|
|
pallet_ids: list[int],
|
|
) -> dict[int, bool]:
|
|
"""批量判断托盘是否仍为未入库且没有任何业务引用。"""
|
|
removability = dict.fromkeys(pallet_ids, False)
|
|
if not pallet_ids:
|
|
return removability
|
|
|
|
has_unstocked_inventory = (
|
|
select(BizPalletInventory.pallet_id)
|
|
.where(
|
|
BizPalletInventory.pallet_id == BizPallet.pallet_id,
|
|
BizPalletInventory.flow_state == PalletFlowState.UNSTOCKED.value,
|
|
)
|
|
.exists()
|
|
)
|
|
has_no_business_references = tuple(
|
|
~select(column).where(column == BizPallet.pallet_id).exists() for column in _PALLET_REMOVAL_BLOCKING_COLUMNS
|
|
)
|
|
statement = select(
|
|
BizPallet.pallet_id,
|
|
and_(has_unstocked_inventory, *has_no_business_references).label('can_remove'),
|
|
).where(BizPallet.pallet_id.in_(pallet_ids))
|
|
result = await db.execute(statement)
|
|
for pallet_id, can_remove in result.all():
|
|
removability[pallet_id] = bool(can_remove)
|
|
return removability
|
|
|
|
@classmethod
|
|
async def find_pallet_by_code(cls, db: AsyncSession, pallet_code: str) -> BizPallet | None:
|
|
return await cls._find(db, BizPallet, BizPallet.pallet_code, pallet_code)
|
|
|
|
@classmethod
|
|
async def add_pallet(cls, db: AsyncSession, pallet: BizPallet) -> BizPallet:
|
|
db.add(pallet)
|
|
await db.flush()
|
|
return pallet
|
|
|
|
@classmethod
|
|
async def update_pallet(
|
|
cls,
|
|
db: AsyncSession,
|
|
pallet: PalletEditModel,
|
|
update_by: str,
|
|
update_time: datetime,
|
|
) -> None:
|
|
await db.execute(
|
|
update(BizPallet)
|
|
.where(BizPallet.pallet_id == pallet.pallet_id)
|
|
.values(
|
|
capacity_packages=pallet.capacity_packages,
|
|
asset_status=pallet.asset_status,
|
|
remark=pallet.remark,
|
|
update_by=update_by,
|
|
update_time=update_time,
|
|
)
|
|
)
|
|
|
|
@classmethod
|
|
async def delete_pallet(cls, db: AsyncSession, pallet_id: int) -> None:
|
|
await cls._delete(db, BizPallet, BizPallet.pallet_id, pallet_id)
|
|
|
|
@classmethod
|
|
async def get_pallet_inventory(
|
|
cls,
|
|
db: AsyncSession,
|
|
pallet_id: int,
|
|
*,
|
|
for_update: bool = False,
|
|
) -> BizPalletInventory | None:
|
|
statement = select(BizPalletInventory).where(BizPalletInventory.pallet_id == pallet_id)
|
|
if for_update:
|
|
statement = statement.with_for_update()
|
|
result = await db.execute(statement)
|
|
return result.scalar_one_or_none()
|
|
|
|
@classmethod
|
|
async def add_pallet_inventory(
|
|
cls,
|
|
db: AsyncSession,
|
|
inventory: BizPalletInventory,
|
|
) -> BizPalletInventory:
|
|
db.add(inventory)
|
|
await db.flush()
|
|
return inventory
|
|
|
|
@classmethod
|
|
async def delete_pallet_inventory(cls, db: AsyncSession, pallet_id: int) -> None:
|
|
await cls._delete(db, BizPalletInventory, BizPalletInventory.pallet_id, pallet_id)
|
|
|
|
@classmethod
|
|
async def count_pallet_events(cls, db: AsyncSession, pallet_id: int) -> int:
|
|
result = await db.execute(
|
|
select(func.count('*')).select_from(BizPalletEvent).where(BizPalletEvent.pallet_id == pallet_id)
|
|
)
|
|
return result.scalar() or 0
|
|
|
|
@classmethod
|
|
async def list_assignable_users(cls, db: AsyncSession) -> list[Any]:
|
|
result = await db.execute(
|
|
select(SysUser.user_id, SysUser.user_name, SysUser.nick_name)
|
|
.where(SysUser.status == '0', SysUser.del_flag == '0')
|
|
.order_by(SysUser.user_id)
|
|
)
|
|
return list(result.all())
|
|
|
|
@classmethod
|
|
async def list_assignable_users_by_ids(cls, db: AsyncSession, user_ids: list[int]) -> list[Any]:
|
|
if not user_ids:
|
|
return []
|
|
result = await db.execute(
|
|
select(SysUser.user_id, SysUser.user_name, SysUser.nick_name)
|
|
.where(
|
|
SysUser.user_id.in_(user_ids),
|
|
SysUser.status == '0',
|
|
SysUser.del_flag == '0',
|
|
)
|
|
.order_by(SysUser.user_id)
|
|
)
|
|
return list(result.all())
|
|
|
|
@classmethod
|
|
async def list_warehouse_assigned_user_ids(cls, db: AsyncSession, warehouse_id: int) -> list[int]:
|
|
result = await db.execute(select(BizUserWarehouse.user_id).where(BizUserWarehouse.warehouse_id == warehouse_id))
|
|
return list(result.scalars().all())
|
|
|
|
@classmethod
|
|
async def list_site_assigned_user_ids(cls, db: AsyncSession, site_id: int) -> list[int]:
|
|
result = await db.execute(select(BizUserSite.user_id).where(BizUserSite.site_id == site_id))
|
|
return list(result.scalars().all())
|
|
|
|
@classmethod
|
|
async def count_references(
|
|
cls,
|
|
db: AsyncSession,
|
|
resource_type: MasterResource,
|
|
resource_id: int,
|
|
) -> int:
|
|
"""统计主数据的所有直接外键引用；同表的多个位置字段按一行计数。"""
|
|
references = _REFERENCE_COLUMNS.get(resource_type)
|
|
if references is None:
|
|
raise ValueError(f'不支持的主数据类型：{resource_type}')
|
|
|
|
total = 0
|
|
for columns in references:
|
|
predicates = [column == resource_id for column in columns]
|
|
predicate = predicates[0] if len(predicates) == 1 else or_(*predicates)
|
|
result = await db.execute(select(func.count('*')).select_from(columns[0].class_).where(predicate))
|
|
total += result.scalar() or 0
|
|
return total
|