public string GetStatusCheck()
{
List <ApplyStatus> reviewStatusList = new List <ApplyStatus>();
ApplyProvider db = new ApplyProvider();
reviewStatusList = db.GetReviewStatus(Session[USRID].ToString());
return(JsonConvert.SerializeObject(reviewStatusList));
}
protected override Provider VisitApply(ApplyProvider provider)
{
// split
List <int> leftMapping;
List <int> rightMapping;
SplitMappings(provider, out leftMapping, out rightMapping);
ApplyParameter applyParameter = provider.ApplyParameter;
var currentOuterUsages = new List <int>();
outerColumnUsages.Add(applyParameter, currentOuterUsages);
outerColumnUsageVisitor.VisitCompilable(provider.Right);
outerColumnUsages.Remove(applyParameter);
leftMapping = Merge(leftMapping, currentOuterUsages);
if (leftMapping.Count == 0)
{
leftMapping.Add(0);
}
// visit
var oldMappings = ReplaceMappings(provider.Left, leftMapping);
CompilableProvider newLeftProvider = VisitCompilable(provider.Left);
leftMapping = mappings[provider.Left];
ReplaceMappings(provider.Right, rightMapping);
outerColumnUsages.Add(applyParameter, leftMapping);
CompilableProvider newRightProvider = VisitCompilable(provider.Right);
outerColumnUsages.Remove(applyParameter);
var pair = OverrideRightApplySource(provider, newRightProvider, rightMapping);
if (pair.First == null)
{
rightMapping = mappings[provider.Right];
}
else
{
newRightProvider = pair.First;
rightMapping = pair.Second;
}
RestoreMappings(oldMappings);
mappings[provider] = Merge(leftMapping, rightMapping.Select(map => map + provider.Left.Header.Length));
if (newLeftProvider == provider.Left && newRightProvider == provider.Right)
{
return(provider);
}
return(new ApplyProvider(applyParameter, newLeftProvider, newRightProvider, provider.IsInlined, provider.SequenceType, provider.ApplyType));
}
private Provider ProcesSelfConvertibleApply(ApplyProvider provider, CompilableProvider left,
CompilableProvider right)
{
if (State.Predicates.ContainsKey(provider.ApplyParameter))
{
State.Predicates.Remove(provider.ApplyParameter);
}
if (left != provider.Left || right != provider.Right)
{
return(new ApplyProvider(provider.ApplyParameter, left, right, provider.IsInlined, provider.SequenceType, provider.ApplyType));
}
return(provider);
}
protected override Provider VisitApply(ApplyProvider provider)
{
var left = VisitCompilable(provider.Left);
var leftOrder = sortOrder;
var right = VisitCompilable(provider.Right);
var rightOrder = sortOrder;
var result = left == provider.Left && right == provider.Right
? provider
: new ApplyProvider(provider.ApplyParameter, left, right, provider.IsInlined, provider.SequenceType, provider.ApplyType);
sortOrder = ComputeBinaryOrder(provider, leftOrder, rightOrder);
return(result);
}
private Provider InsertCalculateProviders(ApplyProvider provider, CompilableProvider convertedApply)
{
if (!State.CalculateProviders.ContainsKey(provider.ApplyParameter))
{
return(convertedApply);
}
var result = convertedApply;
foreach (var providerPair in State.CalculateProviders[provider.ApplyParameter])
{
result = RewriteCalculateColumnExpressions(providerPair, result);
result = InsertCalculateFilter(result, providerPair.First);
}
State.CalculateProviders.Remove(provider.ApplyParameter);
return(result);
}
public JsonResult AddApplyForAgain(string emsNumber)
{
string result = string.Empty;
string msg = string.Empty;
bool isSuccess = false;
if (!string.IsNullOrEmpty(emsNumber))
{
ApplyProvider db = new ApplyProvider();
//检查是否可以提交续领申请用药（即EMS号）1是可以提交。0 是不可以提交
db.CheckApplyIsSubmit(Session[USRID].ToString(), emsNumber, out result, out msg);
if (result == "1")
{
isSuccess = db.UpdatePatientAgainInfo(Session[USRID].ToString(), emsNumber);
}
}
return(Json(new { IsSuccess = isSuccess, errormsg = msg }, "text/html", JsonRequestBehavior.AllowGet));
}
private SqlSelect ProcessApplyViaCrossApply(ApplyProvider provider, SqlProvider left, SqlProvider right)
{
var leftShouldUseReference = ShouldUseQueryReference(provider, left);
var leftTable = leftShouldUseReference
? left.PermanentReference
: left.Request.Statement.From;
var leftColumns = leftShouldUseReference
? leftTable.Columns.Cast <SqlColumn>()
: left.Request.Statement.Columns;
var rightShouldUseReference = ShouldUseQueryReference(provider, right);
var rightTable = rightShouldUseReference
? right.PermanentReference
: right.Request.Statement.From;
var rightColumns = rightShouldUseReference
? rightTable.Columns.Cast <SqlColumn>()
: right.Request.Statement.Columns;
var joinType = provider.ApplyType == JoinType.LeftOuter
? SqlJoinType.LeftOuterApply
: SqlJoinType.CrossApply;
var joinedTable = SqlDml.Join(
joinType,
leftTable,
rightTable,
leftColumns.ToList(),
rightColumns.ToList());
var query = SqlDml.Select(joinedTable);
if (!leftShouldUseReference)
{
query.Where &= left.Request.Statement.Where;
}
if (!rightShouldUseReference)
{
query.Where &= right.Request.Statement.Where;
}
query.Columns.AddRange(joinedTable.AliasedColumns);
return(query);
}
protected override Provider VisitApply(ApplyProvider provider)
{
CompilableProvider left;
CompilableProvider right;
var isSelfConvertibleApply = provider.SequenceType != ApplySequenceType.All;
State.SelfConvertibleApplyProviders.Add(provider.ApplyParameter, isSelfConvertibleApply);
VisitBinaryProvider(provider, out left, out right);
State.SelfConvertibleApplyProviders.Remove(provider.ApplyParameter);
if (isSelfConvertibleApply)
{
return(ProcesSelfConvertibleApply(provider, left, right));
}
CompilableProvider convertedApply = !State.Predicates.ContainsKey(provider.ApplyParameter)
? new PredicateJoinProvider(left, right, (tLeft, tRight) => true, provider.ApplyType)
: ConvertGenericApply(provider, left, right);
return(InsertCalculateProviders(provider, convertedApply));
}
public string GetApplyFor()
{
ApplyProvider db = new ApplyProvider();
UsersProvider udb = new UsersProvider();
UsersModel patientOtherInfo = new UsersModel();
patientOtherInfo = udb.GetPatientInfor(Session[USRID].ToString());
patientOtherInfo.UserID = Session[USRID].ToString();
patientOtherInfo.IsGeneDetect = string.IsNullOrEmpty(patientOtherInfo.IsGeneDetect) ? "1" : patientOtherInfo.IsGeneDetect;
patientOtherInfo.Tumortage = string.IsNullOrEmpty(patientOtherInfo.Tumortage) ? "1" : patientOtherInfo.Tumortage;
patientOtherInfo.IsDiseaseDiagnosis = string.IsNullOrEmpty(patientOtherInfo.IsDiseaseDiagnosis) ? "1" : patientOtherInfo.IsDiseaseDiagnosis;
patientOtherInfo.IsAccordFiveMouth = string.IsNullOrEmpty(patientOtherInfo.IsAccordFiveMouth) ? "1" : patientOtherInfo.IsAccordFiveMouth;
//检查是否预约通过审核
string patientStatus = db.CheckPatientStatus(Session[USRID].ToString());
var data = new
{
patientStatus = patientStatus,
patientOtherInfo = patientOtherInfo
};
return(JsonConvert.SerializeObject(data));
}
private PredicateJoinProvider ConvertGenericApply(ApplyProvider provider, CompilableProvider left,
CompilableProvider right)
{
var oldPredicate = State.Predicates[provider.ApplyParameter];
Expression <Func <Tuple, Tuple, bool> > concatenatedPredicate = null;
foreach (var predicateAndColumns in oldPredicate)
{
var newPredicate = predicateRewriter.Rewrite(predicateAndColumns.First, predicateAndColumns.Second,
right.Header.Columns);
if (concatenatedPredicate == null)
{
concatenatedPredicate = newPredicate;
}
else
{
concatenatedPredicate = collectorHelper
.CreatePredicatesConjunction(newPredicate, concatenatedPredicate);
}
}
State.Predicates.Remove(provider.ApplyParameter);
return(new PredicateJoinProvider(left, right, concatenatedPredicate, provider.ApplyType));
}
//首次提交
public JsonResult AddApplyFor(string data)
{
bool result = false;
string errormsg = string.Empty;
if (!string.IsNullOrEmpty(data))
{
UsersModel patient = JsonConvert.DeserializeObject <UsersModel>(data);
ApplyProvider db = new ApplyProvider();
//首次申请用药提交前检查是否已经提交过。
if (!db.CheckApplyIsExist(Session[USRID].ToString()))
{
result = db.UpdatePatientOtherInfo(patient);
//更新完首次申请信息，然后提交一条申请
db.UpdatePatientAgainInfo(Session[USRID].ToString(), patient.EMSNumber);
}
else
{
errormsg = "您已经提交过首次申请用药！";
}
}
return(Json(new { IsSuccess = result, errormsg = errormsg }, "text/html", JsonRequestBehavior.AllowGet));
}
protected override Pair <CompilableProvider, List <int> > OverrideRightApplySource(ApplyProvider applyProvider, CompilableProvider provider, List <int> requestedMapping)
{
var currentMapping = mappings[applyProvider.Right];
if (currentMapping.SequenceEqual(requestedMapping))
{
return(base.OverrideRightApplySource(applyProvider, provider, requestedMapping));
}
var selectProvider = new SelectProvider(provider, requestedMapping.ToArray());
return(new Pair <CompilableProvider, List <int> >(selectProvider, requestedMapping));
}
protected virtual Pair <CompilableProvider, List <int> > OverrideRightApplySource(ApplyProvider applyProvider, CompilableProvider provider, List <int> requestedMapping)
{
return(new Pair <CompilableProvider, List <int> >(provider, requestedMapping));
}
/// <summary> /// Compiles <see cref="ApplyProvider"/>. /// </summary> /// <param name="provider">The provider.</param> protected abstract TResult VisitApply(ApplyProvider provider);
private SqlSelect ProcessApplyViaSubqueries(ApplyProvider provider, SqlProvider left, SqlProvider right, bool shouldUseQueryReference)
{
var rightQuery = right.Request.Statement;
SqlSelect query;
if (shouldUseQueryReference)
{
var leftTable = left.PermanentReference;
query = SqlDml.Select(leftTable);
query.Columns.AddRange(leftTable.Columns.Cast <SqlColumn>());
}
else
{
query = left.Request.Statement.ShallowClone();
}
var isApplyExistence =
provider.Right.Type == ProviderType.Existence ||
provider.Right.Type == ProviderType.Select && provider.Right.Sources[0].Type == ProviderType.Existence;
if (isApplyExistence)
{
for (int i = 0; i < rightQuery.Columns.Count; i++)
{
var column = rightQuery.Columns[i];
if (provider.IsInlined)
{
var columnStub = SqlDml.ColumnStub(column);
var userColumn = ExtractUserColumn(column);
stubColumnMap.Add(columnStub, userColumn.Expression);
column = columnStub;
}
query.Columns.Add(column);
}
}
else
{
if (provider.IsInlined)
{
for (int i = 0; i < rightQuery.Columns.Count; i++)
{
var subquery = rightQuery.ShallowClone();
var sqlColumn = subquery.Columns[i];
if (IsColumnStub(sqlColumn))
{
var columnStub = ExtractColumnStub(sqlColumn);
subquery.Columns.Clear();
subquery.Columns.Add(columnStub.Column);
query.Columns.Add(subquery, sqlColumn.Name);
}
else
{
var columnRef = (SqlColumnRef)sqlColumn;
var column = columnRef.SqlColumn;
subquery.Columns.Clear();
subquery.Columns.Add(column);
var columnName = ProcessAliasedName(provider.Right.Header.Columns[i].Name);
var userColumnRef = SqlDml.ColumnRef(SqlDml.Column(subquery), columnName);
var columnStub = SqlDml.ColumnStub(userColumnRef);
stubColumnMap.Add(columnStub, subquery);
query.Columns.Add(columnStub);
}
}
}
else
{
for (int i = 0; i < rightQuery.Columns.Count; i++)
{
var subquery = rightQuery.ShallowClone();
var column = subquery.Columns[i];
if (IsColumnStub(column))
{
var columnStub = ExtractColumnStub(column);
subquery.Columns.Clear();
subquery.Columns.Add(columnStub.Column);
query.Columns.Add(subquery, column.Name);
}
else
{
var columnRef = (SqlColumnRef)column;
var sqlColumn = columnRef.SqlColumn;
subquery.Columns.Clear();
subquery.Columns.Add(sqlColumn);
query.Columns.Add(subquery, columnRef.Name);
}
}
}
}
return(query);
}
/// <inheritdoc/>
protected override SqlProvider VisitApply(ApplyProvider provider)
{
bool processViaCrossApply;
switch (provider.SequenceType)
{
case ApplySequenceType.All:
// apply is required
if (!providerInfo.Supports(ProviderFeatures.Apply))
{
throw new NotSupportedException();
}
processViaCrossApply = true;
break;
case ApplySequenceType.First:
case ApplySequenceType.FirstOrDefault:
// apply is prefered but is not required
processViaCrossApply = providerInfo.Supports(ProviderFeatures.Apply);
break;
case ApplySequenceType.Single:
case ApplySequenceType.SingleOrDefault:
// apply is not allowed
processViaCrossApply = false;
break;
default:
throw new ArgumentOutOfRangeException();
}
var left = Compile(provider.Left);
bool shouldUseQueryReference;
var sourceSelect = left.Request.Statement;
if (processViaCrossApply)
{
shouldUseQueryReference = ShouldUseQueryReference(provider, left);
}
else
{
var calculatedColumnIndexes = sourceSelect.Columns
.Select((c, i) => IsCalculatedColumn(c) ? i : -1)
.Where(i => i >= 0)
.ToList();
var groupByIsUsed = sourceSelect.GroupBy.Count > 0;
var usedOuterColumns = new List <int>();
var visitor = new ApplyParameterAccessVisitor(provider.ApplyParameter, (mc, index) => {
usedOuterColumns.Add(index);
return(mc);
});
var providerVisitor = new CompilableProviderVisitor((p, e) => visitor.Visit(e));
providerVisitor.VisitCompilable(provider.Right);
shouldUseQueryReference = usedOuterColumns.Any(calculatedColumnIndexes.Contains) ||
groupByIsUsed ||
provider.Left.Type.In(ProviderType.Store, ProviderType.Include) ||
left.Header.Columns.Count != left.Request.Statement.Columns.Count;
}
var binding = OuterReferences.Add(
provider.ApplyParameter, new Pair <SqlProvider, bool>(left, shouldUseQueryReference));
using (binding) {
var right = Compile(provider.Right);
var query = processViaCrossApply
? ProcessApplyViaCrossApply(provider, left, right)
: ProcessApplyViaSubqueries(provider, left, right, shouldUseQueryReference);
return(CreateProvider(query, provider, left, right));
}
}
