private static bool ProcessOuterApplyOverProject( RuleProcessingContext context, System.Data.Entity.Core.Query.InternalTrees.Node applyNode, out System.Data.Entity.Core.Query.InternalTrees.Node newNode) { newNode = applyNode; System.Data.Entity.Core.Query.InternalTrees.Node child1_1 = applyNode.Child1; System.Data.Entity.Core.Query.InternalTrees.Node child1_2 = child1_1.Child1; TransformationRulesContext transformationRulesContext = (TransformationRulesContext)context; Var computedVar = context.Command.GetExtendedNodeInfo(child1_1.Child0).NonNullableDefinitions.First; if (computedVar == null && child1_2.Children.Count == 1 && (child1_2.Child0.Child0.Op.OpType == OpType.InternalConstant || child1_2.Child0.Child0.Op.OpType == OpType.NullSentinel)) { return(false); } Command command = context.Command; System.Data.Entity.Core.Query.InternalTrees.Node node1 = (System.Data.Entity.Core.Query.InternalTrees.Node)null; InternalConstantOp internalConstantOp = (InternalConstantOp)null; ExtendedNodeInfo extendedNodeInfo1 = command.GetExtendedNodeInfo(child1_1.Child0); bool flag = false; foreach (System.Data.Entity.Core.Query.InternalTrees.Node child in child1_2.Children) { System.Data.Entity.Core.Query.PlanCompiler.PlanCompiler.Assert(child.Op.OpType == OpType.VarDef, "Expected VarDefOp. Found " + (object)child.Op.OpType + " instead"); VarRefOp op = child.Child0.Op as VarRefOp; if (op == null || !extendedNodeInfo1.Definitions.IsSet(op.Var)) { if (computedVar == null) { internalConstantOp = command.CreateInternalConstantOp(command.IntegerType, (object)1); System.Data.Entity.Core.Query.InternalTrees.Node node2 = command.CreateNode((Op)internalConstantOp); System.Data.Entity.Core.Query.InternalTrees.Node varDefListNode = command.CreateVarDefListNode(node2, out computedVar); ProjectOp projectOp = command.CreateProjectOp(computedVar); projectOp.Outputs.Or(extendedNodeInfo1.Definitions); node1 = command.CreateNode((Op)projectOp, child1_1.Child0, varDefListNode); } System.Data.Entity.Core.Query.InternalTrees.Node node3 = internalConstantOp == null || !internalConstantOp.IsEquivalent(child.Child0.Op) && child.Child0.Op.OpType != OpType.NullSentinel ? transformationRulesContext.BuildNullIfExpression(computedVar, child.Child0) : command.CreateNode((Op)command.CreateVarRefOp(computedVar)); child.Child0 = node3; command.RecomputeNodeInfo(child); flag = true; } } if (flag) { command.RecomputeNodeInfo(child1_2); } applyNode.Child1 = node1 ?? child1_1.Child0; command.RecomputeNodeInfo(applyNode); child1_1.Child0 = applyNode; ExtendedNodeInfo extendedNodeInfo2 = command.GetExtendedNodeInfo(applyNode.Child0); ((ProjectOp)child1_1.Op).Outputs.Or(extendedNodeInfo2.Definitions); newNode = child1_1; return(true); }
private static bool ProcessLikeOverConstant( RuleProcessingContext context, System.Data.Entity.Core.Query.InternalTrees.Node n, out System.Data.Entity.Core.Query.InternalTrees.Node newNode) { newNode = n; InternalConstantOp op1 = (InternalConstantOp)n.Child1.Op; InternalConstantOp op2 = (InternalConstantOp)n.Child0.Op; string str1 = (string)op2.Value; string str2 = (string)op1.Value; bool?nullable = ScalarOpRules.MatchesPattern((string)op2.Value, (string)op1.Value); if (!nullable.HasValue) { return(false); } ConstantPredicateOp constantPredicateOp = context.Command.CreateConstantPredicateOp(nullable.Value); newNode = context.Command.CreateNode((Op)constantPredicateOp); return(true); }
/// <summary> /// Copies an InternalConstantOp /// </summary> /// <param name="op">The Op to Copy</param> /// <param name="n">The Node that references the Op</param> /// <returns>A copy of the original Node that references a copy of the original Op</returns> public override Node Visit(InternalConstantOp op, Node n) { InternalConstantOp newOp = m_destCmd.CreateInternalConstantOp(op.Type, op.Value); return(m_destCmd.CreateNode(newOp)); }
/// <summary> /// Visitor pattern method for InternalConstantOp /// </summary> /// <param name="op"> The InternalConstantOp being visited </param> /// <param name="n"> The Node that references the Op </param> public virtual void Visit(InternalConstantOp op, Node n) { VisitConstantOp(op, n); }
private static bool ProcessOuterApplyOverProject(RuleProcessingContext context, Node applyNode, out Node newNode) { newNode = applyNode; var projectNode = applyNode.Child1; var varDefListNode = projectNode.Child1; var trc = (TransformationRulesContext)context; var inputNodeInfo = context.Command.GetExtendedNodeInfo(projectNode.Child0); var sentinelVar = inputNodeInfo.NonNullableDefinitions.First; // // special case handling first - we'll end up in an infinite loop otherwise. // If the ProjectOp is the dummy ProjectOp that we would be building (ie) // it defines only 1 var - and the defining expression is simply a constant // if (sentinelVar == null && varDefListNode.Children.Count == 1 && (varDefListNode.Child0.Child0.Op.OpType == OpType.InternalConstant || varDefListNode.Child0.Child0.Op.OpType == OpType.NullSentinel)) { return(false); } var command = context.Command; Node dummyProjectNode = null; InternalConstantOp nullSentinelDefinitionOp = null; // get node information for the project's child var projectInputNodeInfo = command.GetExtendedNodeInfo(projectNode.Child0); // // Build up a dummy project node. // Walk through each local definition of the current project Node, and convert // all expressions into case expressions whose value depends on the var // produced by the dummy project node // // Dev10 #480443: If any of the definitions changes we need to recompute the node info. var anyVarDefChanged = false; foreach (var varDefNode in varDefListNode.Children) { PlanCompiler.Assert(varDefNode.Op.OpType == OpType.VarDef, "Expected VarDefOp. Found " + varDefNode.Op.OpType + " instead"); var varRefOp = varDefNode.Child0.Op as VarRefOp; if (varRefOp == null || !projectInputNodeInfo.Definitions.IsSet(varRefOp.Var)) { // do we need to build a dummy project node if (sentinelVar == null) { nullSentinelDefinitionOp = command.CreateInternalConstantOp(command.IntegerType, 1); var dummyConstantExpr = command.CreateNode(nullSentinelDefinitionOp); var dummyProjectVarDefListNode = command.CreateVarDefListNode(dummyConstantExpr, out sentinelVar); var dummyProjectOp = command.CreateProjectOp(sentinelVar); dummyProjectOp.Outputs.Or(projectInputNodeInfo.Definitions); dummyProjectNode = command.CreateNode(dummyProjectOp, projectNode.Child0, dummyProjectVarDefListNode); } Node currentDefinition; // If the null sentinel was just created, and the local definition of the current project Node // is an internal constant equivalent to the null sentinel, it can be rewritten as a reference // to the null sentinel. if (nullSentinelDefinitionOp != null && (nullSentinelDefinitionOp.IsEquivalent(varDefNode.Child0.Op) || //The null sentinel has the same value of 1, thus it is safe. varDefNode.Child0.Op.OpType == OpType.NullSentinel)) { currentDefinition = command.CreateNode(command.CreateVarRefOp(sentinelVar)); } else { currentDefinition = trc.BuildNullIfExpression(sentinelVar, varDefNode.Child0); } varDefNode.Child0 = currentDefinition; command.RecomputeNodeInfo(varDefNode); anyVarDefChanged = true; } } // Recompute node info if needed if (anyVarDefChanged) { command.RecomputeNodeInfo(varDefListNode); } // // If we've created a dummy project node, make that the new child of the applyOp // applyNode.Child1 = dummyProjectNode != null ? dummyProjectNode : projectNode.Child0; command.RecomputeNodeInfo(applyNode); // // Pull up the project node above the apply node now. Also, make sure that every Var of // the applyNode's definitions actually shows up in the new Project // projectNode.Child0 = applyNode; var applyLeftChildNodeInfo = command.GetExtendedNodeInfo(applyNode.Child0); var projectOp = (ProjectOp)projectNode.Op; projectOp.Outputs.Or(applyLeftChildNodeInfo.Definitions); newNode = projectNode; return(true); }
// <summary> // Copies an InternalConstantOp // </summary> // <param name="op"> The Op to Copy </param> // <param name="n"> The Node that references the Op </param> // <returns> A copy of the original Node that references a copy of the original Op </returns> public override Node Visit(InternalConstantOp op, Node n) { var newOp = m_destCmd.CreateInternalConstantOp(op.Type, op.Value); return m_destCmd.CreateNode(newOp); }