/// <summary> /// This method takes a type and a set of facets and returns the best mapped equivalent type /// in EDM. /// </summary> /// <param name="storeType">A TypeUsage encapsulating a store type and a set of facets</param> /// <returns>A TypeUsage encapsulating an EDM type and a set of facets</returns> public override TypeUsage GetEdmType(TypeUsage storeType) { if (storeType == null) { throw new ArgumentNullException("storeType"); } string storeTypeName = storeType.EdmType.Name.ToLowerInvariant(); if (!base.StoreTypeNameToEdmPrimitiveType.ContainsKey(storeTypeName)) { throw new ArgumentException(String.Format("The underlying provider does not support the type '{0}'.", storeTypeName)); } PrimitiveType edmPrimitiveType = base.StoreTypeNameToEdmPrimitiveType[storeTypeName]; int maxLength = 0; bool isUnicode = true; bool isFixedLen = false; bool isUnbounded = true; PrimitiveTypeKind newPrimitiveTypeKind; switch (storeTypeName) { // for some types we just go with simple type usage with no facets case "tinyint": case "smallint": case "bigint": case "bit": case "uniqueidentifier": case "int": case "guid": return(TypeUsage.CreateDefaultTypeUsage(edmPrimitiveType)); case "nvarchar": case "varchar": newPrimitiveTypeKind = PrimitiveTypeKind.String; isUnbounded = !storeType.TryGetMaxLength(out maxLength); isFixedLen = false; break; case "nchar": case "char": newPrimitiveTypeKind = PrimitiveTypeKind.String; isUnbounded = !storeType.TryGetMaxLength(out maxLength); isFixedLen = true; break; case "nvarchar(max)": case "varchar(max)": case "ntext": case "text": newPrimitiveTypeKind = PrimitiveTypeKind.String; isUnbounded = true; isFixedLen = false; break; case "binary": newPrimitiveTypeKind = PrimitiveTypeKind.Binary; isUnbounded = !storeType.TryGetMaxLength(out maxLength); isFixedLen = true; break; case "varbinary": newPrimitiveTypeKind = PrimitiveTypeKind.Binary; isUnbounded = !storeType.TryGetMaxLength(out maxLength); isFixedLen = false; break; case "varbinary(max)": case "image": newPrimitiveTypeKind = PrimitiveTypeKind.Binary; isUnbounded = true; isFixedLen = false; break; case "float": case "real": return(TypeUsage.CreateDefaultTypeUsage(edmPrimitiveType)); case "decimal": case "numeric": { byte precision; byte scale; if (storeType.TryGetPrecision(out precision) && storeType.TryGetScale(out scale)) { return(TypeUsage.CreateDecimalTypeUsage(edmPrimitiveType, precision, scale)); } else { return(TypeUsage.CreateDecimalTypeUsage(edmPrimitiveType)); } } case "money": return(TypeUsage.CreateDecimalTypeUsage(edmPrimitiveType, 19, 4)); case "datetime": return(TypeUsage.CreateDateTimeTypeUsage(edmPrimitiveType, null)); case "time": return(TypeUsage.CreateTimeTypeUsage(edmPrimitiveType, null)); default: throw new NotSupportedException(String.Format("Jet does not support the type '{0}'.", storeTypeName)); } Debug.Assert(newPrimitiveTypeKind == PrimitiveTypeKind.String || newPrimitiveTypeKind == PrimitiveTypeKind.Binary, "at this point only string and binary types should be present"); switch (newPrimitiveTypeKind) { case PrimitiveTypeKind.String: if (!isUnbounded) { return(TypeUsage.CreateStringTypeUsage(edmPrimitiveType, isUnicode, isFixedLen, maxLength)); } else { return(TypeUsage.CreateStringTypeUsage(edmPrimitiveType, isUnicode, isFixedLen)); } case PrimitiveTypeKind.Binary: if (!isUnbounded) { return(TypeUsage.CreateBinaryTypeUsage(edmPrimitiveType, isFixedLen, maxLength)); } else { return(TypeUsage.CreateBinaryTypeUsage(edmPrimitiveType, isFixedLen)); } default: throw new NotSupportedException(String.Format("Jet does not support the type '{0}'.", storeTypeName)); } }
public void Build_builds_valid_DbDatabaseMapping_for_functions() { var rowTypeProperty = CreateStoreProperty("p1", "int"); var complexTypeProperty = EdmProperty.Create( "p2", TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32))); var functionImportReturnComplexType = ComplexType.Create( "CT", "entityModel", DataSpace.CSpace, new[] { complexTypeProperty }, null); var storeFunction = EdmFunction.Create( "f_s", "storeModel", DataSpace.SSpace, new EdmFunctionPayload { IsComposable = true, IsFunctionImport = false, ReturnParameters = new[] { FunctionParameter.Create( "ReturnType", RowType.Create(new[] { rowTypeProperty }, null).GetCollectionType(), ParameterMode.ReturnValue) } }, null); var functionImport = EdmFunction.Create( "f_c", "entityModel", DataSpace.CSpace, new EdmFunctionPayload { IsComposable = true, IsFunctionImport = true, ReturnParameters = new[] { FunctionParameter.Create( "ReturnType", functionImportReturnComplexType.GetCollectionType(), ParameterMode.ReturnValue) } }, null); var modelContainer = EntityContainer.Create("C_C", DataSpace.CSpace, new EntitySet[0], new[] { functionImport }, null); var storeContainer = EntityContainer.Create("C_S", DataSpace.SSpace, new EntitySet[0], null, null); var storeModel = EdmModel.CreateStoreModel(storeContainer, null, null); storeModel.AddItem(storeFunction); var mappingContext = new SimpleMappingContext(storeModel, true); mappingContext.AddMapping(rowTypeProperty, complexTypeProperty); mappingContext.AddMapping(storeFunction, functionImport); mappingContext.AddMapping(storeContainer, modelContainer); var entityModel = DbDatabaseMappingBuilder.Build(mappingContext).ConceptualModel; Assert.NotNull(entityModel); Assert.Equal(new[] { "f_c" }, entityModel.Containers.Single().FunctionImports.Select(f => f.Name)); Assert.Equal(new[] { "CT" }, entityModel.ComplexTypes.Select(t => t.Name)); }
private static EdmType GetEdmType(DbModel model, ReadOnlyCollection <PrimitiveType> storeTypes, PrimitiveTypeKind typeKind) { return(model.ProviderManifest.GetStoreType(TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(typeKind))).EdmType); }
public void BuildAssociationSetMappings_builds_conceptual_assocation_set_mapping_for_collapsed_store_entity_sets() { #region Setting up many to many relationship in the SSpace Teacher * -- 1 TeacherStudents 1 -- * Teachers var joinStoreEntityType = EntityType.Create( "TeacherStudents", "ns.Store", DataSpace.SSpace, new[] { "JoinTeacherId", "JoinStudentId" }, new[] { CreateStoreProperty("JoinTeacherId", "int"), CreateStoreProperty("JoinStudentId", "int") }, null); var joinStoreEntitySet = EntitySet.Create("TeacherStudentsSet", "dbo", "TeacherStudentTable", null, joinStoreEntityType, null); var storeTeacherEntityType = EntityType.Create( "Teacher", "ns.Store", DataSpace.SSpace, new[] { "TeacherId" }, new[] { CreateStoreProperty("TeacherId", "int") }, null); var storeTeacherEntitySet = EntitySet.Create("TeachersSet", "dbo", "Teachers", null, storeTeacherEntityType, null); var storeStudentEntityType = EntityType.Create( "Student", "ns.Store", DataSpace.SSpace, new[] { "StudentId" }, new[] { CreateStoreProperty("StudentId", "int") }, null); var storeStudentEntitySet = EntitySet.Create("StudentSet", "dbo", "Students", null, storeStudentEntityType, null); var storeTeachersEndMember = AssociationEndMember.Create( "Teachers", storeTeacherEntityType.GetReferenceType(), RelationshipMultiplicity.Many, OperationAction.None, null); var storeTeacherStudentsfromTeachersEndMember = AssociationEndMember.Create( "TeacherStudents_fromTeachers", joinStoreEntityType.GetReferenceType(), RelationshipMultiplicity.One, OperationAction.None, null); var storeTeacherAssociationType = AssociationType.Create( "Teacher_TeacherStudentsAssociationType", "ns.Store", false, DataSpace.SSpace, storeTeachersEndMember, storeTeacherStudentsfromTeachersEndMember, new ReferentialConstraint( storeTeachersEndMember, storeTeacherStudentsfromTeachersEndMember, storeTeacherEntityType.KeyProperties, joinStoreEntityType.KeyProperties.Where(p => p.Name == "JoinTeacherId")), null); var storeTeacherAssociationSet = AssociationSet.Create( "Teacher_TeacherStudents", storeTeacherAssociationType, storeTeacherEntitySet, joinStoreEntitySet, null); var storeStudentsEndMember = AssociationEndMember.Create( "Students", storeStudentEntityType.GetReferenceType(), RelationshipMultiplicity.Many, OperationAction.None, null); var storeTeacherStudentsfromStudentsEndMember = AssociationEndMember.Create( "TeacherStudents_fromStudents", joinStoreEntityType.GetReferenceType(), RelationshipMultiplicity.One, OperationAction.None, null); var storeStudentAssociationType = AssociationType.Create( "Student_TeacherStudentsAssociationType", "ns.Store", false, DataSpace.SSpace, storeStudentsEndMember, storeTeacherStudentsfromStudentsEndMember, new ReferentialConstraint( storeStudentsEndMember, storeTeacherStudentsfromStudentsEndMember, storeStudentEntityType.KeyProperties, joinStoreEntityType.KeyProperties.Where(p => p.Name == "JoinStudentId")), null); var storeStudentAssociationSet = AssociationSet.Create( "Student_TeacherStudents", storeStudentAssociationType, storeStudentEntitySet, joinStoreEntitySet, null); var collapsedAssociationSet = new CollapsibleEntityAssociationSets(joinStoreEntitySet); collapsedAssociationSet.AssociationSets.Add(storeTeacherAssociationSet); collapsedAssociationSet.AssociationSets.Add(storeStudentAssociationSet); #endregion #region Setting up many to many relationship in the CSpace Teacher * -- * Teachers var conceptualContainer = EntityContainer.Create("ConceptualContainer", DataSpace.CSpace, null, null, null); var edmIntTypeUsage = TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)); var conceptualTeacherEntityType = EntityType.Create( "Teacher", "ns", DataSpace.CSpace, new[] { "TeacherId" }, new[] { EdmProperty.Create("TeacherId", edmIntTypeUsage) }, null); var conceptualTeacherEntitySet = EntitySet.Create("TeachersSet", null, null, null, conceptualTeacherEntityType, null); var conceptualStudentEntityType = EntityType.Create( "Student", "ns", DataSpace.CSpace, new[] { "StudentId" }, new[] { EdmProperty.Create("StudentId", edmIntTypeUsage) }, null); var conceptualStudentEntitySet = EntitySet.Create("StudentSet", "dbo", "Students", null, conceptualStudentEntityType, null); var conceptualTeachersEndMember = AssociationEndMember.Create( "TeachersEnd", conceptualTeacherEntityType.GetReferenceType(), RelationshipMultiplicity.Many, OperationAction.None, null); var conceptualStudentsEndMember = AssociationEndMember.Create( "StudentsEnd", conceptualStudentEntityType.GetReferenceType(), RelationshipMultiplicity.Many, OperationAction.None, null); var conceptualAssociationType = AssociationType.Create( "TeacherStudentAssociation", "ns.Model", false, DataSpace.CSpace, conceptualTeachersEndMember, conceptualStudentsEndMember, new ReferentialConstraint( conceptualTeachersEndMember, conceptualStudentsEndMember, conceptualTeacherEntityType.KeyProperties, conceptualStudentEntityType.KeyProperties), null); var conceptualAssociationSet = AssociationSet.Create( "TeacherStudentSet", conceptualAssociationType, conceptualTeacherEntitySet, conceptualStudentEntitySet, null); #endregion var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true); mappingContext.AddMapping(collapsedAssociationSet, conceptualAssociationSet); mappingContext.AddMapping(storeTeachersEndMember, conceptualTeachersEndMember); mappingContext.AddMapping(storeStudentsEndMember, conceptualStudentsEndMember); mappingContext.AddMapping( storeTeacherAssociationSet.AssociationSetEnds.ElementAt(0), conceptualAssociationSet.AssociationSetEnds.ElementAt(0)); mappingContext.AddMapping( storeStudentAssociationSet.AssociationSetEnds.ElementAt(0), conceptualAssociationSet.AssociationSetEnds.ElementAt(1)); mappingContext.AddMapping( storeStudentEntityType.KeyProperties.Single(), conceptualStudentEntityType.KeyProperties.Single()); mappingContext.AddMapping( storeTeacherEntityType.KeyProperties.Single(), conceptualTeacherEntityType.KeyProperties.Single()); var storageEntitySetMapping = new EntityContainerMapping(conceptualContainer, null, null, false, false); var associationSetMapping = DbDatabaseMappingBuilder.BuildAssociationSetMappings(storageEntitySetMapping, mappingContext) .SingleOrDefault(); Assert.NotNull(associationSetMapping); var mappingFragment = associationSetMapping.TypeMappings.SingleOrDefault(); Assert.NotNull(mappingFragment); var propertyMappings = mappingFragment.MappingFragments.Single().PropertyMappings; Assert.Equal(2, propertyMappings.Count); Assert.Same(conceptualTeachersEndMember, ((EndPropertyMapping)propertyMappings[0]).AssociationEnd); Assert.Same(conceptualStudentsEndMember, ((EndPropertyMapping)propertyMappings[1]).AssociationEnd); var scalarPropertyMapping = ((EndPropertyMapping)propertyMappings[0]).PropertyMappings.Single(); Assert.Same(conceptualTeacherEntityType.KeyMembers.Single(), scalarPropertyMapping.Property); Assert.Same( joinStoreEntityType.KeyMembers.Single(m => m.Name == "JoinTeacherId"), scalarPropertyMapping.Column); scalarPropertyMapping = ((EndPropertyMapping)propertyMappings[1]).PropertyMappings.Single(); Assert.Same(conceptualStudentEntityType.KeyMembers.Single(), scalarPropertyMapping.Property); Assert.Same( joinStoreEntityType.KeyMembers.Single(m => m.Name == "JoinStudentId"), scalarPropertyMapping.Column); }
public void BuildComposableFunctionMapping_creates_valid_function_mapping() { var rowTypeProperty = CreateStoreProperty("p1", "int"); var complexTypeProperty = EdmProperty.Create( "p2", TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32))); var functionImportReturnComplexType = ComplexType.Create( "c", "entityModel", DataSpace.CSpace, new[] { complexTypeProperty }, null); var storeFunction = EdmFunction.Create( "f_s", "storeModel", DataSpace.SSpace, new EdmFunctionPayload { IsComposable = true, IsFunctionImport = false, ReturnParameters = new[] { FunctionParameter.Create( "ReturnType", RowType.Create(new[] { rowTypeProperty }, null).GetCollectionType(), ParameterMode.ReturnValue) } }, null); var functionImport = EdmFunction.Create( "f_c", "entityModel", DataSpace.CSpace, new EdmFunctionPayload { IsComposable = true, IsFunctionImport = false, ReturnParameters = new[] { FunctionParameter.Create( "ReturnType", functionImportReturnComplexType.GetCollectionType(), ParameterMode.ReturnValue) } }, null); var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true); mappingContext.AddMapping(rowTypeProperty, complexTypeProperty); mappingContext.AddMapping(storeFunction, functionImport); var functionImportMapping = DbDatabaseMappingBuilder.BuildComposableFunctionMapping(storeFunction, mappingContext); Assert.NotNull(functionImportMapping); Assert.Same(storeFunction, functionImportMapping.TargetFunction); Assert.Same(functionImport, functionImportMapping.FunctionImport); var structuralTypeMappings = functionImportMapping.StructuralTypeMappings; Assert.NotNull(structuralTypeMappings); Assert.Same(functionImportReturnComplexType, structuralTypeMappings.Single().Item1); Assert.Empty(structuralTypeMappings.Single().Item2); Assert.Same(complexTypeProperty, structuralTypeMappings.Single().Item3.Single().Property); Assert.Same(rowTypeProperty, ((ScalarPropertyMapping)structuralTypeMappings.Single().Item3.Single()).Column); }
public void Can_create_composable_function_import_with_entity_type_hierarchy() { DbProviderManifest providerManifest; var containerMapping = GetContainerMapping(out providerManifest); var cTypeUsageInt = TypeUsage.Create( PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32), new[] { Facet.Create(MetadataItem.NullableFacetDescription, false) }); var sTypeUsageInt = TypeUsage.Create( providerManifest.GetStoreType(cTypeUsageInt).EdmType, new[] { Facet.Create(MetadataItem.NullableFacetDescription, false) }); var cTypeUsageString = TypeUsage.CreateDefaultTypeUsage( PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); var sTypeUsageString = providerManifest.GetStoreType(cTypeUsageString); var itemCollection = containerMapping.StorageMappingItemCollection.EdmItemCollection.GetItems <EntityType>(); var baseEntityType = itemCollection.Single(et => et.Name == "E"); var entityType1 = itemCollection.Single(et => et.Name == "E1"); var entityType2 = itemCollection.Single(et => et.Name == "E2"); var rowType = RowType.Create( new[] { EdmProperty.Create("CId", sTypeUsageInt), EdmProperty.Create("C", sTypeUsageString), EdmProperty.Create("C1", sTypeUsageString), EdmProperty.Create("C2", sTypeUsageString), EdmProperty.Create("CD", sTypeUsageString) }, null); var functionImport = EdmFunction.Create( "F", "N", DataSpace.CSpace, new EdmFunctionPayload { IsComposable = true, ReturnParameters = new[] { FunctionParameter.Create("R", baseEntityType.GetCollectionType(), ParameterMode.ReturnValue) } }, null); var targetFunction = EdmFunction.Create( "SF", "N", DataSpace.SSpace, new EdmFunctionPayload { IsComposable = true, ReturnParameters = new[] { FunctionParameter.Create("R", rowType.GetCollectionType(), ParameterMode.ReturnValue) } }, null); var resultMapping = new FunctionImportResultMapping(); var typeMapping = new FunctionImportEntityTypeMapping( new[] { baseEntityType }, Enumerable.Empty <EntityType>(), new Collection <FunctionImportReturnTypePropertyMapping>() { new FunctionImportReturnTypeScalarPropertyMapping("Id", "CId"), new FunctionImportReturnTypeScalarPropertyMapping("P", "C"), new FunctionImportReturnTypeScalarPropertyMapping("Discriminator", "CD"), }, Enumerable.Empty <FunctionImportEntityTypeMappingConditionValue>()); resultMapping.AddTypeMapping(typeMapping); typeMapping = new FunctionImportEntityTypeMapping( Enumerable.Empty <EntityType>(), new[] { entityType1 }, new Collection <FunctionImportReturnTypePropertyMapping>() { new FunctionImportReturnTypeScalarPropertyMapping("P1", "C1"), }, new [] { new FunctionImportEntityTypeMappingConditionValue("CD", "E1") }); resultMapping.AddTypeMapping(typeMapping); typeMapping = new FunctionImportEntityTypeMapping( Enumerable.Empty <EntityType>(), new[] { entityType2 }, new Collection <FunctionImportReturnTypePropertyMapping>() { new FunctionImportReturnTypeScalarPropertyMapping("P2", "C2"), }, new [] { new FunctionImportEntityTypeMappingConditionValue("CD", "E2") }); resultMapping.AddTypeMapping(typeMapping); var functionImportMapping = new FunctionImportMappingComposable( functionImport, targetFunction, resultMapping, containerMapping); Assert.Same(resultMapping, functionImportMapping.ResultMapping); Assert.Equal(2, functionImportMapping.StructuralTypeMappings.Count); Assert.Equal(1, functionImportMapping.TvfKeys.Length); Assert.Equal(typeof(E1).Name, functionImportMapping.StructuralTypeMappings[0].Item1.Name); Assert.Equal(1, functionImportMapping.StructuralTypeMappings[0].Item2.Count()); Assert.Equal(3, functionImportMapping.StructuralTypeMappings[0].Item3.Count()); Assert.Equal(typeof(E2).Name, functionImportMapping.StructuralTypeMappings[1].Item1.Name); Assert.Equal(1, functionImportMapping.StructuralTypeMappings[0].Item2.Count()); Assert.Equal(3, functionImportMapping.StructuralTypeMappings[0].Item3.Count()); }
private static TypeUsage ConvertFromLegacyEdmTypeUsage(LegacyMetadata.TypeUsage legacyTypeUsage) { Debug.Assert(legacyTypeUsage != null, "legacyTypeUsage != null"); Debug.Assert(legacyTypeUsage.EdmType is LegacyMetadata.PrimitiveType, "primitive type expected."); Debug.Assert( (LegacyMetadata.DataSpace) typeof(LegacyMetadata.EdmType) .GetProperty("DataSpace", BindingFlags.Instance | BindingFlags.NonPublic) .GetValue(legacyTypeUsage.EdmType) == LegacyMetadata.DataSpace.CSpace, "Expected CSpace type."); var legacyPrimitiveEdmType = (LegacyMetadata.PrimitiveType)legacyTypeUsage.EdmType; var primitiveEdmType = FromLegacyPrimitiveType(legacyPrimitiveEdmType); switch (legacyPrimitiveEdmType.PrimitiveTypeKind) { case LegacyMetadata.PrimitiveTypeKind.Boolean: case LegacyMetadata.PrimitiveTypeKind.Byte: case LegacyMetadata.PrimitiveTypeKind.SByte: case LegacyMetadata.PrimitiveTypeKind.Int16: case LegacyMetadata.PrimitiveTypeKind.Int32: case LegacyMetadata.PrimitiveTypeKind.Int64: case LegacyMetadata.PrimitiveTypeKind.Guid: case LegacyMetadata.PrimitiveTypeKind.Double: case LegacyMetadata.PrimitiveTypeKind.Single: case LegacyMetadata.PrimitiveTypeKind.Geography: case LegacyMetadata.PrimitiveTypeKind.GeographyPoint: case LegacyMetadata.PrimitiveTypeKind.GeographyLineString: case LegacyMetadata.PrimitiveTypeKind.GeographyPolygon: case LegacyMetadata.PrimitiveTypeKind.GeographyMultiPoint: case LegacyMetadata.PrimitiveTypeKind.GeographyMultiLineString: case LegacyMetadata.PrimitiveTypeKind.GeographyMultiPolygon: case LegacyMetadata.PrimitiveTypeKind.GeographyCollection: case LegacyMetadata.PrimitiveTypeKind.Geometry: case LegacyMetadata.PrimitiveTypeKind.GeometryPoint: case LegacyMetadata.PrimitiveTypeKind.GeometryLineString: case LegacyMetadata.PrimitiveTypeKind.GeometryPolygon: case LegacyMetadata.PrimitiveTypeKind.GeometryMultiPoint: case LegacyMetadata.PrimitiveTypeKind.GeometryMultiLineString: case LegacyMetadata.PrimitiveTypeKind.GeometryMultiPolygon: case LegacyMetadata.PrimitiveTypeKind.GeometryCollection: return(TypeUsage.CreateDefaultTypeUsage(primitiveEdmType)); case LegacyMetadata.PrimitiveTypeKind.Decimal: var precisionFacetValue = legacyTypeUsage.Facets[PrecisionFacetName].Value; if (precisionFacetValue == null || precisionFacetValue == TypeUsageHelper.LegacyUnboundedValue) { Debug.Assert( legacyTypeUsage.Facets[ScaleFacetName].Value == precisionFacetValue, "Precision and Scale facets are expected to be both unbounded (Max) or null"); return(TypeUsage.CreateDecimalTypeUsage(primitiveEdmType)); } else { var scaleFacetValue = legacyTypeUsage.Facets[ScaleFacetName].Value; Debug.Assert( precisionFacetValue is byte && scaleFacetValue is byte, "Precision and Scale facets are expected to be both unbounded (Max) or both of byte type"); return (TypeUsage.CreateDecimalTypeUsage( primitiveEdmType, (byte)precisionFacetValue, (byte)scaleFacetValue)); } case LegacyMetadata.PrimitiveTypeKind.Binary: Debug.Assert( !(legacyTypeUsage.Facets[FixedLengthFacetName].Value == null ^ legacyTypeUsage.Facets[MaxLengthFacetName].Value == null), "Both Fixed Length and Max Length facet values should be null or none should be null"); var fixedLengthFacetValue = legacyTypeUsage.Facets[FixedLengthFacetName].Value; if (fixedLengthFacetValue == null) { return(TypeUsage.CreateDefaultTypeUsage(primitiveEdmType)); } else { var maxLengthBinaryFacetValue = legacyTypeUsage.Facets[MaxLengthFacetName].Value; return (maxLengthBinaryFacetValue == TypeUsageHelper.LegacyUnboundedValue ? TypeUsage.CreateBinaryTypeUsage( primitiveEdmType, (bool)fixedLengthFacetValue) : TypeUsage.CreateBinaryTypeUsage( primitiveEdmType, (bool)fixedLengthFacetValue, (int)maxLengthBinaryFacetValue)); } case LegacyMetadata.PrimitiveTypeKind.DateTime: return(TypeUsage.CreateDateTimeTypeUsage( primitiveEdmType, (byte?)legacyTypeUsage.Facets[PrecisionFacetName].Value)); case LegacyMetadata.PrimitiveTypeKind.DateTimeOffset: return(TypeUsage.CreateDateTimeOffsetTypeUsage( primitiveEdmType, (byte?)legacyTypeUsage.Facets[PrecisionFacetName].Value)); case LegacyMetadata.PrimitiveTypeKind.Time: return(TypeUsage.CreateTimeTypeUsage( primitiveEdmType, (byte?)legacyTypeUsage.Facets[PrecisionFacetName].Value)); case LegacyMetadata.PrimitiveTypeKind.String: var maxLengthStringFacetValue = legacyTypeUsage.Facets[MaxLengthFacetName].Value; if (maxLengthStringFacetValue == null) { return(TypeUsage.CreateDefaultTypeUsage(primitiveEdmType)); } else { return(maxLengthStringFacetValue == TypeUsageHelper.LegacyUnboundedValue ? TypeUsage.CreateStringTypeUsage( primitiveEdmType, (bool)legacyTypeUsage.Facets[UnicodeFacetName].Value, (bool)legacyTypeUsage.Facets[FixedLengthFacetName].Value) : TypeUsage.CreateStringTypeUsage( primitiveEdmType, (bool)legacyTypeUsage.Facets[UnicodeFacetName].Value, (bool)legacyTypeUsage.Facets[FixedLengthFacetName].Value, (int)maxLengthStringFacetValue)); } } Debug.Fail("Unknown primitive type kind."); throw new NotSupportedException(); }
public override TypeUsage GetStoreType(TypeUsage edmType) { Check.NotNull(edmType, "edmType"); Debug.Assert(edmType.EdmType.BuiltInTypeKind == BuiltInTypeKind.PrimitiveType); var primitiveType = edmType.EdmType as PrimitiveType; if (primitiveType == null) { throw new ArgumentException(Strings.ProviderDoesNotSupportType(edmType.EdmType.Name)); } var facets = edmType.Facets; switch (primitiveType.PrimitiveTypeKind) { case PrimitiveTypeKind.Boolean: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["bit"])); case PrimitiveTypeKind.Byte: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["tinyint"])); case PrimitiveTypeKind.Int16: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["smallint"])); case PrimitiveTypeKind.Int32: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["int"])); case PrimitiveTypeKind.Int64: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["bigint"])); case PrimitiveTypeKind.Geography: case PrimitiveTypeKind.GeographyPoint: case PrimitiveTypeKind.GeographyLineString: case PrimitiveTypeKind.GeographyPolygon: case PrimitiveTypeKind.GeographyMultiPoint: case PrimitiveTypeKind.GeographyMultiLineString: case PrimitiveTypeKind.GeographyMultiPolygon: case PrimitiveTypeKind.GeographyCollection: return(GetStorePrimitiveTypeIfPostSql9("geography", edmType.EdmType.Name, primitiveType.PrimitiveTypeKind)); case PrimitiveTypeKind.Geometry: case PrimitiveTypeKind.GeometryPoint: case PrimitiveTypeKind.GeometryLineString: case PrimitiveTypeKind.GeometryPolygon: case PrimitiveTypeKind.GeometryMultiPoint: case PrimitiveTypeKind.GeometryMultiLineString: case PrimitiveTypeKind.GeometryMultiPolygon: case PrimitiveTypeKind.GeometryCollection: return(GetStorePrimitiveTypeIfPostSql9("geometry", edmType.EdmType.Name, primitiveType.PrimitiveTypeKind)); case PrimitiveTypeKind.Guid: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["uniqueidentifier"])); case PrimitiveTypeKind.HierarchyId: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["hierarchyid"])); case PrimitiveTypeKind.Double: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["float"])); case PrimitiveTypeKind.Single: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["real"])); case PrimitiveTypeKind.Decimal: // decimal, numeric, smallmoney, money { byte precision; if (!edmType.TryGetPrecision(out precision)) { precision = 18; } byte scale; if (!edmType.TryGetScale(out scale)) { scale = 0; } var tu = TypeUsage.CreateDecimalTypeUsage(StoreTypeNameToStorePrimitiveType["decimal"], precision, scale); return(tu); } case PrimitiveTypeKind.Binary: // binary, varbinary, varbinary(max), image, timestamp, rowversion { var isFixedLength = null != facets[FixedLengthFacetName].Value && (bool)facets[FixedLengthFacetName].Value; var f = facets[MaxLengthFacetName]; var isMaxLength = f.IsUnbounded || null == f.Value || (int)f.Value > binaryMaxSize; var maxLength = !isMaxLength ? (int)f.Value : Int32.MinValue; TypeUsage tu; if (isFixedLength) { tu = TypeUsage.CreateBinaryTypeUsage( StoreTypeNameToStorePrimitiveType["binary"], true, (isMaxLength ? binaryMaxSize : maxLength)); } else { if (isMaxLength) { if (_version != SqlVersion.Sql8) { tu = TypeUsage.CreateBinaryTypeUsage(StoreTypeNameToStorePrimitiveType["varbinary(max)"], false); Debug.Assert(tu.Facets[MaxLengthFacetName].Description.IsConstant, "varbinary(max) is not constant!"); } else { tu = TypeUsage.CreateBinaryTypeUsage( StoreTypeNameToStorePrimitiveType["varbinary"], false, binaryMaxSize); } } else { tu = TypeUsage.CreateBinaryTypeUsage(StoreTypeNameToStorePrimitiveType["varbinary"], false, maxLength); } } return(tu); } case PrimitiveTypeKind.String: // char, nchar, varchar, nvarchar, varchar(max), nvarchar(max), ntext, text, xml { var isUnicode = null == facets[UnicodeFacetName].Value || (bool)facets[UnicodeFacetName].Value; var isFixedLength = null != facets[FixedLengthFacetName].Value && (bool)facets[FixedLengthFacetName].Value; var f = facets[MaxLengthFacetName]; // maxlen is true if facet value is unbounded, the value is bigger than the limited string sizes *or* the facet // value is null. this is needed since functions still have maxlength facet value as null var isMaxLength = f.IsUnbounded || null == f.Value || (int)f.Value > (isUnicode ? nvarcharMaxSize : varcharMaxSize); var maxLength = !isMaxLength ? (int)f.Value : Int32.MinValue; TypeUsage tu; if (isUnicode) { if (isFixedLength) { tu = TypeUsage.CreateStringTypeUsage( StoreTypeNameToStorePrimitiveType["nchar"], true, true, (isMaxLength ? nvarcharMaxSize : maxLength)); } else { if (isMaxLength) { // nvarchar(max) (SQL 9) or ntext (SQL 8) if (_version != SqlVersion.Sql8) { tu = TypeUsage.CreateStringTypeUsage( StoreTypeNameToStorePrimitiveType["nvarchar(max)"], true, false); Debug.Assert(tu.Facets[MaxLengthFacetName].Description.IsConstant, "NVarchar(max) is not constant!"); } else { // if it is unknown, fallback to nvarchar[4000] instead of ntext since it has limited store semantics tu = TypeUsage.CreateStringTypeUsage( StoreTypeNameToStorePrimitiveType["nvarchar"], true, false, nvarcharMaxSize); } } else { tu = TypeUsage.CreateStringTypeUsage( StoreTypeNameToStorePrimitiveType["nvarchar"], true, false, maxLength); } } } else // !isUnicode { if (isFixedLength) { tu = TypeUsage.CreateStringTypeUsage( StoreTypeNameToStorePrimitiveType["char"], false, true, (isMaxLength ? varcharMaxSize : maxLength)); } else { if (isMaxLength) { // nvarchar(max) (SQL 9) or ntext (SQL 8) if (_version != SqlVersion.Sql8) { tu = TypeUsage.CreateStringTypeUsage( StoreTypeNameToStorePrimitiveType["varchar(max)"], false, false); Debug.Assert(tu.Facets[MaxLengthFacetName].Description.IsConstant, "varchar(max) is not constant!"); } else { // if it is unknown, fallback to varchar[8000] instead of text since it has limited store semantics tu = TypeUsage.CreateStringTypeUsage( StoreTypeNameToStorePrimitiveType["varchar"], false, false, varcharMaxSize); } } else { tu = TypeUsage.CreateStringTypeUsage( StoreTypeNameToStorePrimitiveType["varchar"], false, false, maxLength); } } } return(tu); } case PrimitiveTypeKind.DateTime: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["datetime"])); case PrimitiveTypeKind.DateTimeOffset: return(GetStorePrimitiveTypeIfPostSql9("datetimeoffset", edmType.EdmType.Name, primitiveType.PrimitiveTypeKind)); case PrimitiveTypeKind.Time: return(GetStorePrimitiveTypeIfPostSql9("time", edmType.EdmType.Name, primitiveType.PrimitiveTypeKind)); default: throw new NotSupportedException(Strings.NoStoreTypeForEdmType(edmType.EdmType.Name, primitiveType.PrimitiveTypeKind)); } }
public override TypeUsage GetEdmType(TypeUsage storeType) { Check.NotNull <TypeUsage>(storeType, nameof(storeType)); string lowerInvariant = storeType.EdmType.Name.ToLowerInvariant(); if (!this.StoreTypeNameToEdmPrimitiveType.ContainsKey(lowerInvariant)) { throw new ArgumentException(Strings.ProviderDoesNotSupportType((object)lowerInvariant)); } PrimitiveType primitiveType = this.StoreTypeNameToEdmPrimitiveType[lowerInvariant]; int maxLength = 0; bool isUnicode = true; PrimitiveTypeKind primitiveTypeKind; bool flag; bool isFixedLength; switch (lowerInvariant) { case "tinyint": case "smallint": case "bigint": case "bit": case "uniqueidentifier": case "int": case "geography": case "geometry": return(TypeUsage.CreateDefaultTypeUsage((EdmType)primitiveType)); case "varchar": primitiveTypeKind = PrimitiveTypeKind.String; flag = !storeType.TryGetMaxLength(out maxLength); isUnicode = false; isFixedLength = false; break; case "char": primitiveTypeKind = PrimitiveTypeKind.String; flag = !storeType.TryGetMaxLength(out maxLength); isUnicode = false; isFixedLength = true; break; case "nvarchar": primitiveTypeKind = PrimitiveTypeKind.String; flag = !storeType.TryGetMaxLength(out maxLength); isUnicode = true; isFixedLength = false; break; case "nchar": primitiveTypeKind = PrimitiveTypeKind.String; flag = !storeType.TryGetMaxLength(out maxLength); isUnicode = true; isFixedLength = true; break; case "varchar(max)": case "text": primitiveTypeKind = PrimitiveTypeKind.String; flag = true; isUnicode = false; isFixedLength = false; break; case "nvarchar(max)": case "ntext": case "xml": primitiveTypeKind = PrimitiveTypeKind.String; flag = true; isUnicode = true; isFixedLength = false; break; case "binary": primitiveTypeKind = PrimitiveTypeKind.Binary; flag = !storeType.TryGetMaxLength(out maxLength); isFixedLength = true; break; case "varbinary": primitiveTypeKind = PrimitiveTypeKind.Binary; flag = !storeType.TryGetMaxLength(out maxLength); isFixedLength = false; break; case "varbinary(max)": case "image": primitiveTypeKind = PrimitiveTypeKind.Binary; flag = true; isFixedLength = false; break; case "timestamp": case "rowversion": return(TypeUsage.CreateBinaryTypeUsage(primitiveType, true, 8)); case "float": case "real": return(TypeUsage.CreateDefaultTypeUsage((EdmType)primitiveType)); case "decimal": case "numeric": byte precision; byte scale; if (storeType.TryGetPrecision(out precision) && storeType.TryGetScale(out scale)) { return(TypeUsage.CreateDecimalTypeUsage(primitiveType, precision, scale)); } return(TypeUsage.CreateDecimalTypeUsage(primitiveType)); case "money": return(TypeUsage.CreateDecimalTypeUsage(primitiveType, (byte)19, (byte)4)); case "smallmoney": return(TypeUsage.CreateDecimalTypeUsage(primitiveType, (byte)10, (byte)4)); case "datetime": case "datetime2": case "smalldatetime": return(TypeUsage.CreateDateTimeTypeUsage(primitiveType, new byte?())); case "date": return(TypeUsage.CreateDefaultTypeUsage((EdmType)primitiveType)); case "time": return(TypeUsage.CreateTimeTypeUsage(primitiveType, new byte?())); case "datetimeoffset": return(TypeUsage.CreateDateTimeOffsetTypeUsage(primitiveType, new byte?())); default: throw new NotSupportedException(Strings.ProviderDoesNotSupportType((object)lowerInvariant)); } switch (primitiveTypeKind) { case PrimitiveTypeKind.Binary: if (!flag) { return(TypeUsage.CreateBinaryTypeUsage(primitiveType, isFixedLength, maxLength)); } return(TypeUsage.CreateBinaryTypeUsage(primitiveType, isFixedLength)); case PrimitiveTypeKind.String: if (!flag) { return(TypeUsage.CreateStringTypeUsage(primitiveType, isUnicode, isFixedLength, maxLength)); } return(TypeUsage.CreateStringTypeUsage(primitiveType, isUnicode, isFixedLength)); default: throw new NotSupportedException(Strings.ProviderDoesNotSupportType((object)lowerInvariant)); } }
/// <summary> /// This method takes a type and a set of facets and returns the best mapped equivalent type /// in Ingres, taking the store version into consideration. /// </summary> /// <param name="storeType">A TypeUsage encapsulating an EDM type and a set of facets</param> /// <returns>A TypeUsage encapsulating a store type and a set of facets</returns> public override TypeUsage GetStoreType(TypeUsage edmType) { if (edmType == null) { throw new ArgumentNullException("edmType"); } Debug.Assert(edmType.EdmType.BuiltInTypeKind == BuiltInTypeKind.PrimitiveType); var primitiveType = edmType.EdmType as PrimitiveType; if (primitiveType == null) { throw new ArgumentException(String.Format("The underlying provider does not support the type '{0}'.", edmType)); } ReadOnlyMetadataCollection <Facet> facets = edmType.Facets; switch (primitiveType.PrimitiveTypeKind) { case PrimitiveTypeKind.Boolean: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["tinyint"])); case PrimitiveTypeKind.SByte: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["tinyint"])); case PrimitiveTypeKind.Byte: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["smallint"])); case PrimitiveTypeKind.Int16: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["smallint"])); case PrimitiveTypeKind.Int32: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["integer"])); case PrimitiveTypeKind.Int64: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["bigint"])); case PrimitiveTypeKind.Double: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["float"])); case PrimitiveTypeKind.Single: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["real"])); case PrimitiveTypeKind.Decimal: // decimal, money return(TypeUsage.CreateDecimalTypeUsage(StoreTypeNameToStorePrimitiveType["decimal"], TypeHelpers.GetPrecision(edmType, 18), TypeHelpers.GetScale(edmType, 0))); case PrimitiveTypeKind.Binary: // byte, byte varying, long byte { var isFixedLength = facets["FixedLength"].GetValue <bool>(false); var maxLengthFacet = facets["MaxLength"]; var maxLength = maxLengthFacet.GetValue <int?>(); if (maxLengthFacet.IsUnbounded || maxLength == null || maxLength.Value > binaryMaxSize) { maxLength = null; } var storeTypeName = isFixedLength ? "byte" : maxLength == null ? "long byte" : "byte varying"; return(CreateBinaryTypeUsage(StoreTypeNameToStorePrimitiveType[storeTypeName], isFixedLength, maxLength)); } case PrimitiveTypeKind.String: // char, nchar, varchar, nvarchar, long varchar, long nvarchar { var isUnicode = facets["Unicode"].GetValue <bool>(false); var isFixedLength = facets["FixedLength"].GetValue <bool>(false); var maxLengthFacet = facets["MaxLength"]; var maxLength = maxLengthFacet.GetValue <int?>(); if (maxLengthFacet.IsUnbounded || maxLength == null || maxLength.Value > varcharMaxSize) { maxLength = null; } var storeTypeName = isFixedLength ? "char" : "varchar"; storeTypeName = isUnicode ? "n" + storeTypeName : storeTypeName; storeTypeName = (maxLength == null) ? "long " + storeTypeName : storeTypeName; return(CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType[storeTypeName], isUnicode, isFixedLength, maxLength)); } case PrimitiveTypeKind.DateTime: // ingresdate return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["ingresdate"])); case PrimitiveTypeKind.Time: // time return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["time"])); default: throw new NotSupportedException(String.Format("There is no store type corresponding to the EDM type '{0}' of primitive type '{1}'.", edmType, primitiveType.PrimitiveTypeKind)); } }
public override TypeUsage GetEdmType(TypeUsage storeType) { Check.NotNull(storeType, "storeType"); var storeTypeName = storeType.EdmType.Name.ToLowerInvariant(); if (!base.StoreTypeNameToEdmPrimitiveType.ContainsKey(storeTypeName)) { throw new ArgumentException(Strings.ProviderDoesNotSupportType(storeTypeName)); } var edmPrimitiveType = base.StoreTypeNameToEdmPrimitiveType[storeTypeName]; var maxLength = 0; var isUnicode = true; var isFixedLen = false; var isUnbounded = true; PrimitiveTypeKind newPrimitiveTypeKind; switch (storeTypeName) { // for some types we just go with simple type usage with no facets case "tinyint": case "smallint": case "bigint": case "bit": case "uniqueidentifier": case "hierarchyid": case "int": case "geography": case "geometry": return(TypeUsage.CreateDefaultTypeUsage(edmPrimitiveType)); case "varchar": newPrimitiveTypeKind = PrimitiveTypeKind.String; isUnbounded = !storeType.TryGetMaxLength(out maxLength); isUnicode = false; isFixedLen = false; break; case "char": newPrimitiveTypeKind = PrimitiveTypeKind.String; isUnbounded = !storeType.TryGetMaxLength(out maxLength); isUnicode = false; isFixedLen = true; break; case "nvarchar": newPrimitiveTypeKind = PrimitiveTypeKind.String; isUnbounded = !storeType.TryGetMaxLength(out maxLength); isUnicode = true; isFixedLen = false; break; case "nchar": newPrimitiveTypeKind = PrimitiveTypeKind.String; isUnbounded = !storeType.TryGetMaxLength(out maxLength); isUnicode = true; isFixedLen = true; break; case "varchar(max)": case "text": newPrimitiveTypeKind = PrimitiveTypeKind.String; isUnbounded = true; isUnicode = false; isFixedLen = false; break; case "nvarchar(max)": case "ntext": case "xml": newPrimitiveTypeKind = PrimitiveTypeKind.String; isUnbounded = true; isUnicode = true; isFixedLen = false; break; case "binary": newPrimitiveTypeKind = PrimitiveTypeKind.Binary; isUnbounded = !storeType.TryGetMaxLength(out maxLength); isFixedLen = true; break; case "varbinary": newPrimitiveTypeKind = PrimitiveTypeKind.Binary; isUnbounded = !storeType.TryGetMaxLength(out maxLength); isFixedLen = false; break; case "varbinary(max)": case "image": newPrimitiveTypeKind = PrimitiveTypeKind.Binary; isUnbounded = true; isFixedLen = false; break; case "timestamp": case "rowversion": return(TypeUsage.CreateBinaryTypeUsage(edmPrimitiveType, true, 8)); case "float": case "real": return(TypeUsage.CreateDefaultTypeUsage(edmPrimitiveType)); case "decimal": case "numeric": { byte precision; byte scale; if (storeType.TryGetPrecision(out precision) && storeType.TryGetScale(out scale)) { return(TypeUsage.CreateDecimalTypeUsage(edmPrimitiveType, precision, scale)); } else { return(TypeUsage.CreateDecimalTypeUsage(edmPrimitiveType)); } } case "money": return(TypeUsage.CreateDecimalTypeUsage(edmPrimitiveType, 19, 4)); case "smallmoney": return(TypeUsage.CreateDecimalTypeUsage(edmPrimitiveType, 10, 4)); case "datetime": case "datetime2": case "smalldatetime": return(TypeUsage.CreateDateTimeTypeUsage(edmPrimitiveType, null)); case "date": return(TypeUsage.CreateDefaultTypeUsage(edmPrimitiveType)); case "time": return(TypeUsage.CreateTimeTypeUsage(edmPrimitiveType, null)); case "datetimeoffset": return(TypeUsage.CreateDateTimeOffsetTypeUsage(edmPrimitiveType, null)); default: throw new NotSupportedException(Strings.ProviderDoesNotSupportType(storeTypeName)); } Debug.Assert( newPrimitiveTypeKind == PrimitiveTypeKind.String || newPrimitiveTypeKind == PrimitiveTypeKind.Binary, "at this point only string and binary types should be present"); switch (newPrimitiveTypeKind) { case PrimitiveTypeKind.String: if (!isUnbounded) { return(TypeUsage.CreateStringTypeUsage(edmPrimitiveType, isUnicode, isFixedLen, maxLength)); } else { return(TypeUsage.CreateStringTypeUsage(edmPrimitiveType, isUnicode, isFixedLen)); } case PrimitiveTypeKind.Binary: if (!isUnbounded) { return(TypeUsage.CreateBinaryTypeUsage(edmPrimitiveType, isFixedLen, maxLength)); } else { return(TypeUsage.CreateBinaryTypeUsage(edmPrimitiveType, isFixedLen)); } default: throw new NotSupportedException(Strings.ProviderDoesNotSupportType(storeTypeName)); } }
/// <summary> /// This method takes a type and a set of facets and returns the best mapped equivalent type /// in EDM. /// </summary> /// <param name="storeType">A TypeUsage encapsulating a store type and a set of facets</param> /// <returns>A TypeUsage encapsulating an EDM type and a set of facets</returns> public override TypeUsage GetEdmType(TypeUsage storeType) { if (storeType == null) { throw new ArgumentNullException("storeType"); } string storeTypeName = storeType.EdmType.Name.ToLowerInvariant(); if (!base.StoreTypeNameToEdmPrimitiveType.ContainsKey(storeTypeName)) { throw new ArgumentException(String.Format("The underlying provider does not support the type '{0}'.", storeTypeName)); } PrimitiveType edmPrimitiveType = base.StoreTypeNameToEdmPrimitiveType[storeTypeName]; switch (storeTypeName) { // for some types we just go with simple type usage with no facets case "tinyint": case "smallint": case "integer": case "bigint": case "integer1": case "integer2": case "integer4": case "integer8": case "bool": case "int1": case "int2": case "int4": case "int8": case "float": case "float4": case "float8": case "double": case "real": return(TypeUsage.CreateDefaultTypeUsage(edmPrimitiveType)); case "decimal": return(CreateDecimalTypeUsage(edmPrimitiveType, TypeHelpers.GetPrecision(storeType), TypeHelpers.GetScale(storeType))); case "money": return(TypeUsage.CreateDecimalTypeUsage(edmPrimitiveType, 14, 2)); case "varchar": return(CreateStringTypeUsage(edmPrimitiveType, false, false, TypeHelpers.GetMaxLength(storeType))); case "char": return(CreateStringTypeUsage(edmPrimitiveType, false, true, TypeHelpers.GetMaxLength(storeType))); case "nvarchar": return(CreateStringTypeUsage(edmPrimitiveType, true, false, TypeHelpers.GetMaxLength(storeType))); case "nchar": return(CreateStringTypeUsage(edmPrimitiveType, true, true, TypeHelpers.GetMaxLength(storeType))); case "long varchar": return(CreateStringTypeUsage(edmPrimitiveType, false, false)); case "byte": return(CreateBinaryTypeUsage(edmPrimitiveType, true, TypeHelpers.GetMaxLength(storeType))); case "byte varying": return(CreateBinaryTypeUsage(edmPrimitiveType, false, TypeHelpers.GetMaxLength(storeType))); case "long byte": return(CreateBinaryTypeUsage(edmPrimitiveType, false)); case "timestamp": case "rowversion": return(TypeUsage.CreateBinaryTypeUsage(edmPrimitiveType, true, 8)); case "date": case "ingresdate": case "ansidate": return(TypeUsage.CreateDateTimeTypeUsage(edmPrimitiveType, null)); default: throw new NotSupportedException(String.Format("The underlying provider does not support the type '{0}'.", storeTypeName)); } }
public override TypeUsage GetStoreType(TypeUsage edmType) { if (edmType == null) { throw new ArgumentNullException("edmType"); } Debug.Assert(edmType.EdmType.BuiltInTypeKind == BuiltInTypeKind.PrimitiveType); PrimitiveType primitiveType = edmType.EdmType as PrimitiveType; if (primitiveType == null) { throw new ArgumentException(String.Format(Resources.TypeNotSupported, edmType)); } ReadOnlyMetadataCollection <Facet> facets = edmType.Facets; switch (primitiveType.PrimitiveTypeKind) { case PrimitiveTypeKind.Boolean: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["bool"])); case PrimitiveTypeKind.Byte: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["utinyint"])); case PrimitiveTypeKind.SByte: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["tinyint"])); case PrimitiveTypeKind.Int16: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["smallint"])); case PrimitiveTypeKind.Int32: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["int"])); case PrimitiveTypeKind.Int64: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["bigint"])); case PrimitiveTypeKind.Guid: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["guid"])); case PrimitiveTypeKind.Double: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["double"])); case PrimitiveTypeKind.Single: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["float"])); case PrimitiveTypeKind.Decimal: { byte precision = DEFAULT_DECIMAL_PRECISION; byte scale = DEFAULT_DECIMAL_SCALE; Facet facet; if (edmType.Facets.TryGetValue("Precision", false, out facet)) { if (!facet.IsUnbounded && facet.Value != null) { precision = (byte)facet.Value; } } if (edmType.Facets.TryGetValue("Scale", false, out facet)) { if (!facet.IsUnbounded && facet.Value != null) { scale = (byte)facet.Value; } } return(TypeUsage.CreateDecimalTypeUsage(StoreTypeNameToStorePrimitiveType["decimal"], precision, scale)); } case PrimitiveTypeKind.Binary: { bool isFixedLength = null != facets["FixedLength"].Value && (bool)facets["FixedLength"].Value; Facet f = facets["MaxLength"]; bool isMaxLength = f.IsUnbounded || null == f.Value || (int)f.Value > MEDIUMBLOB_MAXLEN; int maxLength = !isMaxLength ? (int)f.Value : LONGBLOB_MAXLEN; string typeName = String.Empty; // now this applies for both isFixedLength and !isFixedLength if (maxLength < CHAR_MAXLEN) { typeName = "tinyblob"; } else if (maxLength < MEDIUMBLOB_MAXLEN) { typeName = "blob"; } else if (maxLength < LONGTEXT_MAXLEN) { typeName = "mediumblob"; } else { typeName = "longblob"; } return(TypeUsage.CreateBinaryTypeUsage(StoreTypeNameToStorePrimitiveType[typeName], isFixedLength, maxLength)); } case PrimitiveTypeKind.String: { string typeName = String.Empty; bool isUnicode = null != facets["Unicode"].Value && (bool)facets["Unicode"].Value; bool isFixedLength = null != facets["FixedLength"].Value && (bool)facets["FixedLength"].Value; int maxLenghtValue; Facet maxLengthFacet = facets["MaxLength"]; if (isFixedLength) { typeName = isUnicode ? "nchar" : "char"; if (maxLengthFacet.Value != null && Int32.TryParse(maxLengthFacet.Value.ToString(), out maxLenghtValue) && maxLenghtValue <= CHAR_MAXLEN) { return(TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType[typeName], isUnicode, isFixedLength, (int)maxLengthFacet.Value)); } else if (maxLengthFacet.Value != null && maxLengthFacet.Value.ToString() == "Max") { return(TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType[typeName], isUnicode, isFixedLength, CHAR_MAXLEN)); } else { return(TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType[typeName], isUnicode, isFixedLength)); } } else { typeName = isUnicode ? "nvarchar" : "varchar"; if (maxLengthFacet.Value != null && Int32.TryParse(maxLengthFacet.Value.ToString(), out maxLenghtValue)) { if (maxLenghtValue > VARCHAR_MAXLEN && maxLenghtValue <= MEDIUMTEXT_MAXLEN) { typeName = "mediumtext"; } else if ((int)maxLengthFacet.Value > MEDIUMTEXT_MAXLEN) { typeName = "longtext"; } return(TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType[typeName], isUnicode, isFixedLength, (int)maxLengthFacet.Value)); } else { return(TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType["longtext"], isUnicode, isFixedLength, LONGBLOB_MAXLEN)); } } } case PrimitiveTypeKind.DateTimeOffset: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["timestamp"])); case PrimitiveTypeKind.DateTime: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["datetime"])); case PrimitiveTypeKind.Time: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["time"])); #if NET_45_OR_GREATER case PrimitiveTypeKind.Geometry: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["geometry"])); #endif default: throw new NotSupportedException(String.Format(Resources.NoStoreTypeForEdmType, edmType, primitiveType.PrimitiveTypeKind)); } }
private TypeUsage ConvertFromLegacyStoreTypeUsage(LegacyMetadata.TypeUsage legacyStoreTypeUsage) { Debug.Assert(legacyStoreTypeUsage != null, "legacyStoreTypeUsage != null"); Debug.Assert(legacyStoreTypeUsage.EdmType is LegacyMetadata.PrimitiveType, "primitive type expected"); Debug.Assert( (LegacyMetadata.DataSpace) typeof(LegacyMetadata.EdmType) .GetProperty("DataSpace", BindingFlags.Instance | BindingFlags.NonPublic) .GetValue(legacyStoreTypeUsage.EdmType) == LegacyMetadata.DataSpace.SSpace, "Expected SSpace type."); var legacyStorePrimitiveType = (LegacyMetadata.PrimitiveType)legacyStoreTypeUsage.EdmType; var storePrimitiveType = _storeTypes.Single(t => t.FullName == legacyStorePrimitiveType.FullName); switch (storePrimitiveType.PrimitiveTypeKind) { case PrimitiveTypeKind.Boolean: case PrimitiveTypeKind.Byte: case PrimitiveTypeKind.SByte: case PrimitiveTypeKind.Int16: case PrimitiveTypeKind.Int32: case PrimitiveTypeKind.Int64: case PrimitiveTypeKind.Guid: case PrimitiveTypeKind.Double: case PrimitiveTypeKind.Single: case PrimitiveTypeKind.Geography: case PrimitiveTypeKind.GeographyPoint: case PrimitiveTypeKind.GeographyLineString: case PrimitiveTypeKind.GeographyPolygon: case PrimitiveTypeKind.GeographyMultiPoint: case PrimitiveTypeKind.GeographyMultiLineString: case PrimitiveTypeKind.GeographyMultiPolygon: case PrimitiveTypeKind.GeographyCollection: case PrimitiveTypeKind.Geometry: case PrimitiveTypeKind.GeometryPoint: case PrimitiveTypeKind.GeometryLineString: case PrimitiveTypeKind.GeometryPolygon: case PrimitiveTypeKind.GeometryMultiPoint: case PrimitiveTypeKind.GeometryMultiLineString: case PrimitiveTypeKind.GeometryMultiPolygon: case PrimitiveTypeKind.GeometryCollection: return(TypeUsage.CreateDefaultTypeUsage(storePrimitiveType)); case PrimitiveTypeKind.Decimal: return(TypeUsage.CreateDecimalTypeUsage( storePrimitiveType, (byte)legacyStoreTypeUsage.Facets[PrecisionFacetName].Value, (byte)legacyStoreTypeUsage.Facets[ScaleFacetName].Value)); case PrimitiveTypeKind.Binary: return(TypeUsage.CreateBinaryTypeUsage( storePrimitiveType, (bool)legacyStoreTypeUsage.Facets[FixedLengthFacetName].Value, (int)legacyStoreTypeUsage.Facets[MaxLengthFacetName].Value)); case PrimitiveTypeKind.DateTime: return(TypeUsage.CreateDateTimeTypeUsage( storePrimitiveType, (byte?)legacyStoreTypeUsage.Facets[PrecisionFacetName].Value)); case PrimitiveTypeKind.DateTimeOffset: return(TypeUsage.CreateDateTimeOffsetTypeUsage( storePrimitiveType, (byte?)legacyStoreTypeUsage.Facets[PrecisionFacetName].Value)); case PrimitiveTypeKind.Time: return(TypeUsage.CreateTimeTypeUsage( storePrimitiveType, (byte?)legacyStoreTypeUsage.Facets[PrecisionFacetName].Value)); case PrimitiveTypeKind.String: return(TypeUsage.CreateStringTypeUsage( storePrimitiveType, (bool)legacyStoreTypeUsage.Facets[UnicodeFacetName].Value, (bool)legacyStoreTypeUsage.Facets[FixedLengthFacetName].Value, (int)legacyStoreTypeUsage.Facets[MaxLengthFacetName].Value)); } Debug.Fail("Unknown primitive type kind."); throw new NotSupportedException(); }
/// <summary> /// This method takes a type and a set of facets and returns the best mapped equivalent type /// in Jet /// </summary> /// <param name="storeType">A TypeUsage encapsulating an EDM type and a set of facets</param> /// <returns>A TypeUsage encapsulating a store type and a set of facets</returns> public override TypeUsage GetStoreType(TypeUsage edmType) { if (edmType == null) { throw new ArgumentNullException("edmType"); } System.Diagnostics.Debug.Assert(edmType.EdmType.BuiltInTypeKind == BuiltInTypeKind.PrimitiveType); PrimitiveType primitiveType = edmType.EdmType as PrimitiveType; if (primitiveType == null) { throw new ArgumentException(String.Format("The underlying provider does not support the type '{0}'.", edmType)); } ReadOnlyMetadataCollection <Facet> facets = edmType.Facets; switch (primitiveType.PrimitiveTypeKind) { case PrimitiveTypeKind.Boolean: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["bit"])); case PrimitiveTypeKind.Byte: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["tinyint"])); case PrimitiveTypeKind.Int16: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["smallint"])); case PrimitiveTypeKind.Int32: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["int"])); case PrimitiveTypeKind.Int64: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["int"])); case PrimitiveTypeKind.Guid: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["guid"])); case PrimitiveTypeKind.Double: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["float"])); case PrimitiveTypeKind.Single: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["real"])); case PrimitiveTypeKind.Decimal: // decimal, numeric, smallmoney, money { byte precision; if (!edmType.TryGetPrecision(out precision)) { precision = 18; } byte scale; if (!edmType.TryGetScale(out scale)) { scale = 0; } return(TypeUsage.CreateDecimalTypeUsage(StoreTypeNameToStorePrimitiveType["decimal"], precision, scale)); } case PrimitiveTypeKind.Binary: // binary, varbinary, image { bool isFixedLength = edmType.GetIsFixedLength(); bool isMaxLength = edmType.GetMaxLength() > BINARY_MAXSIZE; int maxLength = edmType.GetMaxLength(); TypeUsage tu; if (isFixedLength) { tu = TypeUsage.CreateBinaryTypeUsage(StoreTypeNameToStorePrimitiveType["binary"], true, maxLength); } else if (isMaxLength) { tu = TypeUsage.CreateBinaryTypeUsage(StoreTypeNameToStorePrimitiveType["image"], false); System.Diagnostics.Debug.Assert(tu.Facets["MaxLength"].Description.IsConstant, "varbinary(max) is not constant!"); } else { tu = TypeUsage.CreateBinaryTypeUsage(StoreTypeNameToStorePrimitiveType["varbinary"], false, maxLength); } return(tu); } case PrimitiveTypeKind.String: // char, varchar, text { bool isUnicode = edmType.GetIsUnicode(); // We do not handle unicode (everything's unicode in Jet) bool isFixedLength = edmType.GetIsFixedLength(); bool isMaxLength = edmType.GetMaxLength() > VARCHAR_MAXSIZE; int maxLength = edmType.GetMaxLength(); TypeUsage tu; if (isFixedLength) { tu = TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType["char"], false, true, maxLength); } else if (isMaxLength) { tu = TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType["text"], false, false); } else { tu = TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType["varchar"], false, false, maxLength); } return(tu); } case PrimitiveTypeKind.DateTime: // datetime return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["datetime"])); case PrimitiveTypeKind.Time: // time return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["time"])); default: throw new NotSupportedException(String.Format("There is no store type corresponding to the EDM type '{0}' of primitive type '{1}'.", edmType, primitiveType.PrimitiveTypeKind)); } }
public override TypeUsage GetStoreType(TypeUsage edmType) { Check.NotNull <TypeUsage>(edmType, nameof(edmType)); PrimitiveType edmType1 = edmType.EdmType as PrimitiveType; if (edmType1 == null) { throw new ArgumentException(Strings.ProviderDoesNotSupportType((object)edmType.EdmType.Name)); } ReadOnlyMetadataCollection <Facet> facets = edmType.Facets; switch (edmType1.PrimitiveTypeKind) { case PrimitiveTypeKind.Binary: bool flag1 = facets["FixedLength"].Value != null && (bool)facets["FixedLength"].Value; Facet facet1 = facets["MaxLength"]; bool flag2 = facet1.IsUnbounded || facet1.Value == null || (int)facet1.Value > 8000; int maxLength1 = !flag2 ? (int)facet1.Value : int.MinValue; return(!flag1 ? (!flag2 ? TypeUsage.CreateBinaryTypeUsage(this.StoreTypeNameToStorePrimitiveType["varbinary"], false, maxLength1) : (this._version == SqlVersion.Sql8 ? TypeUsage.CreateBinaryTypeUsage(this.StoreTypeNameToStorePrimitiveType["varbinary"], false, 8000) : TypeUsage.CreateBinaryTypeUsage(this.StoreTypeNameToStorePrimitiveType["varbinary(max)"], false))) : TypeUsage.CreateBinaryTypeUsage(this.StoreTypeNameToStorePrimitiveType["binary"], true, flag2 ? 8000 : maxLength1)); case PrimitiveTypeKind.Boolean: return(TypeUsage.CreateDefaultTypeUsage((EdmType)this.StoreTypeNameToStorePrimitiveType["bit"])); case PrimitiveTypeKind.Byte: return(TypeUsage.CreateDefaultTypeUsage((EdmType)this.StoreTypeNameToStorePrimitiveType["tinyint"])); case PrimitiveTypeKind.DateTime: return(TypeUsage.CreateDefaultTypeUsage((EdmType)this.StoreTypeNameToStorePrimitiveType["datetime"])); case PrimitiveTypeKind.Decimal: byte precision; if (!edmType.TryGetPrecision(out precision)) { precision = (byte)18; } byte scale; if (!edmType.TryGetScale(out scale)) { scale = (byte)0; } return(TypeUsage.CreateDecimalTypeUsage(this.StoreTypeNameToStorePrimitiveType["decimal"], precision, scale)); case PrimitiveTypeKind.Double: return(TypeUsage.CreateDefaultTypeUsage((EdmType)this.StoreTypeNameToStorePrimitiveType["float"])); case PrimitiveTypeKind.Guid: return(TypeUsage.CreateDefaultTypeUsage((EdmType)this.StoreTypeNameToStorePrimitiveType["uniqueidentifier"])); case PrimitiveTypeKind.Single: return(TypeUsage.CreateDefaultTypeUsage((EdmType)this.StoreTypeNameToStorePrimitiveType["real"])); case PrimitiveTypeKind.Int16: return(TypeUsage.CreateDefaultTypeUsage((EdmType)this.StoreTypeNameToStorePrimitiveType["smallint"])); case PrimitiveTypeKind.Int32: return(TypeUsage.CreateDefaultTypeUsage((EdmType)this.StoreTypeNameToStorePrimitiveType["int"])); case PrimitiveTypeKind.Int64: return(TypeUsage.CreateDefaultTypeUsage((EdmType)this.StoreTypeNameToStorePrimitiveType["bigint"])); case PrimitiveTypeKind.String: bool flag3 = facets["Unicode"].Value == null || (bool)facets["Unicode"].Value; bool flag4 = facets["FixedLength"].Value != null && (bool)facets["FixedLength"].Value; Facet facet2 = facets["MaxLength"]; bool flag5 = facet2.IsUnbounded || facet2.Value == null || (int)facet2.Value > (flag3 ? 4000 : 8000); int maxLength2 = !flag5 ? (int)facet2.Value : int.MinValue; return(!flag3 ? (!flag4 ? (!flag5 ? TypeUsage.CreateStringTypeUsage(this.StoreTypeNameToStorePrimitiveType["varchar"], false, false, maxLength2) : (this._version == SqlVersion.Sql8 ? TypeUsage.CreateStringTypeUsage(this.StoreTypeNameToStorePrimitiveType["varchar"], false, false, 8000) : TypeUsage.CreateStringTypeUsage(this.StoreTypeNameToStorePrimitiveType["varchar(max)"], false, false))) : TypeUsage.CreateStringTypeUsage(this.StoreTypeNameToStorePrimitiveType["char"], false, true, flag5 ? 8000 : maxLength2)) : (!flag4 ? (!flag5 ? TypeUsage.CreateStringTypeUsage(this.StoreTypeNameToStorePrimitiveType["nvarchar"], true, false, maxLength2) : (this._version == SqlVersion.Sql8 ? TypeUsage.CreateStringTypeUsage(this.StoreTypeNameToStorePrimitiveType["nvarchar"], true, false, 4000) : TypeUsage.CreateStringTypeUsage(this.StoreTypeNameToStorePrimitiveType["nvarchar(max)"], true, false))) : TypeUsage.CreateStringTypeUsage(this.StoreTypeNameToStorePrimitiveType["nchar"], true, true, flag5 ? 4000 : maxLength2))); case PrimitiveTypeKind.Time: return(this.GetStorePrimitiveTypeIfPostSql9("time", edmType.EdmType.Name, edmType1.PrimitiveTypeKind)); case PrimitiveTypeKind.DateTimeOffset: return(this.GetStorePrimitiveTypeIfPostSql9("datetimeoffset", edmType.EdmType.Name, edmType1.PrimitiveTypeKind)); case PrimitiveTypeKind.Geometry: case PrimitiveTypeKind.GeometryPoint: case PrimitiveTypeKind.GeometryLineString: case PrimitiveTypeKind.GeometryPolygon: case PrimitiveTypeKind.GeometryMultiPoint: case PrimitiveTypeKind.GeometryMultiLineString: case PrimitiveTypeKind.GeometryMultiPolygon: case PrimitiveTypeKind.GeometryCollection: return(this.GetStorePrimitiveTypeIfPostSql9("geometry", edmType.EdmType.Name, edmType1.PrimitiveTypeKind)); case PrimitiveTypeKind.Geography: case PrimitiveTypeKind.GeographyPoint: case PrimitiveTypeKind.GeographyLineString: case PrimitiveTypeKind.GeographyPolygon: case PrimitiveTypeKind.GeographyMultiPoint: case PrimitiveTypeKind.GeographyMultiLineString: case PrimitiveTypeKind.GeographyMultiPolygon: case PrimitiveTypeKind.GeographyCollection: return(this.GetStorePrimitiveTypeIfPostSql9("geography", edmType.EdmType.Name, edmType1.PrimitiveTypeKind)); default: throw new NotSupportedException(Strings.NoStoreTypeForEdmType((object)edmType.EdmType.Name, (object)edmType1.PrimitiveTypeKind)); } }
public void Can_create_composable_function_import_with_complex_type_collection_result() { DbProviderManifest providerManifest; var containerMapping = GetContainerMapping(out providerManifest); var cTypeUsageString = TypeUsage.CreateDefaultTypeUsage( PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); var sTypeUsageString = providerManifest.GetStoreType(cTypeUsageString); var complexType = ComplexType.Create( "RT", "N", DataSpace.CSpace, new[] { EdmProperty.Create("P1", cTypeUsageString), EdmProperty.Create("P2", cTypeUsageString) }, null); var rowType = RowType.Create( new[] { EdmProperty.Create("C1", sTypeUsageString), EdmProperty.Create("C2", sTypeUsageString) }, null); var functionImport = EdmFunction.Create( "F", "N", DataSpace.CSpace, new EdmFunctionPayload { IsComposable = true, ReturnParameters = new[] { FunctionParameter.Create("R", complexType.GetCollectionType(), ParameterMode.ReturnValue) } }, null); var targetFunction = EdmFunction.Create( "SF", "N", DataSpace.SSpace, new EdmFunctionPayload { IsComposable = true, ReturnParameters = new[] { FunctionParameter.Create("R", rowType.GetCollectionType(), ParameterMode.ReturnValue) } }, null); var typeMapping = new FunctionImportComplexTypeMapping( complexType, new Collection <FunctionImportReturnTypePropertyMapping>() { new FunctionImportReturnTypeScalarPropertyMapping("P1", "C1"), new FunctionImportReturnTypeScalarPropertyMapping("P2", "C2"), }); var resultMapping = new FunctionImportResultMapping(); resultMapping.AddTypeMapping(typeMapping); var functionImportMapping = new FunctionImportMappingComposable( functionImport, targetFunction, resultMapping, containerMapping); Assert.Same(resultMapping, functionImportMapping.ResultMapping); Assert.Equal(1, functionImportMapping.StructuralTypeMappings.Count); Assert.Null(functionImportMapping.TvfKeys); }
public override TypeUsage GetStoreType(TypeUsage edmType) { if (edmType == null) { throw new ArgumentNullException("edmType"); } PrimitiveType primitiveType = edmType.EdmType as PrimitiveType; if (primitiveType == null) { throw new ArgumentException("Store does not support specified edm type"); } // TODO: come up with way to determin if unicode is used bool isUnicode = true; Facet facet; switch (primitiveType.PrimitiveTypeKind) { case PrimitiveTypeKind.Boolean: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["bool"])); case PrimitiveTypeKind.Int16: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["int2"])); case PrimitiveTypeKind.Int32: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["int4"])); case PrimitiveTypeKind.Int64: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["int8"])); case PrimitiveTypeKind.Single: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["float4"])); case PrimitiveTypeKind.Double: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["float8"])); case PrimitiveTypeKind.Decimal: { byte scale; byte precision; if (edmType.Facets.TryGetValue(ScaleFacet, false, out facet) && !facet.IsUnbounded && facet.Value != null) { scale = (byte)facet.Value; if (edmType.Facets.TryGetValue(PrecisionFacet, false, out facet) && !facet.IsUnbounded && facet.Value != null) { precision = (byte)facet.Value; return(TypeUsage.CreateDecimalTypeUsage(StoreTypeNameToStorePrimitiveType["numeric"], precision, scale)); } } return(TypeUsage.CreateDecimalTypeUsage(StoreTypeNameToStorePrimitiveType["numeric"])); } case PrimitiveTypeKind.String: { // TODO: could get character, character varying, text if (edmType.Facets.TryGetValue(FixedLengthFacet, false, out facet) && !facet.IsUnbounded && facet.Value != null) { PrimitiveType characterPrimitive = StoreTypeNameToStorePrimitiveType["bpchar"]; if (edmType.Facets.TryGetValue(MaxLengthFacet, false, out facet) && !facet.IsUnbounded && facet.Value != null) { return(TypeUsage.CreateStringTypeUsage(characterPrimitive, isUnicode, true, (int)facet.Value)); } // this may not work well return(TypeUsage.CreateStringTypeUsage(characterPrimitive, isUnicode, true)); } if (edmType.Facets.TryGetValue(MaxLengthFacet, false, out facet) && !facet.IsUnbounded && facet.Value != null) { return(TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType["varchar"], isUnicode, false, (int)facet.Value)); } // assume text since it is not fixed length and has no max length return(TypeUsage.CreateStringTypeUsage(StoreTypeNameToStorePrimitiveType["text"], isUnicode, false)); } case PrimitiveTypeKind.DateTime: if (edmType.Facets.TryGetValue(PrecisionFacet, false, out facet) && !facet.IsUnbounded && facet.Value != null) { return(TypeUsage.CreateDateTimeTypeUsage(StoreTypeNameToStorePrimitiveType["timestamp"], (byte)facet.Value)); } else { return(TypeUsage.CreateDateTimeTypeUsage(StoreTypeNameToStorePrimitiveType["timestamp"], null)); } case PrimitiveTypeKind.DateTimeOffset: if (edmType.Facets.TryGetValue(PrecisionFacet, false, out facet) && !facet.IsUnbounded && facet.Value != null) { return(TypeUsage.CreateDateTimeOffsetTypeUsage(StoreTypeNameToStorePrimitiveType["timestamptz"], (byte)facet.Value)); } else { return(TypeUsage.CreateDateTimeOffsetTypeUsage(StoreTypeNameToStorePrimitiveType["timestamptz"], null)); } case PrimitiveTypeKind.Time: if (edmType.Facets.TryGetValue(PrecisionFacet, false, out facet) && !facet.IsUnbounded && facet.Value != null) { return(TypeUsage.CreateTimeTypeUsage(StoreTypeNameToStorePrimitiveType["interval"], (byte)facet.Value)); } else { return(TypeUsage.CreateTimeTypeUsage(StoreTypeNameToStorePrimitiveType["interval"], null)); } case PrimitiveTypeKind.Binary: { if (edmType.Facets.TryGetValue(MaxLengthFacet, false, out facet) && !facet.IsUnbounded && facet.Value != null) { return(TypeUsage.CreateBinaryTypeUsage(StoreTypeNameToStorePrimitiveType["bytea"], false, (int)facet.Value)); } return(TypeUsage.CreateBinaryTypeUsage(StoreTypeNameToStorePrimitiveType["bytea"], false)); } case PrimitiveTypeKind.Guid: return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType["uuid"])); // notably missing // PrimitiveTypeKind.Byte: // PrimitiveTypeKind.SByte: } throw new NotSupportedException(); }
public override TypeUsage GetEdmType(TypeUsage storeType) { if (storeType == null) { throw new ArgumentNullException("storeType"); } string storeTypeName = storeType.EdmType.Name; PrimitiveType primitiveType = StoreTypeNameToEdmPrimitiveType[storeTypeName]; // TODO: come up with way to determin if unicode is used bool isUnicode = true; Facet facet; switch (storeTypeName) { case "bool": case "int2": case "int4": case "int8": case "float4": case "float8": case "uuid": return(TypeUsage.CreateDefaultTypeUsage(primitiveType)); case "numeric": { byte scale; byte precision; if (storeType.Facets.TryGetValue(ScaleFacet, false, out facet) && !facet.IsUnbounded && facet.Value != null) { scale = (byte)facet.Value; if (storeType.Facets.TryGetValue(PrecisionFacet, false, out facet) && !facet.IsUnbounded && facet.Value != null) { precision = (byte)facet.Value; return(TypeUsage.CreateDecimalTypeUsage(primitiveType, precision, scale)); } } return(TypeUsage.CreateDecimalTypeUsage(primitiveType)); } case "bpchar": if (storeType.Facets.TryGetValue(MaxLengthFacet, false, out facet) && !facet.IsUnbounded && facet.Value != null) { return(TypeUsage.CreateStringTypeUsage(primitiveType, isUnicode, true, (int)facet.Value)); } else { return(TypeUsage.CreateStringTypeUsage(primitiveType, isUnicode, true)); } case "varchar": if (storeType.Facets.TryGetValue(MaxLengthFacet, false, out facet) && !facet.IsUnbounded && facet.Value != null) { return(TypeUsage.CreateStringTypeUsage(primitiveType, isUnicode, false, (int)facet.Value)); } else { return(TypeUsage.CreateStringTypeUsage(primitiveType, isUnicode, false)); } case "text": case "xml": return(TypeUsage.CreateStringTypeUsage(primitiveType, isUnicode, false)); case "timestamp": // TODO: make sure the arguments are correct here if (storeType.Facets.TryGetValue(PrecisionFacet, false, out facet) && !facet.IsUnbounded && facet.Value != null) { return(TypeUsage.CreateDateTimeTypeUsage(primitiveType, (byte)facet.Value)); } else { return(TypeUsage.CreateDateTimeTypeUsage(primitiveType, null)); } case "date": return(TypeUsage.CreateDateTimeTypeUsage(primitiveType, 0)); case "timestamptz": if (storeType.Facets.TryGetValue(PrecisionFacet, false, out facet) && !facet.IsUnbounded && facet.Value != null) { return(TypeUsage.CreateDateTimeOffsetTypeUsage(primitiveType, (byte)facet.Value)); } else { return(TypeUsage.CreateDateTimeOffsetTypeUsage(primitiveType, null)); } case "time": case "interval": if (storeType.Facets.TryGetValue(PrecisionFacet, false, out facet) && !facet.IsUnbounded && facet.Value != null) { return(TypeUsage.CreateTimeTypeUsage(primitiveType, (byte)facet.Value)); } else { return(TypeUsage.CreateTimeTypeUsage(primitiveType, null)); } case "bytea": { if (storeType.Facets.TryGetValue(MaxLengthFacet, false, out facet) && !facet.IsUnbounded && facet.Value != null) { return(TypeUsage.CreateBinaryTypeUsage(primitiveType, false, (int)facet.Value)); } return(TypeUsage.CreateBinaryTypeUsage(primitiveType, false)); } case "rowversion": { return(TypeUsage.CreateBinaryTypeUsage(primitiveType, true, 8)); } //TypeUsage.CreateBinaryTypeUsage //TypeUsage.CreateDateTimeTypeUsage //TypeUsage.CreateDecimalTypeUsage //TypeUsage.CreateStringTypeUsage } throw new NotSupportedException("Not supported store type: " + storeTypeName); }
private TypeUsage BuildTypeUsage() { var primitiveType = PrimitiveType.GetEdmPrimitiveType(Type); if (Type == PrimitiveTypeKind.Binary) { if (MaxLength != null) { return(TypeUsage.CreateBinaryTypeUsage( primitiveType, IsFixedLength ?? false, MaxLength.Value)); } return(TypeUsage.CreateBinaryTypeUsage( primitiveType, IsFixedLength ?? false)); } if (Type == PrimitiveTypeKind.String) { if (MaxLength != null) { return(TypeUsage.CreateStringTypeUsage( primitiveType, IsUnicode ?? true, IsFixedLength ?? false, MaxLength.Value)); } return(TypeUsage.CreateStringTypeUsage( primitiveType, IsUnicode ?? true, IsFixedLength ?? false)); } if (Type == PrimitiveTypeKind.DateTime) { return(TypeUsage.CreateDateTimeTypeUsage(primitiveType, Precision)); } if (Type == PrimitiveTypeKind.DateTimeOffset) { return(TypeUsage.CreateDateTimeOffsetTypeUsage(primitiveType, Precision)); } if (Type == PrimitiveTypeKind.Decimal) { if ((Precision != null) || (Scale != null)) { return(TypeUsage.CreateDecimalTypeUsage( primitiveType, Precision ?? 18, Scale ?? 0)); } return(TypeUsage.CreateDecimalTypeUsage(primitiveType)); } return((Type == PrimitiveTypeKind.Time) ? TypeUsage.CreateTimeTypeUsage(primitiveType, Precision) : TypeUsage.CreateDefaultTypeUsage(primitiveType)); }