private static string DoBuildQueryString(EntityMetadata entityMetadata, InternalQueryRequest queryParameter,
QueryCacheKey.QueryMode queryMode, IWhereBuilder compositeWhereBuilder, QueryCacheKey cacheKey)
{
var buffer = new StringBuilder(InitialStringBuilderCapacity);
var projectionBuilder = new StringBuilder(InitialStringBuilderCapacity);
projectionBuilder.Append(QuerySelectBuilder.BuildSelectAttributesClause(entityMetadata, queryMode, queryParameter.SearchDTO));
projectionBuilder.Append(QueryFromBuilder.Build(entityMetadata, queryParameter.SearchDTO));
buffer.Append(projectionBuilder);
buffer.Append(compositeWhereBuilder.BuildWhereClause(entityMetadata.Name, queryMode, queryParameter.SearchDTO));
var hasUnionWhereClauses = queryParameter.SearchDTO != null && queryParameter.SearchDTO.UnionWhereClauses != null;
var isUnion = entityMetadata.HasUnion() || queryMode == QueryCacheKey.QueryMode.Union || hasUnionWhereClauses;
if (queryMode != QueryCacheKey.QueryMode.Count && queryMode != QueryCacheKey.QueryMode.Detail && !isUnion)
{
buffer.Append(QuerySearchSortBuilder.BuildSearchSort(entityMetadata, queryParameter.SearchDTO));
}
if (hasUnionWhereClauses)
{
foreach (var unionWC in queryParameter.SearchDTO.UnionWhereClauses)
{
buffer.Append(" union all ").Append(projectionBuilder).Append(" where (").Append(unionWC).Append(")");
}
buffer.Append(" order by 1 desc");
}
var queryString = buffer.ToString();
return(queryString);
}
public async Task <int> GetDispObservationsCountAsync(IWhereBuilder <DispObservation> dispObservationBuilder)
{
if (dispObservationBuilder == default)
{
throw new ArgumentNullException(nameof(dispObservationBuilder));
}
return(await dispObservationBuilder.Where(MedicContext.DispObservations)
.CountAsync());
}
public async Task <int> GetTrasnfersCountAsync(IWhereBuilder <Transfer> transferBuilder)
{
if (transferBuilder == default)
{
throw new ArgumentNullException(nameof(transferBuilder));
}
return(await transferBuilder.Where(MedicContext.Transfers)
.CountAsync());
}
public async Task <int> GetCommissionAprsCountAsync(IWhereBuilder <CommissionApr> commissionAprWhereBuilder)
{
if (commissionAprWhereBuilder == default)
{
throw new ArgumentNullException(nameof(commissionAprWhereBuilder));
}
return(await commissionAprWhereBuilder.Where(MedicContext.CommissionAprs)
.CountAsync());
}
public async Task <int> GetInClinicProceduresCountAsync(IWhereBuilder <InClinicProcedure> inClinicProcedureBuilder)
{
if (inClinicProcedureBuilder == default)
{
throw new ArgumentNullException(nameof(inClinicProcedureBuilder));
}
return(await inClinicProcedureBuilder.Where(MedicContext.InClinicProcedures)
.CountAsync());
}
public async Task <int> GetProtocolDrugTherapiesCountAsync(IWhereBuilder <ProtocolDrugTherapy> protocolDrugTherapyBuilder)
{
if (protocolDrugTherapyBuilder == default)
{
throw new ArgumentNullException(nameof(protocolDrugTherapyBuilder));
}
return(await protocolDrugTherapyBuilder.Where(MedicContext.ProtocolDrugTherapies)
.CountAsync());
}
public async Task <int> GetPlanningsCountAsync(IWhereBuilder <Planned> plannedProcedureBuilder)
{
if (plannedProcedureBuilder == default)
{
throw new ArgumentNullException(nameof(plannedProcedureBuilder));
}
return(await plannedProcedureBuilder.Where(MedicContext.Plannings)
.CountAsync());
}
public async Task <int> GetPathProceduresCountAsync(IWhereBuilder <PathProcedure> pathProcedureBuilder)
{
if (pathProcedureBuilder == default)
{
throw new ArgumentNullException(nameof(pathProcedureBuilder));
}
return(await pathProcedureBuilder.Where(MedicContext.PathProcedures)
.CountAsync());
}
public async Task <int> GetOutsCountAsync(IWhereBuilder <Out> outBuilder)
{
if (outBuilder == default)
{
throw new ArgumentNullException(nameof(outBuilder));
}
return(await outBuilder.Where(MedicContext.Outs)
.CountAsync());
}
public SelectQuery(IWhereBuilder whereBuilder,
ISelectFromBuilder fromBuilder,
IOrderBuilder orderBuilder,
LimitBuilder limitBuilder,
bool existsQuery)
{
_whereBuilder = whereBuilder;
_fromBuilder = fromBuilder;
_orderBuilder = orderBuilder;
_limitBuilder = limitBuilder;
_existsQuery = existsQuery;
}
private string BuildWhereStatment()
{
string strWhere = String.Empty;
if (WhereConditions.Count > 0)
{
StringBuilder strWhereBuilder = new StringBuilder(" WHERE ");
_whereBuilderUsed = CreateWhereBuilder();
strWhereBuilder.Append(_whereBuilderUsed.BuildWhere(WhereConditions));
strWhere = strWhereBuilder.ToString();
}
return(strWhere);
}
public async Task <List <TransferPreviewViewModel> > GetTrasnfersAsync(IWhereBuilder <Transfer> transferBuilder, IHelperBuilder <Transfer> helperBuilder, int startIndex)
{
if (transferBuilder == default)
{
throw new ArgumentNullException(nameof(transferBuilder));
}
if (helperBuilder == default)
{
throw new ArgumentNullException(nameof(helperBuilder));
}
return(await helperBuilder.BuildQuery(transferBuilder.Where(MedicContext.Transfers).Skip(startIndex))
.ProjectTo <TransferPreviewViewModel>(Configuration)
.ToListAsync());
}
public async Task <List <PlannedPreviewViewModel> > GetPlanningsAsync(
IWhereBuilder <Planned> plannedProcedureBuilder,
IHelperBuilder <Planned> helperBuilder,
int startIndex)
{
if (plannedProcedureBuilder == default)
{
throw new ArgumentNullException(nameof(plannedProcedureBuilder));
}
if (helperBuilder == default)
{
throw new ArgumentNullException(nameof(helperBuilder));
}
return(await helperBuilder.BuildQuery(plannedProcedureBuilder.Where(MedicContext.Plannings).Skip(startIndex))
.ProjectTo <PlannedPreviewViewModel>(Configuration)
.ToListAsync());
}
public async Task <List <ProtocolDrugTherapyPreviewViewModel> > GetProtocolDrugTherapiesAsync(
IWhereBuilder <ProtocolDrugTherapy> protocolDrugTherapyBuilder,
IHelperBuilder <ProtocolDrugTherapy> helperBuilder,
int startIndex)
{
if (protocolDrugTherapyBuilder == default)
{
throw new ArgumentNullException(nameof(protocolDrugTherapyBuilder));
}
if (helperBuilder == default)
{
throw new ArgumentNullException(nameof(helperBuilder));
}
return(await helperBuilder.BuildQuery(protocolDrugTherapyBuilder.Where(MedicContext.ProtocolDrugTherapies).Skip(startIndex))
.ProjectTo <ProtocolDrugTherapyPreviewViewModel>(Configuration)
.ToListAsync());
}
public async Task <List <InClinicProcedurePreviewViewModel> > GetInClinicProceduresAsync(
IWhereBuilder <InClinicProcedure> inClinicProcedureBuilder,
IHelperBuilder <InClinicProcedure> helperBuilder,
int startIndex)
{
if (inClinicProcedureBuilder == default)
{
throw new ArgumentNullException(nameof(inClinicProcedureBuilder));
}
if (helperBuilder == default)
{
throw new ArgumentNullException(nameof(helperBuilder));
}
return(await helperBuilder.BuildQuery(inClinicProcedureBuilder.Where(MedicContext.InClinicProcedures).Skip(startIndex))
.ProjectTo <InClinicProcedurePreviewViewModel>(Configuration)
.ToListAsync());
}
public async Task <List <DispObservationPreviewViewModel> > GetDispObservationsAsync(
IWhereBuilder <DispObservation> dispObservationBuilder,
IHelperBuilder <DispObservation> helperBuilder,
int startIndex)
{
if (dispObservationBuilder == default)
{
throw new ArgumentNullException(nameof(dispObservationBuilder));
}
if (helperBuilder == default)
{
throw new ArgumentNullException(nameof(helperBuilder));
}
return(await helperBuilder.BuildQuery(dispObservationBuilder.Where(MedicContext.DispObservations.Skip(startIndex)))
.ProjectTo <DispObservationPreviewViewModel>(Configuration)
.ToListAsync());
}
/// <summary>
/// 向生成器中追加查询条件
/// </summary>
/// <param name="wheres">生成器对象</param>
/// <param name="anotherWhere">新增的查询条件</param>
/// <returns></returns>
public static IWhereBuilder Append(this IWhereBuilder wheres, string anotherWhere)
{
wheres.Append(anotherWhere);
return(wheres);
}
