private void VisitPropertyOp(Op op, System.Data.Entity.Core.Query.InternalTrees.Node n, PropertyRef propertyRef) { PropertyRefList propertyRefs = new PropertyRefList(); if (!TypeUtils.IsStructuredType(op.Type)) { propertyRefs.Add(propertyRef); } else { PropertyRefList propertyRefList = this.GetPropertyRefList(n); if (propertyRefList.AllProperties) { propertyRefs = propertyRefList; } else { foreach (PropertyRef property in propertyRefList.Properties) { propertyRefs.Add(property.CreateNestedPropertyRef(propertyRef)); } } } this.AddPropertyRefs(n.Child0, propertyRefs); this.VisitChildren(n); }
private static PropertyRefList GetIdentityProperties(EntityType type) { PropertyRefList keyProperties = PropertyPushdownHelper.GetKeyProperties(type); keyProperties.Add((PropertyRef)EntitySetIdPropertyRef.Instance); return(keyProperties); }
protected override void VisitSetOp(SetOp op, System.Data.Entity.Core.Query.InternalTrees.Node n) { foreach (Dictionary <Var, Var> var in op.VarMap) { foreach (KeyValuePair <Var, Var> keyValuePair in var) { if (TypeUtils.IsStructuredType(keyValuePair.Key.Type)) { PropertyRefList propertyRefList = this.GetPropertyRefList(keyValuePair.Key); PropertyRefList propertyRefs; if (op.OpType == OpType.Intersect || op.OpType == OpType.Except) { propertyRefs = PropertyRefList.All; this.AddPropertyRefs(keyValuePair.Key, propertyRefs); } else { propertyRefs = propertyRefList.Clone(); } this.AddPropertyRefs(keyValuePair.Value, propertyRefs); } } } this.VisitChildren(n); }
/// <summary> /// SoftCastOp: /// If the input is /// Ref - ask for all properties /// Entity, ComplexType - ask for the same properties I've been asked for /// Record - ask for all properties (Note: This should be more optimized in the future /// since we can actually "remap" the properties) /// </summary> /// <param name="op"> </param> /// <param name="n"> </param> public override void Visit(SoftCastOp op, Node n) { PropertyRefList childProps = null; if (md.TypeSemantics.IsReferenceType(op.Type)) { childProps = PropertyRefList.All; } else if (md.TypeSemantics.IsNominalType(op.Type)) { var myProps = m_nodePropertyRefMap[n]; childProps = myProps.Clone(); } else if (md.TypeSemantics.IsRowType(op.Type)) { // // Note: We should do a better job here (by translating // our PropertyRefs to the equivalent property refs on the child // childProps = PropertyRefList.All; } if (childProps != null) { AddPropertyRefs(n.Child0, childProps); } VisitChildren(n); }
public override void Visit(TreatOp op, System.Data.Entity.Core.Query.InternalTrees.Node n) { PropertyRefList propertyRefs = this.GetPropertyRefList(n).Clone(); propertyRefs.Add((PropertyRef)TypeIdPropertyRef.Instance); this.AddPropertyRefs(n.Child0, propertyRefs); this.VisitChildren(n); }
public override void Visit(VarDefOp op, System.Data.Entity.Core.Query.InternalTrees.Node n) { if (TypeUtils.IsStructuredType(op.Var.Type)) { PropertyRefList propertyRefList = this.GetPropertyRefList(op.Var); this.AddPropertyRefs(n.Child0, propertyRefList); } this.VisitChildren(n); }
public override void Visit(ScanViewOp op, System.Data.Entity.Core.Query.InternalTrees.Node n) { System.Data.Entity.Core.Query.PlanCompiler.PlanCompiler.Assert(op.Table.Columns.Count == 1, "ScanViewOp with multiple columns?"); PropertyRefList propertyRefList = this.GetPropertyRefList(op.Table.Columns[0]); Var singletonVar = NominalTypeEliminator.GetSingletonVar(n.Child0); System.Data.Entity.Core.Query.PlanCompiler.PlanCompiler.Assert(singletonVar != null, "cannot determine single Var from ScanViewOp's input"); this.AddPropertyRefs(singletonVar, propertyRefList.Clone()); this.VisitChildren(n); }
public override void Visit(VarRefOp op, System.Data.Entity.Core.Query.InternalTrees.Node n) { if (!TypeUtils.IsStructuredType(op.Var.Type)) { return; } PropertyRefList propertyRefList = this.GetPropertyRefList(n); this.AddPropertyRefs(op.Var, propertyRefList); }
public override void Visit(GetEntityRefOp op, System.Data.Entity.Core.Query.InternalTrees.Node n) { ScalarOp op1 = n.Child0.Op as ScalarOp; System.Data.Entity.Core.Query.PlanCompiler.PlanCompiler.Assert(op1 != null, "input to GetEntityRefOp is not a ScalarOp?"); PropertyRefList identityProperties = PropertyPushdownHelper.GetIdentityProperties(TypeHelpers.GetEdmType <EntityType>(op1.Type)); this.AddPropertyRefs(n.Child0, identityProperties); this.VisitNode(n.Child0); }
internal PropertyRefList Clone() { PropertyRefList propertyRefList = new PropertyRefList(this.m_allProperties); foreach (PropertyRef key in this.m_propertyReferences.Keys) { propertyRefList.Add(key); } return(propertyRefList); }
// <summary> // Create a clone of myself // </summary> // <returns> a clone of myself </returns> internal PropertyRefList Clone() { var newProps = new PropertyRefList(m_allProperties); foreach (var p in m_propertyReferences.Keys) { newProps.Add(p); } return(newProps); }
/// <summary> /// IsOfOp handling /// Simply requests the "typeid" property from /// the input. No other property is required /// </summary> /// <param name="op"> IsOf op </param> /// <param name="n"> Node to visit </param> public override void Visit(IsOfOp op, Node n) { // The only property I need from my child is the typeid property; var childProps = new PropertyRefList(); childProps.Add(TypeIdPropertyRef.Instance); AddPropertyRefs(n.Child0, childProps); VisitChildren(n); }
/// <summary> /// Get the list of propertyrefs for a node. If none exists, create an /// empty structure and store it in the map /// </summary> /// <param name="node"> Specific node </param> /// <returns> List of properties expected from this node </returns> private PropertyRefList GetPropertyRefList(Node node) { PropertyRefList propRefs; if (!m_nodePropertyRefMap.TryGetValue(node, out propRefs)) { propRefs = new PropertyRefList(); m_nodePropertyRefMap[node] = propRefs; } return(propRefs); }
/// <summary> /// Get the list of desired properties for a Var /// </summary> /// <param name="v"> the var </param> /// <returns> List of desired properties </returns> private PropertyRefList GetPropertyRefList(Var v) { PropertyRefList propRefs; if (!m_varPropertyRefMap.TryGetValue(v, out propRefs)) { propRefs = new PropertyRefList(); m_varPropertyRefMap[v] = propRefs; } return(propRefs); }
internal void Append(PropertyRefList propertyRefs) { if (this.m_allProperties) { return; } foreach (PropertyRef key in propertyRefs.m_propertyReferences.Keys) { this.Add(key); } }
// <summary> // Append an existing list of property references to myself // </summary> // <param name="propertyRefs"> list of property references </param> internal void Append(PropertyRefList propertyRefs) { if (m_allProperties) { return; } foreach (var p in propertyRefs.m_propertyReferences.Keys) { Add(p); } }
private PropertyRefList GetPropertyRefList(Var v) { PropertyRefList propertyRefList; if (!this.m_varPropertyRefMap.TryGetValue(v, out propertyRefList)) { propertyRefList = new PropertyRefList(); this.m_varPropertyRefMap[v] = propertyRefList; } return(propertyRefList); }
private PropertyRefList GetPropertyRefList(System.Data.Entity.Core.Query.InternalTrees.Node node) { PropertyRefList propertyRefList; if (!this.m_nodePropertyRefMap.TryGetValue(node, out propertyRefList)) { propertyRefList = new PropertyRefList(); this.m_nodePropertyRefMap[node] = propertyRefList; } return(propertyRefList); }
public override void Visit(CaseOp op, System.Data.Entity.Core.Query.InternalTrees.Node n) { PropertyRefList propertyRefList = this.GetPropertyRefList(n); for (int index = 1; index < n.Children.Count - 1; index += 2) { PropertyRefList propertyRefs = propertyRefList.Clone(); this.AddPropertyRefs(n.Children[index], propertyRefs); } this.AddPropertyRefs(n.Children[n.Children.Count - 1], propertyRefList.Clone()); this.VisitChildren(n); }
private static PropertyRefList GetKeyProperties(EntityType entityType) { PropertyRefList propertyRefList = new PropertyRefList(); foreach (EdmMember keyMember in entityType.KeyMembers) { EdmProperty edmProperty = keyMember as EdmProperty; System.Data.Entity.Core.Query.PlanCompiler.PlanCompiler.Assert(edmProperty != null, "EntityType had non-EdmProperty key member?"); SimplePropertyRef simplePropertyRef = new SimplePropertyRef((EdmMember)edmProperty); propertyRefList.Add((PropertyRef)simplePropertyRef); } return(propertyRefList); }
private static PropertyRefList GetKeyProperties(md.EntityType entityType) { var desiredProperties = new PropertyRefList(); foreach (var p in entityType.KeyMembers) { var edmP = p as md.EdmProperty; PlanCompiler.Assert(edmP != null, "EntityType had non-EdmProperty key member?"); var pRef = new SimplePropertyRef(edmP); desiredProperties.Add(pRef); } return(desiredProperties); }
/// <summary> /// Common handler for RelPropertyOp and PropertyOp. /// Simply pushes down the desired set of properties to the child /// </summary> /// <param name="op"> the *propertyOp </param> /// <param name="n"> node tree corresponding to the Op </param> /// <param name="propertyRef"> the property reference </param> private void VisitPropertyOp(Op op, Node n, PropertyRef propertyRef) { var cdProps = new PropertyRefList(); if (!TypeUtils.IsStructuredType(op.Type)) { cdProps.Add(propertyRef); } else { // Get the list of properties my parent expects from me. var pdProps = GetPropertyRefList(n); // Ask my child (which is really my container type) for each of these // properties // If I've been asked for all my properties, then get the // corresponding flat list of properties from my children. // For now, however, simply ask for all properties in this case // What we really need to do is to get the "flattened" list of // properties from the input, and prepend each of these with // our property name. We don't have that info available, so // I'm taking the easier route. if (pdProps.AllProperties) { cdProps = pdProps; } else { foreach (var p in pdProps.Properties) { cdProps.Add(p.CreateNestedPropertyRef(propertyRef)); } } } // push down my expectations AddPropertyRefs(n.Child0, cdProps); VisitChildren(n); }
public override void Visit(SoftCastOp op, System.Data.Entity.Core.Query.InternalTrees.Node n) { PropertyRefList propertyRefs = (PropertyRefList)null; if (TypeSemantics.IsReferenceType(op.Type)) { propertyRefs = PropertyRefList.All; } else if (TypeSemantics.IsNominalType(op.Type)) { propertyRefs = this.m_nodePropertyRefMap[n].Clone(); } else if (TypeSemantics.IsRowType(op.Type)) { propertyRefs = PropertyRefList.All; } if (propertyRefs != null) { this.AddPropertyRefs(n.Child0, propertyRefs); } this.VisitChildren(n); }
public override void Visit(ComparisonOp op, System.Data.Entity.Core.Query.InternalTrees.Node n) { TypeUsage type = (n.Child0.Op as ScalarOp).Type; if (!TypeUtils.IsStructuredType(type)) { this.VisitChildren(n); } else if (TypeSemantics.IsRowType(type) || TypeSemantics.IsReferenceType(type)) { this.VisitDefault(n); } else { System.Data.Entity.Core.Query.PlanCompiler.PlanCompiler.Assert(TypeSemantics.IsEntityType(type), "unexpected childOpType?"); PropertyRefList identityProperties = PropertyPushdownHelper.GetIdentityProperties(TypeHelpers.GetEdmType <EntityType>(type)); foreach (System.Data.Entity.Core.Query.InternalTrees.Node child in n.Children) { this.AddPropertyRefs(child, identityProperties); } this.VisitChildren(n); } }
/// <summary> /// Flattens a CaseOp - Specifically, if the CaseOp returns a structuredtype, /// then the CaseOp is broken up so that we build up a "flat" record constructor /// for that structured type, with each argument to the record constructor being /// a (scalar) CaseOp. For example: /// Case when b1 then e1 else e2 end /// gets translated into: /// RecordOp(case when b1 then e1.a else e2.a end, /// case when b1 then e1.b else e2.b end, /// ...) /// The property extraction is optimized by producing only those properties /// that have actually been requested. /// </summary> /// <param name="n"> Node corresponding to the CaseOp </param> /// <param name="typeInfo"> Information about the type </param> /// <param name="desiredProperties"> Set of properties desired </param> /// <returns> </returns> private Node FlattenCaseOp(Node n, TypeInfo typeInfo, PropertyRefList desiredProperties) { // Build up a type constructor - with only as many fields filled in // as are desired. var fieldTypes = new List<md.EdmProperty>(); var fieldValues = new List<Node>(); foreach (var pref in typeInfo.PropertyRefList) { // Is this property desired later? if (!desiredProperties.Contains(pref)) { continue; } var property = typeInfo.GetNewProperty(pref); // Build up an accessor for this property across each when/then clause var caseChildren = new List<Node>(); for (var i = 0; i < n.Children.Count - 1;) { var whenNode = Copy(n.Children[i]); caseChildren.Add(whenNode); i++; var propNode = BuildAccessorWithNulls(n.Children[i], property); caseChildren.Add(propNode); i++; } var elseNode = BuildAccessorWithNulls(n.Children[n.Children.Count - 1], property); caseChildren.Add(elseNode); var caseNode = m_command.CreateNode(m_command.CreateCaseOp(md.Helper.GetModelTypeUsage(property)), caseChildren); fieldTypes.Add(property); fieldValues.Add(caseNode); } var newRec = m_command.CreateNewRecordOp(typeInfo.FlattenedTypeUsage, fieldTypes); return m_command.CreateNode(newRec, fieldValues); }
// <summary> // Create a clone of myself // </summary> // <returns> a clone of myself </returns> internal PropertyRefList Clone() { var newProps = new PropertyRefList(m_allProperties); foreach (var p in m_propertyReferences.Keys) { newProps.Add(p); } return newProps; }
/// <summary> /// IsOfOp handling /// /// Simply requests the "typeid" property from /// the input. No other property is required /// </summary> /// <param name="op"> IsOf op </param> /// <param name="n"> Node to visit </param> public override void Visit(IsOfOp op, Node n) { // The only property I need from my child is the typeid property; var childProps = new PropertyRefList(); childProps.Add(TypeIdPropertyRef.Instance); AddPropertyRefs(n.Child0, childProps); VisitChildren(n); }
/// <summary> /// Add a new set of properties to a Var /// </summary> /// <param name="v"> the var </param> /// <param name="propertyRefs"> desired properties </param> private void AddPropertyRefs(Var v, PropertyRefList propertyRefs) { var currentRefs = GetPropertyRefList(v); currentRefs.Append(propertyRefs); }
private static PropertyRefList GetKeyProperties(md.EntityType entityType) { var desiredProperties = new PropertyRefList(); foreach (var p in entityType.KeyMembers) { var edmP = p as md.EdmProperty; PlanCompiler.Assert(edmP != null, "EntityType had non-EdmProperty key member?"); var pRef = new SimplePropertyRef(edmP); desiredProperties.Add(pRef); } return desiredProperties; }
/// <summary> /// Add a list of property references for this node /// </summary> /// <param name="node"> the node </param> /// <param name="propertyRefs"> list of property references </param> private void AddPropertyRefs(Node node, PropertyRefList propertyRefs) { var refs = GetPropertyRefList(node); refs.Append(propertyRefs); }
/// <summary> /// Get the list of desired properties for a Var /// </summary> /// <param name="v"> the var </param> /// <returns> List of desired properties </returns> private PropertyRefList GetPropertyRefList(Var v) { PropertyRefList propRefs; if (!m_varPropertyRefMap.TryGetValue(v, out propRefs)) { propRefs = new PropertyRefList(); m_varPropertyRefMap[v] = propRefs; } return propRefs; }
/// <summary> /// Get the list of propertyrefs for a node. If none exists, create an /// empty structure and store it in the map /// </summary> /// <param name="node"> Specific node </param> /// <returns> List of properties expected from this node </returns> private PropertyRefList GetPropertyRefList(Node node) { PropertyRefList propRefs; if (!m_nodePropertyRefMap.TryGetValue(node, out propRefs)) { propRefs = new PropertyRefList(); m_nodePropertyRefMap[node] = propRefs; } return propRefs; }
private void AddPropertyRefs(System.Data.Entity.Core.Query.InternalTrees.Node node, PropertyRefList propertyRefs) { this.GetPropertyRefList(node).Append(propertyRefs); }
private void AddPropertyRefs(Var v, PropertyRefList propertyRefs) { this.GetPropertyRefList(v).Append(propertyRefs); }