public CodegenExpression MakeCodegen(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(ContextControllerDetailInitiatedTerminated), GetType(), classScope);
method.Block
.DeclareVar<ContextControllerDetailInitiatedTerminated>(
"detail",
NewInstance(typeof(ContextControllerDetailInitiatedTerminated)))
.SetProperty(Ref("detail"), "StartCondition", StartCondition.Make(method, symbols, classScope))
.SetProperty(Ref("detail"), "EndCondition", EndCondition.Make(method, symbols, classScope))
.SetProperty(Ref("detail"), "IsOverlapping", Constant(IsOverlapping));
if (DistinctExpressions != null && DistinctExpressions.Length > 0) {
method.Block
.SetProperty(
Ref("detail"),
"DistinctEval",
ExprNodeUtilityCodegen.CodegenEvaluatorMayMultiKeyWCoerce(
ExprNodeUtilityQuery.GetForges(DistinctExpressions),
null,
method,
GetType(),
classScope))
.SetProperty(
Ref("detail"),
"DistinctTypes",
Constant(ExprNodeUtilityQuery.GetExprResultTypes(DistinctExpressions)));
}
method.Block.MethodReturn(Ref("detail"));
return LocalMethod(method);
}
public override ExprNode Validate(ExprValidationContext validationContext)
{
if (ChildNodes.Length != 3) {
throw new ExprValidationException("The Between operator requires exactly 3 child expressions");
}
// Must be either numeric or string
var forges = ExprNodeUtilityQuery.GetForges(ChildNodes);
var typeOne = forges[0].EvaluationType.GetBoxedType();
var typeTwo = forges[1].EvaluationType.GetBoxedType();
var typeThree = forges[2].EvaluationType.GetBoxedType();
if (typeOne == null) {
throw new ExprValidationException("Null value not allowed in between-clause");
}
Type compareType;
var isAlwaysFalse = false;
ExprBetweenComp computer = null;
if (typeTwo == null || typeThree == null) {
isAlwaysFalse = true;
}
else {
if (typeOne != typeof(string) || typeTwo != typeof(string) || typeThree != typeof(string)) {
if (!typeOne.IsNumeric()) {
throw new ExprValidationException(
"Implicit conversion from datatype '" +
typeOne.CleanName() +
"' to numeric is not allowed");
}
if (!typeTwo.IsNumeric()) {
throw new ExprValidationException(
"Implicit conversion from datatype '" +
typeTwo.CleanName() +
"' to numeric is not allowed");
}
if (!typeThree.IsNumeric()) {
throw new ExprValidationException(
"Implicit conversion from datatype '" +
typeThree.CleanName() +
"' to numeric is not allowed");
}
}
var intermedType = typeOne.GetCompareToCoercionType(typeTwo);
compareType = intermedType.GetCompareToCoercionType(typeThree);
computer = MakeComputer(compareType, typeOne, typeTwo, typeThree);
}
_forge = new ExprBetweenNodeForge(this, computer, isAlwaysFalse);
return null;
}
protected void ValidateGroupKeys(
TableMetaData metadata,
ExprValidationContext validationContext)
{
if (ChildNodes.Length > 0) {
groupKeyEvaluators = ExprNodeUtilityQuery.GetForges(ChildNodes);
}
else {
groupKeyEvaluators = new ExprForge[0];
}
var typesReturned = ExprNodeUtilityQuery.GetExprResultTypes(ChildNodes);
var keyTypes = metadata.IsKeyed ? metadata.KeyTypes : new Type[0];
ExprTableNodeUtil.ValidateExpressions(TableName, typesReturned, "key", ChildNodes, keyTypes, "key");
}
public override IList<StmtClassForgeableFactory> Validate(
StreamTypeService typeService,
StatementBaseInfo @base,
StatementCompileTimeServices services)
{
int count = 0;
ExprValidationContext validationContext =
new ExprValidationContextBuilder(typeService, @base.StatementRawInfo, services)
.WithAllowBindingConsumption(true)
.Build();
ExprNode[] inputParamNodes = new ExprNode[inputParameters.Length];
foreach (string inputParam in inputParameters) {
ExprNode raw = FindSQLExpressionNode(StreamNum, count, @base.StatementSpec.Raw.SqlParameters);
if (raw == null) {
throw new ExprValidationException(
"Internal error find expression for historical stream parameter " +
count +
" stream " +
StreamNum);
}
ExprNode evaluator = ExprNodeUtilityValidate.GetValidatedSubtree(
ExprNodeOrigin.DATABASEPOLL,
raw,
validationContext);
inputParamNodes[count++] = evaluator;
ExprNodeIdentifierCollectVisitor visitor = new ExprNodeIdentifierCollectVisitor();
visitor.Visit(evaluator);
foreach (ExprIdentNode identNode in visitor.ExprProperties) {
if (identNode.StreamId == StreamNum) {
throw new ExprValidationException(
"Invalid expression '" + inputParam + "' resolves to the historical data itself");
}
SubordinateStreams.Add(identNode.StreamId);
}
}
InputParamEvaluators = ExprNodeUtilityQuery.GetForges(inputParamNodes);
// plan multikey
MultiKeyPlan multiKeyPlan = MultiKeyPlanner.PlanMultiKey(InputParamEvaluators, false, @base.StatementRawInfo, services.SerdeResolver);
MultiKeyClassRef = multiKeyPlan.ClassRef;
return multiKeyPlan.MultiKeyForgeables;
}
public static InstanceManufacturerFactory GetManufacturer(
Type targetClass,
ImportServiceCompileTime importService,
ExprNode[] childNodes)
{
var forgesUnmodified = ExprNodeUtilityQuery.GetForges(childNodes);
var returnTypes = new object[forgesUnmodified.Length];
for (var i = 0; i < forgesUnmodified.Length; i++) {
returnTypes[i] = forgesUnmodified[i].EvaluationType;
}
var ctor = InstanceManufacturerUtil.GetManufacturer(
targetClass,
importService,
forgesUnmodified,
returnTypes);
return new InstanceManufacturerFactoryFastCtor(targetClass, ctor.First, ctor.Second);
}
public static CodegenExpression CodegenExprEvaluatorMayMultikey(
ExprNode[] expressionNodes,
Type[] optionalCoercionTypes,
MultiKeyClassRef multiKeyClassRef,
CodegenMethod method,
CodegenClassScope classScope)
{
if (expressionNodes == null || expressionNodes.Length == 0)
{
return(ConstantNull());
}
return(CodegenExprEvaluatorMayMultikey(
ExprNodeUtilityQuery.GetForges(expressionNodes),
optionalCoercionTypes,
multiKeyClassRef,
method,
classScope));
}
public override IList<StmtClassForgeableFactory> Validate(
StreamTypeService typeService,
StatementBaseInfo @base,
StatementCompileTimeServices services)
{
// validate and visit
var validationContext = new ExprValidationContextBuilder(typeService, @base.StatementRawInfo, services)
.WithAllowBindingConsumption(true)
.Build();
var visitor = new ExprNodeIdentifierAndStreamRefVisitor(true);
var validatedInputParameters = new List<ExprNode>();
foreach (var exprNode in methodStreamSpec.Expressions) {
var validated = ExprNodeUtilityValidate.GetValidatedSubtree(
ExprNodeOrigin.METHODINVJOIN,
exprNode,
validationContext);
validatedInputParameters.Add(validated);
validated.Accept(visitor);
}
// determine required streams
foreach (ExprNodePropOrStreamDesc @ref in visitor.Refs) {
SubordinateStreams.Add(@ref.StreamNum);
}
// class-based evaluation
MethodInfo targetMethod = null;
if (metadata.MethodProviderClass != null) {
// resolve actual method to use
ExprNodeUtilResolveExceptionHandler handler = new ProxyExprNodeUtilResolveExceptionHandler {
ProcHandle = e => {
if (methodStreamSpec.Expressions.Count == 0) {
return new ExprValidationException(
"Method footprint does not match the number or type of expression parameters, expecting no parameters in method: " +
e.Message);
}
var resultTypes = ExprNodeUtilityQuery.GetExprResultTypes(validatedInputParameters);
return new ExprValidationException(
"Method footprint does not match the number or type of expression parameters, expecting a method where parameters are typed '" +
TypeHelper.GetParameterAsString(resultTypes) +
"': " +
e.Message);
}
};
var desc = ExprNodeUtilityResolve.ResolveMethodAllowWildcardAndStream(
metadata.MethodProviderClass.FullName,
metadata.IsStaticMethod ? null : metadata.MethodProviderClass,
methodStreamSpec.MethodName,
validatedInputParameters,
false,
null,
handler,
methodStreamSpec.MethodName,
@base.StatementRawInfo,
services);
InputParamEvaluators = desc.ChildForges;
targetMethod = desc.ReflectionMethod;
}
else {
// script-based evaluation
InputParamEvaluators = ExprNodeUtilityQuery.GetForges(ExprNodeUtilityQuery.ToArray(validatedInputParameters));
}
// plan multikey
MultiKeyPlan multiKeyPlan = MultiKeyPlanner.PlanMultiKey(InputParamEvaluators, false, @base.StatementRawInfo, services.SerdeResolver);
MultiKeyClassRef = multiKeyPlan.ClassRef;
Pair<MethodTargetStrategyForge, MethodConversionStrategyForge> strategies =
PollExecStrategyPlanner.Plan(metadata, targetMethod, EventType);
target = strategies.First;
conversion = strategies.Second;
return multiKeyPlan.MultiKeyForgeables;
}
// Obtain those method and state factories for each level
private static AggregationLocalGroupByLevelForge GetLevel(
int levelNumber,
AggregationGroupByLocalGroupLevel level,
ExprForge[][] methodForgesAll,
AggregationForgeFactory[] methodFactoriesAll,
AggregationStateFactoryForge[] accessForges,
AggregationLocalGroupByColumnForge[] columns,
bool defaultLevel,
AggregationAccessorSlotPairForge[] accessors,
ImportService importService,
bool isFireAndForget,
string statementName)
{
var partitionExpr = level.PartitionExpr;
ExprForge[] partitionForges = ExprNodeUtilityQuery.GetForges(partitionExpr);
IList<ExprForge[]> methodForges = new List<ExprForge[]>();
IList<AggregationForgeFactory> methodFactories = new List<AggregationForgeFactory>();
IList<AggregationStateFactoryForge> stateFactories = new List<AggregationStateFactoryForge>();
foreach (var expr in level.Expressions) {
int column = expr.AggregationNode.Column;
var methodOffset = -1;
var methodAgg = true;
AggregationAccessorSlotPairForge pair = null;
if (column < methodForgesAll.Length) {
methodForges.Add(methodForgesAll[column]);
methodFactories.Add(methodFactoriesAll[column]);
methodOffset = methodFactories.Count - 1;
}
else {
// slot gives us the number of the state factory
int absoluteSlot = accessors[column - methodForgesAll.Length].Slot;
AggregationAccessorForge accessor = accessors[column - methodForgesAll.Length].AccessorForge;
var factory = accessForges[absoluteSlot];
var relativeSlot = stateFactories.IndexOf(factory);
if (relativeSlot == -1) {
stateFactories.Add(factory);
relativeSlot = stateFactories.Count - 1;
}
methodAgg = false;
pair = new AggregationAccessorSlotPairForge(relativeSlot, accessor);
}
columns[column] = new AggregationLocalGroupByColumnForge(
defaultLevel,
partitionForges,
methodOffset,
methodAgg,
pair,
levelNumber);
}
return new AggregationLocalGroupByLevelForge(
methodForges.ToArray(),
methodFactories.ToArray(),
stateFactories.ToArray(),
partitionForges,
defaultLevel);
}
public static CodegenExpression Codegen(
ExprInNodeForge forge,
CodegenMethodScope codegenMethodScope,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
var forges = ExprNodeUtilityQuery.GetForges(forge.ForgeRenderable.ChildNodes);
var isNot = forge.ForgeRenderable.IsNotIn;
var methodNode = codegenMethodScope.MakeChild(
typeof(bool?),
typeof(ExprInNodeForgeEvalWColl),
codegenClassScope);
var block = methodNode.Block
.DeclareVar<bool>("hasNullRow", ConstantFalse());
var leftTypeUncoerced = forges[0].EvaluationType.GetBoxedType();
var leftTypeCoerced = forge.CoercionType.GetBoxedType();
block.DeclareVar(
leftTypeUncoerced,
"left",
forges[0].EvaluateCodegen(leftTypeUncoerced, methodNode, exprSymbol, codegenClassScope));
block.DeclareVar(
forge.CoercionType,
"leftCoerced",
!forge.IsMustCoerce
? Ref("left")
: forge.Coercer.CoerceCodegenMayNullBoxed(
Ref("left"),
leftTypeUncoerced,
methodNode,
codegenClassScope));
for (var i = 1; i < forges.Length; i++) {
var reftype = forges[i].EvaluationType.GetBoxedType();
var refforge = forges[i];
var refname = "r" + i;
if (reftype == null) {
block.AssignRef("hasNullRow", ConstantTrue());
continue;
}
block.DeclareVar(
reftype,
refname,
refforge.EvaluateCodegen(reftype, methodNode, exprSymbol, codegenClassScope));
if (reftype.IsArray) {
var ifRightNotNull = block.IfCondition(NotEqualsNull(Ref(refname)));
{
if (leftTypeUncoerced.CanBeNull()) {
ifRightNotNull.IfCondition(
And(
Relational(ArrayLength(Ref(refname)), GT, Constant(0)),
EqualsNull(Ref("left"))))
.BlockReturn(ConstantNull());
}
var forLoop = ifRightNotNull.ForLoopIntSimple("index", ArrayLength(Ref(refname)));
{
forLoop.DeclareVar(
reftype.GetElementType(),
"item",
ArrayAtIndex(Ref(refname), Ref("index")));
forLoop.DeclareVar<bool>(
"itemNull",
reftype.GetElementType().CanNotBeNull() ? ConstantFalse() : EqualsNull(Ref("item")));
var itemNotNull = forLoop.IfCondition(Ref("itemNull"))
.AssignRef("hasNullRow", ConstantTrue())
.IfElse();
{
if (!forge.IsMustCoerce) {
itemNotNull.IfCondition(
CodegenLegoCompareEquals.CodegenEqualsNonNullNoCoerce(
Ref("leftCoerced"),
leftTypeCoerced,
Ref("item"),
reftype.GetElementType()))
.BlockReturn(!isNot ? ConstantTrue() : ConstantFalse());
}
else {
if (TypeHelper.IsNumeric(reftype.GetElementType())) {
itemNotNull.IfCondition(
CodegenLegoCompareEquals.CodegenEqualsNonNullNoCoerce(
Ref("leftCoerced"),
leftTypeCoerced,
forge.Coercer.CoerceCodegen(Ref("item"), reftype.GetElementType()),
forge.CoercionType))
.BlockReturn(!isNot ? ConstantTrue() : ConstantFalse());
}
}
}
}
}
}
else if (reftype.IsGenericDictionary()) {
var ifRightNotNull = block.IfCondition(NotEqualsNull(Ref(refname)));
{
if (leftTypeUncoerced.CanBeNull()) {
ifRightNotNull.IfRefNullReturnNull("left");
}
var leftWithBoxing = ExprEqualsAllAnyNodeForgeHelper.ItemToCollectionUnboxing(
Ref("left"), leftTypeUncoerced, reftype.GetDictionaryKeyType());
ifRightNotNull.IfCondition(ExprDotMethod(Ref(refname), "CheckedContainsKey", leftWithBoxing))
.BlockReturn(!isNot ? ConstantTrue() : ConstantFalse());
}
}
else if (reftype.IsGenericCollection()) {
var ifRightNotNull = block.IfCondition(NotEqualsNull(Ref(refname)));
{
if (leftTypeUncoerced.CanBeNull()) {
ifRightNotNull.IfRefNullReturnNull("left");
}
var leftWithBoxing = ExprEqualsAllAnyNodeForgeHelper.ItemToCollectionUnboxing(
Ref("left"), leftTypeUncoerced, reftype.GetCollectionItemType());
ifRightNotNull
.IfCondition(StaticMethod(typeof(Collections), "CheckedContains", Ref(refname), leftWithBoxing))
.BlockReturn(!isNot ? ConstantTrue() : ConstantFalse());
}
}
else {
var ifRightNotNull = reftype.CanNotBeNull() ? block : block.IfRefNotNull(refname);
{
if (leftTypeUncoerced.CanBeNull()) {
ifRightNotNull.IfRefNullReturnNull("left");
}
if (!forge.IsMustCoerce) {
ifRightNotNull
.IfCondition(
CodegenLegoCompareEquals.CodegenEqualsNonNullNoCoerce(
Ref("leftCoerced"),
leftTypeCoerced,
Ref(refname),
reftype))
.BlockReturn(!isNot ? ConstantTrue() : ConstantFalse());
}
else {
ifRightNotNull
.IfCondition(
CodegenLegoCompareEquals.CodegenEqualsNonNullNoCoerce(
Ref("leftCoerced"),
leftTypeCoerced,
forge.Coercer.CoerceCodegen(Ref(refname), reftype),
forge.CoercionType))
.BlockReturn(!isNot ? ConstantTrue() : ConstantFalse());
}
}
if (reftype.CanBeNull()) {
block.IfRefNull(refname).AssignRef("hasNullRow", ConstantTrue());
}
}
}
block.IfCondition(Ref("hasNullRow")).BlockReturn(ConstantNull());
block.MethodReturn(isNot ? ConstantTrue() : ConstantFalse());
return LocalMethod(methodNode);
}
public static CodegenExpression Codegen(
ExprEqualsAllAnyNodeForge forge,
CodegenMethodScope codegenMethodScope,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
var forges = ExprNodeUtilityQuery.GetForges(forge.ForgeRenderable.ChildNodes);
var isNot = forge.ForgeRenderable.IsNot;
var methodNode = codegenMethodScope.MakeChild(
typeof(bool?),
typeof(ExprEqualsAllAnyNodeForgeEvalAllWColl),
codegenClassScope);
var block = methodNode.Block;
var leftTypeUncoerced = forges[0].EvaluationType;
block.DeclareVar(
leftTypeUncoerced,
"left",
forges[0].EvaluateCodegen(leftTypeUncoerced, methodNode, exprSymbol, codegenClassScope));
block.DeclareVar(
forge.CoercionTypeBoxed,
"leftCoerced",
!forge.IsMustCoerce
? Ref("left")
: forge.Coercer.CoerceCodegenMayNullBoxed(
Ref("left"),
leftTypeUncoerced,
methodNode,
codegenClassScope));
block.DeclareVar<bool>("hasNonNullRow", ConstantFalse());
block.DeclareVar<bool>("hasNullRow", ConstantFalse());
for (var i = 1; i < forges.Length; i++) {
var refforge = forges[i];
var refname = "r" + i;
var reftype = forges[i].EvaluationType;
if (reftype.IsArray) {
var arrayBlock = block.IfRefNullReturnNull("left")
.DeclareVar(
reftype,
refname,
refforge.EvaluateCodegen(reftype, methodNode, exprSymbol, codegenClassScope))
.IfCondition(EqualsNull(Ref(refname)))
.AssignRef("hasNullRow", ConstantTrue())
.IfElse();
var forLoop = arrayBlock.ForLoopIntSimple("i", ArrayLength(Ref(refname)));
var arrayAtIndex = ArrayAtIndex(Ref(refname), Ref("i"));
forLoop.DeclareVar(
forge.CoercionTypeBoxed,
"item",
forge.Coercer == null
? arrayAtIndex
: forge.Coercer.CoerceCodegenMayNullBoxed(
arrayAtIndex,
reftype.GetElementType(),
methodNode,
codegenClassScope));
var forLoopElse = forLoop.IfCondition(EqualsNull(Ref("item")))
.AssignRef("hasNullRow", ConstantTrue())
.IfElse();
forLoopElse.AssignRef("hasNonNullRow", ConstantTrue());
forLoopElse.IfCondition(
NotOptional(!isNot, StaticMethod<object>("Equals", Ref("leftCoerced"), Ref("item"))))
.BlockReturn(ConstantFalse());
}
else if (reftype.IsGenericDictionary()) {
var dictionaryType = typeof(IDictionary<,>)
.MakeGenericType(
reftype.GetGenericArguments()[0],
reftype.GetGenericArguments()[1]);
var leftWithBoxing = ExprEqualsAllAnyNodeForgeHelper.ItemToCollectionUnboxing(
Ref("left"), leftTypeUncoerced, reftype.GetDictionaryKeyType());
block.IfRefNullReturnNull("left")
.DeclareVar(
dictionaryType,
refname,
refforge.EvaluateCodegen(
dictionaryType,
methodNode,
exprSymbol,
codegenClassScope))
.IfCondition(EqualsNull(Ref(refname)))
.AssignRef("hasNullRow", ConstantTrue())
.IfElse()
.AssignRef("hasNonNullRow", ConstantTrue())
.IfCondition(NotOptional(!isNot, ExprDotMethod(Ref(refname), "CheckedContainsKey", leftWithBoxing)))
.BlockReturn(ConstantFalse());
}
else if (reftype.IsGenericCollection()) {
var collectionType = typeof(ICollection<>)
.MakeGenericType(reftype.GetGenericArguments()[0]);
var leftWithBoxing = ExprEqualsAllAnyNodeForgeHelper.ItemToCollectionUnboxing(
Ref("left"), leftTypeUncoerced, reftype.GetCollectionItemType());
block.IfRefNullReturnNull("left")
.DeclareVar(
collectionType,
refname,
refforge.EvaluateCodegen(
collectionType,
methodNode,
exprSymbol,
codegenClassScope))
.IfCondition(EqualsNull(Ref(refname)))
.AssignRef("hasNullRow", ConstantTrue())
.IfElse()
.AssignRef("hasNonNullRow", ConstantTrue())
.IfCondition(NotOptional(!isNot, ExprDotMethod(Ref(refname), "CheckedContains", leftWithBoxing)))
.BlockReturn(ConstantFalse());
}
else
{
block.IfRefNullReturnNull("leftCoerced");
block.DeclareVar(
forge.CoercionTypeBoxed,
refname,
forge.Coercer == null
? refforge.EvaluateCodegen(
forge.CoercionTypeBoxed,
methodNode,
exprSymbol,
codegenClassScope)
: forge.Coercer.CoerceCodegenMayNullBoxed(
refforge.EvaluateCodegen(
forge.CoercionTypeBoxed,
methodNode,
exprSymbol,
codegenClassScope),
reftype,
methodNode,
codegenClassScope));
var ifRightNotNull = block.IfRefNotNull(refname);
{
ifRightNotNull.AssignRef("hasNonNullRow", ConstantTrue());
ifRightNotNull
.IfCondition(NotOptional(!isNot, StaticMethod<object>("Equals", Ref("leftCoerced"), Ref(refname))))
.BlockReturn(ConstantFalse());
}
ifRightNotNull.IfElse()
.AssignRef("hasNullRow", ConstantTrue());
}
}
block.IfCondition(Or(Not(Ref("hasNonNullRow")), Ref("hasNullRow"))).BlockReturn(ConstantNull());
block.MethodReturn(ConstantTrue());
return LocalMethod(methodNode);
}
public CodegenExpression Make(
CodegenMethodScope parent,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(StatementInformationalsRuntime), GetType(), classScope);
var info = Ref("info");
method.Block
.DeclareVar<StatementInformationalsRuntime>(
info.Ref,
NewInstance(typeof(StatementInformationalsRuntime)))
.SetProperty(info, "StatementNameCompileTime", Constant(_statementNameCompileTime))
.SetProperty(info, "IsAlwaysSynthesizeOutputEvents", Constant(_alwaysSynthesizeOutputEvents))
.SetProperty(info, "OptionalContextName", Constant(_optionalContextName))
.SetProperty(info, "OptionalContextModuleName", Constant(_optionalContextModuleName))
.SetProperty(info, "OptionalContextVisibility", Constant(_optionalContextVisibility))
.SetProperty(info, "IsCanSelfJoin", Constant(_canSelfJoin))
.SetProperty(info, "HasSubquery", Constant(_hasSubquery))
.SetProperty(info, "IsNeedDedup", Constant(_needDedup))
.SetProperty(info, "IsStateless", Constant(_stateless))
.SetProperty(
info,
"Annotations",
_annotations == null
? ConstantNull()
: LocalMethod(MakeAnnotations(typeof(Attribute[]), _annotations, method, classScope)))
.SetProperty(
info,
"UserObjectCompileTime",
SerializerUtil.ExpressionForUserObject(_userObjectCompileTime))
.SetProperty(info, "NumFilterCallbacks", Constant(_numFilterCallbacks))
.SetProperty(info, "NumScheduleCallbacks", Constant(_numScheduleCallbacks))
.SetProperty(info, "NumNamedWindowCallbacks", Constant(_numNamedWindowCallbacks))
.SetProperty(info, "StatementType", Constant(_statementType))
.SetProperty(info, "Priority", Constant(_priority))
.SetProperty(info, "IsPreemptive", Constant(_preemptive))
.SetProperty(info, "HasVariables", Constant(_hasVariables))
.SetProperty(info, "IsWritesToTables", Constant(_writesToTables))
.SetProperty(info, "HasTableAccess", Constant(_hasTableAccess))
.SetProperty(info, "SelectClauseTypes", Constant(_selectClauseTypes))
.SetProperty(info, "SelectClauseColumnNames", Constant(_selectClauseColumnNames))
.SetProperty(info, "IsForClauseDelivery", Constant(_forClauseDelivery))
.SetProperty(
info,
"GroupDeliveryEval",
_groupDelivery == null
? ConstantNull()
: ExprNodeUtilityCodegen.CodegenEvaluatorMayMultiKeyWCoerce(
ExprNodeUtilityQuery.GetForges(_groupDelivery),
null,
method,
GetType(),
classScope))
.SetProperty(info, "Properties", MakeProperties(_properties, method, classScope))
.SetProperty(info, "HasMatchRecognize", Constant(_hasMatchRecognize))
.SetProperty(info, "AuditProvider", MakeAuditProvider(method, classScope))
.SetProperty(info, "IsInstrumented", Constant(_instrumented))
.SetProperty(info, "InstrumentationProvider", MakeInstrumentationProvider(method, classScope))
.SetProperty(info, "SubstitutionParamTypes", MakeSubstitutionParamTypes())
.SetProperty(info, "SubstitutionParamNames", MakeSubstitutionParamNames(method, classScope))
.SetProperty(info, "InsertIntoLatchName", Constant(_insertIntoLatchName))
.SetProperty(info, "IsAllowSubscriber", Constant(_allowSubscriber))
.MethodReturn(info);
return LocalMethod(method);
}
public static CodegenExpression Codegen(
ExprRelationalOpAllAnyNodeForge forge,
CodegenMethodScope codegenMethodScope,
ExprForgeCodegenSymbol exprSymbol,
CodegenClassScope codegenClassScope)
{
var forges = ExprNodeUtilityQuery.GetForges(forge.ForgeRenderable.ChildNodes);
var valueLeftType = forges[0].EvaluationType;
var isAll = forge.ForgeRenderable.IsAll;
if (forges.Length == 1) {
return Constant(isAll);
}
var methodNode = codegenMethodScope.MakeChild(
typeof(bool?),
typeof(ExprRelationalOpAllAnyNodeForgeEval),
codegenClassScope);
var block = methodNode.Block
.DeclareVar<bool>("hasNonNullRow", ConstantFalse())
.DeclareVar(
valueLeftType,
"valueLeft",
forges[0].EvaluateCodegen(valueLeftType, methodNode, exprSymbol, codegenClassScope));
for (var i = 1; i < forges.Length; i++) {
var refforge = forges[i];
var refname = "r" + i;
var reftype = refforge.EvaluationType;
block.DeclareVar(
reftype,
refname,
refforge.EvaluateCodegen(reftype, methodNode, exprSymbol, codegenClassScope));
if (reftype.IsArray) {
var blockIfNotNull = block.IfCondition(NotEqualsNull(Ref(refname)));
{
var forLoopArray = blockIfNotNull.ForLoopIntSimple("index", ArrayLength(Ref(refname)));
{
forLoopArray.DeclareVar(
Boxing.GetBoxedType(reftype.GetElementType()),
"item",
ArrayAtIndex(Ref(refname), Ref("index")));
var ifItemNull = forLoopArray.IfCondition(EqualsNull(Ref("item")));
{
if (isAll) {
ifItemNull.IfReturn(ConstantNull());
}
}
var ifItemNotNull = ifItemNull.IfElse();
{
ifItemNotNull.AssignRef("hasNonNullRow", ConstantTrue());
var ifLeftNotNull = ifItemNotNull.IfCondition(NotEqualsNull(Ref("valueLeft")));
{
ifLeftNotNull.IfCondition(
NotOptional(
isAll,
forge.Computer.Codegen(
Ref("valueLeft"),
valueLeftType,
Ref("item"),
typeof(object))))
.BlockReturn(isAll ? ConstantFalse() : ConstantTrue());
}
}
}
}
}
else if (reftype.IsGenericDictionary()) {
var blockIfNotNull = block.IfCondition(NotEqualsNull(Ref(refname)));
{
var forEach = blockIfNotNull.ForEach(
typeof(object),
"item",
ExprDotName(Ref(refname), "Keys"));
{
var ifNotNumber = forEach.IfCondition(Not(InstanceOf(Ref("item"), typeof(object))));
{
if (isAll) {
ifNotNumber.IfRefNullReturnNull("item");
}
}
var ifNotNumberElse = ifNotNumber.IfElse();
{
ifNotNumberElse.AssignRef("hasNonNullRow", ConstantTrue());
var ifLeftNotNull = ifNotNumberElse.IfCondition(NotEqualsNull(Ref("valueLeft")));
{
ifLeftNotNull.IfCondition(
NotOptional(
isAll,
forge.Computer.Codegen(
Ref("valueLeft"),
valueLeftType,
Cast(typeof(object), Ref("item")),
typeof(object))))
.BlockReturn(isAll ? ConstantFalse() : ConstantTrue());
}
}
}
}
}
else if (reftype.IsGenericCollection()) {
var blockIfNotNull = block.IfCondition(NotEqualsNull(Ref(refname)));
{
var forEach = blockIfNotNull.ForEach(typeof(object), "item", Ref(refname));
{
var ifNotNumber = forEach.IfCondition(Not(InstanceOf(Ref("item"), typeof(object))));
{
if (isAll) {
ifNotNumber.IfRefNullReturnNull("item");
}
}
var ifNotNumberElse = ifNotNumber.IfElse();
{
ifNotNumberElse.AssignRef("hasNonNullRow", ConstantTrue());
var ifLeftNotNull = ifNotNumberElse.IfCondition(NotEqualsNull(Ref("valueLeft")));
{
ifLeftNotNull.IfCondition(
NotOptional(
isAll,
forge.Computer.Codegen(
Ref("valueLeft"),
valueLeftType,
Cast(typeof(object), Ref("item")),
typeof(object))))
.BlockReturn(isAll ? ConstantFalse() : ConstantTrue());
}
}
}
}
}
else if (!TypeHelper.IsSubclassOrImplementsInterface(
Boxing.GetBoxedType(reftype),
typeof(object))) {
if (reftype.CanBeNull()) {
block.IfRefNullReturnNull(refname);
}
block.AssignRef("hasNonNullRow", ConstantTrue());
if (isAll) {
block.BlockReturn(ConstantNull());
}
}
else {
if (reftype.CanNotBeNull()) {
block.AssignRef("hasNonNullRow", ConstantTrue());
block.IfCondition(
NotOptional(
isAll,
forge.Computer.Codegen(Ref("valueLeft"), valueLeftType, Ref(refname), reftype)))
.BlockReturn(isAll ? ConstantFalse() : ConstantTrue());
}
else {
if (isAll) {
block.IfRefNullReturnNull(refname);
}
var ifRefNotNull = block.IfRefNotNull(refname);
{
ifRefNotNull.AssignRef("hasNonNullRow", ConstantTrue());
var ifLeftNotNull = ifRefNotNull.IfCondition(NotEqualsNull(Ref("valueLeft")));
ifLeftNotNull.IfCondition(
NotOptional(
isAll,
forge.Computer.Codegen(
Ref("valueLeft"),
valueLeftType,
Ref(refname),
typeof(object))))
.BlockReturn(isAll ? ConstantFalse() : ConstantTrue());
}
}
}
}
block.IfCondition(Not(Ref("hasNonNullRow")))
.BlockReturn(ConstantNull());
if (valueLeftType.CanBeNull()) {
block.IfRefNullReturnNull("valueLeft");
}
block.MethodReturn(Constant(isAll));
return LocalMethod(methodNode);
}