private QueryValue BuildCollectionQueryValue(string propertyPath, QueryCollectionType queryCollectionType, EntitySetDataRow row) { QueryScalarType scalarElementDataType = queryCollectionType.ElementType as QueryScalarType; QueryComplexType complexTypeElementDataType = queryCollectionType.ElementType as QueryComplexType; List <QueryValue> queryValues = new List <QueryValue>(); if (scalarElementDataType != null) { int i = 0; while (row.PropertyPaths.Any(pp => pp == propertyPath + i)) { var value = row[propertyPath + i]; queryValues.Add(scalarElementDataType.CreateValue(value)); i++; } } else { ExceptionUtilities.CheckObjectNotNull(complexTypeElementDataType, "PropertyPath '{0}' is an invalid type '{1}'", propertyPath, queryCollectionType.ElementType); int i = 0; while (row.PropertyPaths.Where(pp => pp.StartsWith(propertyPath + i, StringComparison.Ordinal)).Count() > 0) { QueryStructuralValue complexChildInstance = complexTypeElementDataType.CreateNewInstance(); this.BuildStructuralPropertiesQueryValue(complexChildInstance, propertyPath + i + ".", complexTypeElementDataType.ComplexType.Properties, complexTypeElementDataType.Properties, row); queryValues.Add(complexChildInstance); i++; } } return(queryCollectionType.CreateCollectionWithValues(queryValues.ToArray())); }
/// <summary> /// Creates a QueryProperty for a property that is a non entity Collection /// </summary> /// <param name="library">Library Query Type</param> /// <param name="result">resulting Query Structural Type</param> /// <param name="collectionProperty">Member to calculate</param> /// <param name="pathToProperty">Path to the Property</param> /// <returns>A Query Property of the collectionType</returns> protected override QueryProperty CreateNonentityCollectionMember(QueryTypeLibrary library, QueryStructuralType result, MemberProperty collectionProperty, PathToProperty pathToProperty) { ExceptionUtilities.CheckArgumentNotNull(collectionProperty, "collectionProperty"); var collectionType = collectionProperty.PropertyType as CollectionDataType; ExceptionUtilities.Assert(collectionType != null, "This type of property is not supported."); var collectionPrimitiveElementType = collectionType.ElementDataType as PrimitiveDataType; var collectionComplexElementType = collectionType.ElementDataType as ComplexDataType; QueryCollectionType queryCollectionType = null; if (collectionPrimitiveElementType != null) { QueryScalarType queryPropertyType = this.GetQueryTypeForMappedProperty(pathToProperty, library, collectionPrimitiveElementType); queryCollectionType = queryPropertyType.CreateCollectionType(); } else { ExceptionUtilities.Assert(collectionComplexElementType != null, "This type of property is not supported."); QueryComplexType queryComplexType = this.CreateStubComplexType(collectionComplexElementType.Definition); CreateMembers(library, queryComplexType, collectionComplexElementType.Definition.Properties, pathToProperty); queryCollectionType = queryComplexType.CreateCollectionType(); } return(QueryProperty.Create(collectionProperty.Name, queryCollectionType)); }
/// <summary> /// Creates new members on a structural type /// </summary> /// <param name="library">Type library</param> /// <param name="result">Structural Type to add members to</param> /// <param name="properties">Properties of the Structural Type member</param> /// <param name="pathToProperty">Path to the Property</param> protected void CreateMembers(QueryTypeLibrary library, QueryStructuralType result, IEnumerable <MemberProperty> properties, PathToProperty pathToProperty) { // TODO: Some Taupo framework pieces skip over StreamDataType properties foreach (var prop in properties.Where(p => !(p.PropertyType is StreamDataType))) { QueryProperty queryProperty = null; pathToProperty.PathStackWithinEntityType.Add(prop.Name); var pdt = prop.PropertyType as PrimitiveDataType; var cdt = prop.PropertyType as ComplexDataType; if (pdt != null) { QueryScalarType queryPropertyType = this.GetQueryTypeForMappedProperty(pathToProperty, library, pdt); queryProperty = QueryProperty.Create(prop.Name, queryPropertyType); } else if (cdt != null) { ComplexType ct = cdt.Definition; QueryComplexType queryComplexType = this.CreateStubComplexType(ct); this.CreateMembers(library, queryComplexType, ct.Properties, pathToProperty); library.SetQueryComplexType(ct, queryComplexType); queryProperty = QueryProperty.Create(prop.Name, queryComplexType); } else { queryProperty = this.CreateNonentityCollectionMember(library, result, prop, pathToProperty); } pathToProperty.PathStackWithinEntityType.RemoveAt(pathToProperty.PathStackWithinEntityType.Count - 1); queryProperty.SetPrimaryKey(prop.IsPrimaryKey); result.Add(queryProperty); } }
private void BuildStructuralPropertiesQueryValue(QueryStructuralValue instance, string propertyPath, IList <MemberProperty> properties, IList <QueryProperty> queryProperties, EntitySetDataRow row) { ExceptionUtilities.Assert(properties.Count == queryProperties.Count, "QueryProperties '{0}' and MemberProperties '{1}' are not the same number!", CreateQueryPropertyList(queryProperties), CreateMemberPropertyList(properties)); // TODO: Some Taupo framework pieces skip over StreamDataType properties foreach (MemberProperty childProperty in properties.Where(p => !(p.PropertyType is StreamDataType))) { string childPropertyPath = propertyPath + childProperty.Name; List <QueryProperty> childQueryProperties = queryProperties.Where(p => p.Name == childProperty.Name).ToList(); ExceptionUtilities.Assert(childQueryProperties.Count == 1, "Could not find query property based on MemberProperty Name '{0}' in list of query properties '{1}'", childProperty.Name, CreateQueryPropertyList(childQueryProperties)); QueryProperty childQueryProperty = childQueryProperties.First(); QueryCollectionType childCollectionDataType = childQueryProperty.PropertyType as QueryCollectionType; QueryScalarType childScalarType = childQueryProperty.PropertyType as QueryScalarType; QueryComplexType childComplexType = childQueryProperty.PropertyType as QueryComplexType; if (childCollectionDataType != null) { instance.SetValue(childProperty.Name, this.BuildCollectionQueryValue(childPropertyPath + ".", childCollectionDataType, row)); } else if (childScalarType != null) { var value = row[childPropertyPath]; var queryValue = childScalarType.CreateValue(value); instance.SetValue(childQueryProperty.Name, queryValue); } else { ExceptionUtilities.CheckObjectNotNull(childComplexType, "Unknown type '{0}'", childProperty.PropertyType); // If a complex type instance is null in the datarow, we will create a QueryStructuralValue indicating null and set it on the instance. if (row.PropertyPaths.Contains(childPropertyPath) && row[childPropertyPath] == null) { instance.SetValue(childProperty.Name, new QueryStructuralValue(childComplexType, true, null, childComplexType.EvaluationStrategy)); } else { QueryStructuralValue childInstance = childComplexType.CreateNewInstance(); this.BuildStructuralPropertiesQueryValue(childInstance, childPropertyPath + ".", childComplexType.ComplexType.Properties, childComplexType.Properties, row); instance.SetValue(childProperty.Name, childInstance); } } } }
/// <summary> /// Creates a QueryValue of a given type. /// </summary> /// <param name="type">Type of the QueryValue that will be generated.</param> /// <returns>QueryValue representing the provided object.</returns> public QueryValue Visit(QueryComplexType type) { var resultFragment = this.ResultFragmentStack.Pop(); QueryStructuralValue visitedComplexType; if (this.visitedStructurals.TryGetValue(resultFragment, out visitedComplexType)) { return(visitedComplexType); } ExceptionUtilities.Assert( resultFragment.GetType().Name == type.ComplexType.Name, "Names don't match. Expecting: " + type.ComplexType.Name + ". Actual: " + resultFragment.GetType().Name + "."); var resultComplexType = type.CreateNewInstance(); this.visitedStructurals[resultFragment] = resultComplexType; resultComplexType = this.PopulateProperties(resultComplexType, resultFragment); return(resultComplexType); }
/// <summary> /// Gets EDM type for primtive, entity and complex types /// </summary> /// <param name="type">The Query Type.</param> /// <returns>The EDM Type in string format.</returns> protected string GetEdmTypeName(QueryType type) { QueryComplexType complexType = type as QueryComplexType; QueryEntityType entityType = type as QueryEntityType; IQueryClrType clrBackedType = type as IQueryClrType; if (complexType != null) { return(complexType.ComplexType.FullName); } else if (entityType != null) { return(entityType.EntityType.FullName); } else if (clrBackedType != null) { ExceptionUtilities.CheckObjectNotNull(this.PrimitiveDataTypeConverter, "Cannot get edm type name for primitive clr type without converter"); return(this.PrimitiveDataTypeConverter.ToDataType(clrBackedType.ClrType).GetEdmTypeName()); } else { throw new TaupoNotSupportedException("Unable to find EDM type name for type which is not an entity type or a primitive type"); } }
/// <summary> /// Visits a <see cref="QueryComplexType"/>. /// </summary> /// <param name="type">Query type being visited.</param> /// <returns>The result of visiting this query type.</returns> public ComparisonResult Visit(QueryComplexType type) { return(this.parent.CompareStructural((QueryStructuralValue)this.expectedValue, this.actualValue, this.path, this.shouldThrow)); }
private void UpdateRootComplexBag(QueryCollectionValue queryCollectionValue, IEnumerable <NamedValue> namedValues, QueryComplexType complexTypeElementDataType) { int i = 0; var complexCollection = new List <QueryValue>(); List <NamedValue> complexInstanceNamedValues = namedValues.Where(pp => pp.Name.StartsWith(i + ".", StringComparison.Ordinal)).ToList(); while (complexInstanceNamedValues.Any()) { QueryStructuralValue complexValue = complexTypeElementDataType.CreateNewInstance(); this.UpdateValues(complexValue, complexInstanceNamedValues, i.ToString(CultureInfo.InvariantCulture)); complexCollection.Add(complexValue); i++; complexInstanceNamedValues = namedValues.Where(pp => pp.Name.StartsWith(i + ".", StringComparison.Ordinal)).ToList(); } if (complexCollection.Any()) { this.SetCollectionValue(queryCollectionValue, complexCollection); } }
private void UpdateComplexBag(QueryStructuralValue instance, QueryProperty memberProperty, string propertyPath, IEnumerable <NamedValue> namedValues, QueryComplexType complexTypeElementDataType) { int i = 0; var complexCollection = new List <QueryValue>(); List <NamedValue> complexInstanceNamedValues = namedValues.Where(pp => pp.Name.StartsWith(propertyPath + "." + i + ".", StringComparison.Ordinal)).ToList(); while (complexInstanceNamedValues.Any()) { QueryStructuralValue complexValue = complexTypeElementDataType.CreateNewInstance(); this.UpdateValues(complexValue, complexInstanceNamedValues, propertyPath + "." + i); complexCollection.Add(complexValue); i++; complexInstanceNamedValues = namedValues.Where(pp => pp.Name.StartsWith(propertyPath + "." + i + ".", StringComparison.Ordinal)).ToList(); } if (complexCollection.Any()) { this.SetCollectionProperty(instance, memberProperty, complexCollection); } }
private void UpdateRootComplexBag(QueryCollectionValue queryCollectionValue, IEnumerable<NamedValue> namedValues, QueryComplexType complexTypeElementDataType) { int i = 0; var complexCollection = new List<QueryValue>(); List<NamedValue> complexInstanceNamedValues = namedValues.Where(pp => pp.Name.StartsWith(i + ".", StringComparison.Ordinal)).ToList(); while (complexInstanceNamedValues.Any()) { QueryStructuralValue complexValue = complexTypeElementDataType.CreateNewInstance(); this.UpdateValues(complexValue, complexInstanceNamedValues, i.ToString(CultureInfo.InvariantCulture)); complexCollection.Add(complexValue); i++; complexInstanceNamedValues = namedValues.Where(pp => pp.Name.StartsWith(i + ".", StringComparison.Ordinal)).ToList(); } if (complexCollection.Any()) { this.SetCollectionValue(queryCollectionValue, complexCollection); } }
private void UpdateComplexBag(QueryStructuralValue instance, QueryProperty memberProperty, string propertyPath, IEnumerable<NamedValue> namedValues, QueryComplexType complexTypeElementDataType) { int i = 0; var complexCollection = new List<QueryValue>(); List<NamedValue> complexInstanceNamedValues = namedValues.Where(pp => pp.Name.StartsWith(propertyPath + "." + i + ".", StringComparison.Ordinal)).ToList(); while (complexInstanceNamedValues.Any()) { QueryStructuralValue complexValue = complexTypeElementDataType.CreateNewInstance(); this.UpdateValues(complexValue, complexInstanceNamedValues, propertyPath + "." + i); complexCollection.Add(complexValue); i++; complexInstanceNamedValues = namedValues.Where(pp => pp.Name.StartsWith(propertyPath + "." + i + ".", StringComparison.Ordinal)).ToList(); } if (complexCollection.Any()) { this.SetCollectionProperty(instance, memberProperty, complexCollection); } }