// <summary> // Add a new property reference to this list // </summary> // <param name="property"> new property reference </param> internal void Add(PropertyRef property) { if (m_allProperties) { return; } else if (property is AllPropertyRef) { MakeAllProperties(); } else { m_propertyReferences[property] = property; } }
// <summary> // Add a mapping from the propertyRef (of the old type) to the // corresponding property in the new type. // NOTE: Only to be used by StructuredTypeInfo // </summary> internal void AddPropertyMapping(PropertyRef propertyRef, EdmProperty newProperty) { m_propertyMap[propertyRef] = newProperty; if (propertyRef is TypeIdPropertyRef) { m_typeIdProperty = newProperty; } else if (propertyRef is EntitySetIdPropertyRef) { m_entitySetIdProperty = newProperty; } else if (propertyRef is NullSentinelPropertyRef) { m_nullSentinelProperty = newProperty; } }
internal int GetNestedStructureOffset(PropertyRef property) { // m_propertyRefList contains every element of the flattened type for (var i = 0; i < m_propertyRefList.Count; i++) { var nestedPropertyRef = m_propertyRefList[i] as NestedPropertyRef; // match offset of the first element of the complex type property if (null != nestedPropertyRef && nestedPropertyRef.InnerProperty.Equals(property)) { return(i); } } PlanCompiler.Assert(false, "no complex structure " + property + " found in TypeInfo"); // return something so that the compiler doesn't complain return(default(int)); }
internal void AddPropertyMapping(PropertyRef propertyRef, EdmProperty newProperty) { this.m_propertyMap[propertyRef] = newProperty; if (propertyRef is TypeIdPropertyRef) { this.m_typeIdProperty = newProperty; } else if (propertyRef is EntitySetIdPropertyRef) { this.m_entitySetIdProperty = newProperty; } else { if (!(propertyRef is NullSentinelPropertyRef)) { return; } this.m_nullSentinelProperty = newProperty; } }
/// <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); }
private TypeUsage GetPropertyType(RootTypeInfo typeInfo, PropertyRef p) { TypeUsage type = (TypeUsage)null; PropertyRef propertyRef = (PropertyRef)null; while (p is NestedPropertyRef) { NestedPropertyRef nestedPropertyRef = (NestedPropertyRef)p; p = nestedPropertyRef.OuterProperty; propertyRef = nestedPropertyRef.InnerProperty; } if (p is TypeIdPropertyRef) { SimplePropertyRef simplePropertyRef = (SimplePropertyRef)propertyRef; type = simplePropertyRef == null ? typeInfo.TypeIdType : this.GetTypeInfo(simplePropertyRef.Property.TypeUsage).RootType.TypeIdType; } else if (p is EntitySetIdPropertyRef || p is NullSentinelPropertyRef) { type = this.m_intType; } else if (p is RelPropertyRef) { type = ((RelPropertyRef)p).Property.ToEnd.TypeUsage; } else { SimplePropertyRef simplePropertyRef = p as SimplePropertyRef; if (simplePropertyRef != null) { type = Helper.GetModelTypeUsage(simplePropertyRef.Property); } } TypeUsage newType = this.GetNewType(type); System.Data.Entity.Core.Query.PlanCompiler.PlanCompiler.Assert(null != newType, "unrecognized property type?"); return(newType); }
// <summary> // Adds a new property reference to the list of desired properties // NOTE: Only to be used by StructuredTypeInfo // </summary> internal void AddPropertyRef(PropertyRef propertyRef) { m_propertyRefList.Add(propertyRef); }
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); }
// <summary> // Do I contain the specifed property? // </summary> // <param name="p"> The property </param> // <returns> true, if I do </returns> internal bool Contains(PropertyRef p) { return m_allProperties || m_propertyReferences.ContainsKey(p); }
// <summary> // Create a nested property ref, with "p" as the prefix. // The best way to think of this function as follows. // Consider a type T where "this" describes a property X on T. Now // consider a new type S, where "p" is a property of S and is of type T. // This function creates a PropertyRef that describes the same property X // from S.p instead // </summary> // <param name="p"> the property to prefix with </param> // <returns> the nested property reference </returns> internal virtual PropertyRef CreateNestedPropertyRef(PropertyRef p) { return(new NestedPropertyRef(p, this)); }
internal NestedPropertyRef(PropertyRef innerProperty, PropertyRef outerProperty) { System.Data.Entity.Core.Query.PlanCompiler.PlanCompiler.Assert(!(innerProperty is NestedPropertyRef), "innerProperty cannot be a NestedPropertyRef"); this.m_inner = innerProperty; this.m_outer = outerProperty; }
private Node VisitPropertyOp(Op op, Node n, PropertyRef propertyRef, bool throwIfMissing) { PlanCompiler.Assert( op.OpType == OpType.Property || op.OpType == OpType.RelProperty, "Unexpected optype: " + op.OpType); var inputType = n.Child0.Op.Type; var outputType = op.Type; // First visit all my children VisitChildren(n); Node newNode = null; var inputTypeInfo = m_typeInfo.GetTypeInfo(inputType); if (TypeUtils.IsStructuredType(outputType)) { var outputTypeInfo = m_typeInfo.GetTypeInfo(outputType); var fieldTypes = new List<md.EdmProperty>(); var fieldValues = new List<Node>(); var expectedProperties = m_nodePropertyMap[n]; foreach (var npr in outputTypeInfo.PropertyRefList) { // Is this a property that's desired by my consumers? if (expectedProperties.Contains(npr)) { var newPropRef = npr.CreateNestedPropertyRef(propertyRef); md.EdmProperty newNestedProp; if (inputTypeInfo.TryGetNewProperty(newPropRef, throwIfMissing, out newNestedProp)) { var outputNestedProp = outputTypeInfo.GetNewProperty(npr); var field = BuildAccessor(n.Child0, newNestedProp); if (null != field) { fieldTypes.Add(outputNestedProp); fieldValues.Add(field); } } } } Op newRecordOp = m_command.CreateNewRecordOp(outputTypeInfo.FlattenedTypeUsage, fieldTypes); newNode = m_command.CreateNode(newRecordOp, fieldValues); } else { var newProp = inputTypeInfo.GetNewProperty(propertyRef); // Build an accessor over the new property newNode = BuildAccessorWithNulls(n.Child0, newProp); } return newNode; }
/// <summary> /// Create a nested property ref, with "p" as the prefix. /// The best way to think of this function as follows. /// Consider a type T where "this" describes a property X on T. Now /// consider a new type S, where "p" is a property of S and is of type T. /// This function creates a PropertyRef that describes the same property X /// from S.p instead /// </summary> /// <param name="p"> the property to prefix with </param> /// <returns> the nested property reference </returns> internal virtual PropertyRef CreateNestedPropertyRef(PropertyRef p) { return new NestedPropertyRef(p, this); }
// <summary> // Try get the new property for the supplied propertyRef // </summary> // <param name="propertyRef"> property reference (on the old type) </param> // <param name="throwIfMissing"> throw if the property is not found </param> // <param name="newProperty"> the corresponding property on the new type </param> internal bool TryGetNewProperty(PropertyRef propertyRef, bool throwIfMissing, out md.EdmProperty newProperty) { return(RootType.TryGetNewProperty(propertyRef, throwIfMissing, out newProperty)); }
private md.TypeUsage GetPropertyType(RootTypeInfo typeInfo, PropertyRef p) { md.TypeUsage result = null; PropertyRef innerProperty = null; // Get the "leaf" property first while (p is NestedPropertyRef) { var npr = (NestedPropertyRef)p; p = npr.OuterProperty; innerProperty = npr.InnerProperty; } if (p is TypeIdPropertyRef) { // // Get to the innermost type that specifies this typeid (the entity type), // get the datatype for the typeid column from that type // var simplePropertyRef = (SimplePropertyRef)innerProperty; if (simplePropertyRef != null) { var innerType = simplePropertyRef.Property.TypeUsage; var innerTypeInfo = GetTypeInfo(innerType); result = innerTypeInfo.RootType.TypeIdType; } else { result = typeInfo.TypeIdType; } } else if (p is EntitySetIdPropertyRef || p is NullSentinelPropertyRef) { result = m_intType; } else if (p is RelPropertyRef) { result = ((RelPropertyRef)p).Property.ToEnd.TypeUsage; } else { var simpleP = p as SimplePropertyRef; if (simpleP != null) { result = md.Helper.GetModelTypeUsage(simpleP.Property); } } result = GetNewType(result); PlanCompiler.Assert(null != result, "unrecognized property type?"); return result; }
internal NestedPropertyRef(PropertyRef innerProperty, PropertyRef outerProperty) { PlanCompiler.Assert(!(innerProperty is NestedPropertyRef), "innerProperty cannot be a NestedPropertyRef"); m_inner = innerProperty; m_outer = outerProperty; }
internal int GetNestedStructureOffset(PropertyRef property) { // m_propertyRefList contains every element of the flattened type for (var i = 0; i < m_propertyRefList.Count; i++) { var nestedPropertyRef = m_propertyRefList[i] as NestedPropertyRef; // match offset of the first element of the complex type property if (null != nestedPropertyRef && nestedPropertyRef.InnerProperty.Equals(property)) { return i; } } PlanCompiler.Assert(false, "no complex structure " + property + " found in TypeInfo"); // return something so that the compiler doesn't complain return default(int); }
internal new bool TryGetNewProperty(PropertyRef propertyRef, bool throwIfMissing, out EdmProperty property) { var result = m_propertyMap.TryGetValue(propertyRef, out property); if (throwIfMissing && !result) { { PlanCompiler.Assert(false, "Unable to find property " + propertyRef + " in type " + Type.EdmType.Identity); } } return result; }
/// <summary> /// Get the new property for the supplied propertyRef /// </summary> /// <param name="propertyRef"> property reference (on the old type) </param> /// <returns> </returns> internal md.EdmProperty GetNewProperty(PropertyRef propertyRef) { md.EdmProperty property; var result = TryGetNewProperty(propertyRef, true, out property); Debug.Assert(result, "Should have thrown if the property was not found"); return property; }
/// <summary> /// Try get the new property for the supplied propertyRef /// </summary> /// <param name="propertyRef"> property reference (on the old type) </param> /// <param name="throwIfMissing"> throw if the property is not found </param> /// <param name="newProperty"> the corresponding property on the new type </param> /// <returns> </returns> internal bool TryGetNewProperty(PropertyRef propertyRef, bool throwIfMissing, out md.EdmProperty newProperty) { return RootType.TryGetNewProperty(propertyRef, throwIfMissing, out newProperty); }
/// <summary> /// Is the given propertyRef representing a null sentinel /// It is if: /// - it is a NullSentinelPropertyRef /// - it is a NestedPropertyRef with the outer property being a NullSentinelPropertyRef /// </summary> /// <param name="propertyRef"> </param> /// <returns> </returns> private static bool IsNullSentinelPropertyRef(PropertyRef propertyRef) { if (propertyRef is NullSentinelPropertyRef) { return true; } var nestedPropertyRef = propertyRef as NestedPropertyRef; if (nestedPropertyRef == null) { return false; } return nestedPropertyRef.OuterProperty is NullSentinelPropertyRef; }
// <summary> // Do I contain the specifed property? // </summary> // <param name="p"> The property </param> // <returns> true, if I do </returns> internal bool Contains(PropertyRef p) { return(m_allProperties || m_propertyReferences.ContainsKey(p)); }