mcs/class/referencesource/System.Data.Entity/System/Data/Metadata/TypeHelpers.cs

   1 //---------------------------------------------------------------------
   2 // <copyright file="TypeHelpers.cs" company="Microsoft">
   3 //      Copyright(c) Microsoft Corporation.  All rights reserved.
   4 // </copyright>
   5 //
   6 // @owner       Microsoft
   7 // @backupOwner Microsoft
   8 //---------------------------------------------------------------------
   9
  10 namespace System.Data.Common
  11 {
  12     using System;
  13     using System.Collections;
  14     using System.Collections.Generic;
  15     using System.Data;
  16     using System.Data.Common.CommandTrees;
  17     using System.Data.Metadata.Edm;
  18     using System.Data.Objects.ELinq;
  19     using System.Diagnostics;
  20     using System.Globalization;
  21
  22     /// <summary>
  23     /// Represents a set of static Type helpers operating on TypeMetadata
  24     /// </summary>
  25     internal static class TypeHelpers
  26     {
  27         #region Assert Types
  28
  29         /// <summary>
  30         /// Asserts types are in Model space
  31         /// </summary>
  32         /// <param name="typeUsage"></param>
  33         [Conditional("DEBUG")]
  34         internal static void AssertEdmType(TypeUsage typeUsage)
  35         {
  36             EdmType type = typeUsage.EdmType;
  37             if (TypeSemantics.IsCollectionType(typeUsage))
  38             {
  39                 AssertEdmType(TypeHelpers.GetElementTypeUsage(typeUsage));
  40             }
  41             else if (TypeSemantics.IsStructuralType(typeUsage) && !Helper.IsComplexType(typeUsage.EdmType) && !Helper.IsEntityType(typeUsage.EdmType))
  42             {
  43                 foreach (EdmMember m in TypeHelpers.GetDeclaredStructuralMembers(typeUsage))
  44                 {
  45                     AssertEdmType(m.TypeUsage);
  46                 }
  47             }
  48             else if (TypeSemantics.IsPrimitiveType(typeUsage))
  49             {
  50                 PrimitiveType pType = type as PrimitiveType;
  51                 if (null != pType)
  52                 {
  53                     if (pType.DataSpace != DataSpace.CSpace)
  54                         throw new NotSupportedException(String.Format(CultureInfo.InvariantCulture, "PrimitiveType must be CSpace '{0}'", typeUsage.ToString()));
  55                 }
  56             }
  57         }
  58
  59         /// <summary>
  60         /// Asserts querycommandtrees are in model space type terms
  61         /// </summary>
  62         /// <param name="commandTree"></param>
  63         [Conditional("DEBUG")]
  64         internal static void AssertEdmType(DbCommandTree commandTree)
  65         {
  66             DbQueryCommandTree queryCommandTree = commandTree as DbQueryCommandTree;
  67             if (null != queryCommandTree)
  68             {
  69                 AssertEdmType(queryCommandTree.Query.ResultType);
  70             }
  71         }
  72         #endregion
  73
  74         //
  75         // Type Semantics
  76         //
  77         #region Type Semantics
  78
  79         /// <summary>
  80         /// Determines whether a given typeUsage is valid as OrderBy sort key
  81         /// </summary>
  82         /// <param name="typeUsage"></param>
  83         /// <returns></returns>
  84         internal static bool IsValidSortOpKeyType(TypeUsage typeUsage)
  85         {
  86             if (TypeSemantics.IsRowType(typeUsage))
  87             {
  88                 RowType rowType = (RowType)typeUsage.EdmType;
  89                 foreach (EdmProperty property in rowType.Properties)
  90                 {
  91                     if (!IsValidSortOpKeyType(property.TypeUsage))
  92                     {
  93                         return false;
  94                     }
  95                 }
  96                 return true;
  97             }
  98             else
  99             {
 100                 return TypeSemantics.IsOrderComparable(typeUsage);
 101             }
 102         }
 103
 104         /// <summary>
 105         /// Determines whether a given typeusage is valid as GroupBy key
 106         /// </summary>
 107         /// <param name="typeUsage"></param>
 108         /// <returns></returns>
 109         internal static bool IsValidGroupKeyType(TypeUsage typeUsage)
 110         {
 111             return IsSetComparableOpType(typeUsage);
 112         }
 113
 114         /// <summary>
 115         /// Determine wheter a given typeusage is valid for Distinct operator
 116         /// </summary>
 117         /// <param name="typeUsage"></param>
 118         /// <returns></returns>
 119         internal static bool IsValidDistinctOpType(TypeUsage typeUsage)
 120         {
 121             return IsSetComparableOpType(typeUsage);
 122         }
 123
 124         /// <summary>
 125         /// Determine wheter a given typeusage is valid for set comparison operator such as UNION, INTERSECT and EXCEPT
 126         /// </summary>
 127         /// <param name="typeUsage"></param>
 128         /// <returns></returns>
 129         internal static bool IsSetComparableOpType(TypeUsage typeUsage)
 130         {
 131             if (Helper.IsEntityType(typeUsage.EdmType)    ||
 132                 Helper.IsPrimitiveType(typeUsage.EdmType) ||
 133                 Helper.IsEnumType(typeUsage.EdmType)      ||
 134                 Helper.IsRefType(typeUsage.EdmType)        )
 135             {
 136                 return true;
 137             }
 138             else if (TypeSemantics.IsRowType(typeUsage))
 139             {
 140                 RowType rowType = (RowType)typeUsage.EdmType;
 141                 foreach (EdmProperty property in rowType.Properties)
 142                 {
 143                     if (!IsSetComparableOpType(property.TypeUsage))
 144                     {
 145                         return false;
 146                     }
 147                 }
 148                 return true;
 149             }
 150             return false;
 151         }
 152
 153         /// <summary>
 154         /// Returns true if typeUsage type is valid for IS [NOT] NULL (expr) operator
 155         /// </summary>
 156         /// <param name="typeUsage"></param>
 157         /// <returns></returns>
 158         internal static bool IsValidIsNullOpType(TypeUsage typeUsage)
 159         {
 160             return TypeSemantics.IsReferenceType(typeUsage) ||
 161                    TypeSemantics.IsEntityType(typeUsage)    ||
 162                    TypeSemantics.IsScalarType(typeUsage);
 163         }
 164
 165
 166         internal static bool IsValidInOpType(TypeUsage typeUsage)
 167         {
 168             return TypeSemantics.IsReferenceType(typeUsage) ||
 169                    TypeSemantics.IsEntityType(typeUsage) ||
 170                    TypeSemantics.IsScalarType(typeUsage);
 171         }
 172
 173         internal static TypeUsage GetCommonTypeUsage(TypeUsage typeUsage1, TypeUsage typeUsage2)
 174         {
 175             return TypeSemantics.GetCommonType(typeUsage1, typeUsage2);
 176         }
 177
 178         internal static TypeUsage GetCommonTypeUsage(IEnumerable<TypeUsage> types)
 179         {
 180             TypeUsage commonType = null;
 181             foreach (TypeUsage testType in types)
 182             {
 183                 if (null == testType)
 184                 {
 185                     return null;
 186                 }
 187
 188                 if (null == commonType)
 189                 {
 190                     commonType = testType;
 191                 }
 192                 else
 193                 {
 194                     commonType = TypeSemantics.GetCommonType(commonType, testType);
 195                     if (null == commonType)
 196                     {
 197                         break;
 198                     }
 199                 }
 200             }
 201             return commonType;
 202         }
 203
 204         #endregion
 205
 206         //
 207         // Type property extractors
 208         //
 209         #region Type property extractors
 210
 211         internal static bool TryGetClosestPromotableType(TypeUsage fromType, out TypeUsage promotableType)
 212         {
 213             promotableType = null;
 214             if (Helper.IsPrimitiveType(fromType.EdmType))
 215             {
 216                 PrimitiveType fromPrimitiveType = (PrimitiveType)fromType.EdmType;
 217                 IList<PrimitiveType> promotableTypes = EdmProviderManifest.Instance.GetPromotionTypes(fromPrimitiveType);
 218                 int index = promotableTypes.IndexOf(fromPrimitiveType);
 219                 if (-1 != index && index + 1 < promotableTypes.Count)
 220                 {
 221                     promotableType = TypeUsage.Create(promotableTypes[index + 1]);
 222                 }
 223             }
 224             return (null != promotableType);
 225         }
 226
 227
 228         #endregion
 229
 230         //
 231         // Facet Helpers
 232         //
 233         #region Facet Helpers
 234
 235         internal static bool TryGetBooleanFacetValue(TypeUsage type, string facetName, out bool boolValue)
 236         {
 237             boolValue = false;
 238             Facet boolFacet;
 239             if (type.Facets.TryGetValue(facetName, false, out boolFacet) && boolFacet.Value != null)
 240             {
 241                 boolValue = (bool)boolFacet.Value;
 242                 return true;
 243             }
 244
 245             return false;
 246         }
 247
 248         internal static bool TryGetByteFacetValue(TypeUsage type, string facetName, out byte byteValue)
 249         {
 250             byteValue = 0;
 251             Facet byteFacet;
 252             if (type.Facets.TryGetValue(facetName, false, out byteFacet) && byteFacet.Value != null && !Helper.IsUnboundedFacetValue(byteFacet))
 253             {
 254                 byteValue = (byte)byteFacet.Value;
 255                 return true;
 256             }
 257
 258             return false;
 259         }
 260
 261         internal static bool TryGetIntFacetValue(TypeUsage type, string facetName, out int intValue)
 262         {
 263             intValue = 0;
 264             Facet intFacet;
 265             if (type.Facets.TryGetValue(facetName, false, out intFacet) && intFacet.Value != null && !Helper.IsUnboundedFacetValue(intFacet) && !Helper.IsVariableFacetValue(intFacet))
 266             {
 267                 intValue = (int)intFacet.Value;
 268                 return true;
 269             }
 270
 271             return false;
 272         }
 273
 274         internal static bool TryGetIsFixedLength(TypeUsage type, out bool isFixedLength)
 275         {
 276             if (!TypeSemantics.IsPrimitiveType(type, PrimitiveTypeKind.String) &&
 277                 !TypeSemantics.IsPrimitiveType(type, PrimitiveTypeKind.Binary))
 278             {
 279                 isFixedLength = false;
 280                 return false;
 281             }
 282
 283             // Binary and String MaxLength facets share the same name
 284             return TypeHelpers.TryGetBooleanFacetValue(type, DbProviderManifest.FixedLengthFacetName, out isFixedLength);
 285         }
 286
 287         internal static bool TryGetIsUnicode(TypeUsage type, out bool isUnicode)
 288         {
 289             if (!TypeSemantics.IsPrimitiveType(type, PrimitiveTypeKind.String))
 290             {
 291                 isUnicode = false;
 292                 return false;
 293             }
 294
 295             return TypeHelpers.TryGetBooleanFacetValue(type, DbProviderManifest.UnicodeFacetName, out isUnicode);
 296         }
 297
 298         internal static bool IsFacetValueConstant(TypeUsage type, string facetName)
 299         {
 300             // Binary and String FixedLength facets share the same name
 301             return Helper.GetFacet(((PrimitiveType)type.EdmType).FacetDescriptions, facetName).IsConstant;
 302         }
 303
 304         internal static bool TryGetMaxLength(TypeUsage type, out int maxLength)
 305         {
 306             if (!TypeSemantics.IsPrimitiveType(type, PrimitiveTypeKind.String) &&
 307                 !TypeSemantics.IsPrimitiveType(type, PrimitiveTypeKind.Binary))
 308             {
 309                 maxLength = 0;
 310                 return false;
 311             }
 312
 313             // Binary and String FixedLength facets share the same name
 314             return TypeHelpers.TryGetIntFacetValue(type, DbProviderManifest.MaxLengthFacetName, out maxLength);
 315         }
 316
 317         internal static bool TryGetPrecision(TypeUsage type, out byte precision)
 318         {
 319             if (!TypeSemantics.IsPrimitiveType(type, PrimitiveTypeKind.Decimal))
 320             {
 321                 precision = 0;
 322                 return false;
 323             }
 324
 325             return TypeHelpers.TryGetByteFacetValue(type, DbProviderManifest.PrecisionFacetName, out precision);
 326         }
 327
 328         internal static bool TryGetScale(TypeUsage type, out byte scale)
 329         {
 330             if (!TypeSemantics.IsPrimitiveType(type, PrimitiveTypeKind.Decimal))
 331             {
 332                 scale = 0;
 333                 return false;
 334             }
 335
 336             return TypeHelpers.TryGetByteFacetValue(type, DbProviderManifest.ScaleFacetName, out scale);
 337         }
 338
 339         internal static bool TryGetPrimitiveTypeKind(TypeUsage type, out PrimitiveTypeKind typeKind)
 340         {
 341             if (type != null && type.EdmType != null && type.EdmType.BuiltInTypeKind == BuiltInTypeKind.PrimitiveType)
 342             {
 343                 typeKind = ((PrimitiveType)type.EdmType).PrimitiveTypeKind;
 344                 return true;
 345             }
 346
 347             typeKind = default(PrimitiveTypeKind);
 348             return false;
 349         }
 350
 351         #endregion
 352
 353         //
 354         // Type Constructors
 355         //
 356         #region Type Constructors
 357         internal static CollectionType CreateCollectionType(TypeUsage elementType)
 358         {
 359             return new CollectionType(elementType);
 360         }
 361
 362         internal static TypeUsage CreateCollectionTypeUsage(TypeUsage elementType)
 363         {
 364             return CreateCollectionTypeUsage(elementType, false /* readOnly */ );
 365         }
 366
 367         internal static TypeUsage CreateCollectionTypeUsage(TypeUsage elementType, bool readOnly)
 368         {
 369             return TypeUsage.Create(new CollectionType(elementType));
 370         }
 371
 372         internal static RowType CreateRowType(IEnumerable<KeyValuePair<string, TypeUsage>> columns)
 373         {
 374             return CreateRowType(columns, null);
 375         }
 376
 377         internal static RowType CreateRowType(IEnumerable<KeyValuePair<string, TypeUsage>> columns, InitializerMetadata initializerMetadata)
 378         {
 379             List<EdmProperty> rowElements = new List<EdmProperty>();
 380             foreach (KeyValuePair<string, TypeUsage> kvp in columns)
 381             {
 382                 rowElements.Add(new EdmProperty(kvp.Key, kvp.Value));
 383             }
 384             return new RowType(rowElements, initializerMetadata);
 385         }
 386
 387         internal static TypeUsage CreateRowTypeUsage(IEnumerable<KeyValuePair<string, TypeUsage>> columns, bool readOnly)
 388         {
 389             return TypeUsage.Create(CreateRowType(columns));
 390         }
 391
 392         internal static RefType CreateReferenceType(EntityTypeBase entityType)
 393         {
 394             return new RefType((EntityType)entityType);
 395         }
 396
 397         internal static TypeUsage CreateReferenceTypeUsage(EntityType entityType)
 398         {
 399             return TypeUsage.Create(CreateReferenceType(entityType));
 400         }
 401
 402         /// <summary>
 403         /// Creates metadata for a new row type with column names and types based on the key members of the specified Entity type
 404         /// </summary>
 405         /// <param name="entityType">The Entity type that provides the Key members on which the column names and types of the new row type will be based</param>
 406         /// <returns>A new RowType info with column names and types corresponding to the Key members of the specified Entity type</returns>
 407         internal static RowType CreateKeyRowType(EntityTypeBase entityType)
 408         {
 409             IEnumerable<EdmMember> entityKeys = entityType.KeyMembers;
 410             if (null == entityKeys)
 411             {
 412                 throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Metadata_EntityTypeNullKeyMembersInvalid, "entityType");
 413             }
 414
 415             List<KeyValuePair<string, TypeUsage>> resultCols = new List<KeyValuePair<string, TypeUsage>>();
 416             //int idx = 0;
 417             foreach (EdmProperty keyProperty in entityKeys)
 418             {
 419                 //this.CheckMember(keyProperty, "property", CommandTreeUtils.FormatIndex("entityType.KeyMembers", idx++));
 420                 resultCols.Add(new KeyValuePair<string, TypeUsage>(keyProperty.Name, Helper.GetModelTypeUsage(keyProperty)));
 421             }
 422
 423             if (resultCols.Count < 1)
 424             {
 425                 throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Metadata_EntityTypeEmptyKeyMembersInvalid, "entityType");
 426             }
 427
 428             return TypeHelpers.CreateRowType(resultCols);
 429         }
 430
 431         /// <summary>
 432         /// Gets primitive type usage for <paramref name="scalarType"/>.
 433         /// </summary>
 434         /// <param name="scalarType">Primitive or enum type usage.</param>
 435         /// <returns>
 436         /// Primitive type usage for <paramref name="scalarType"/>.
 437         /// </returns>
 438         /// <remarks>
 439         /// For enum types a new type usage based on the underlying type will be created. For primitive types
 440         /// the value passed to the function will be returned.
 441         /// </remarks>
 442         internal static TypeUsage GetPrimitiveTypeUsageForScalar(TypeUsage scalarType)
 443         {
 444             Debug.Assert(scalarType != null, "scalarType != null");
 445             Debug.Assert(TypeSemantics.IsScalarType(scalarType), "Primitive or enum type expected.");
 446
 447             return TypeSemantics.IsEnumerationType(scalarType) ?
 448                 CreateEnumUnderlyingTypeUsage(scalarType) :
 449                 scalarType;
 450         }
 451
 452         /// <summary>
 453         /// Factory method for creating a type usage for underlying type of enum type usage.
 454         /// </summary>
 455         /// <param name="enumTypeUsage">Enum type usage used to create an underlying type usage of.</param>
 456         /// <returns>Type usage for the underlying enum type.</returns>
 457         internal static TypeUsage CreateEnumUnderlyingTypeUsage(TypeUsage enumTypeUsage)
 458         {
 459             Debug.Assert(enumTypeUsage != null, "enumTypeUsage != null");
 460             Debug.Assert(TypeSemantics.IsEnumerationType(enumTypeUsage), "enumTypeUsage is not an enumerated type");
 461
 462             return TypeUsage.Create(Helper.GetUnderlyingEdmTypeForEnumType(enumTypeUsage.EdmType), enumTypeUsage.Facets);
 463         }
 464
 465         /// <summary>
 466         /// Factory method for creating a type usage for underlying union type of spatial type usage.
 467         /// </summary>
 468         /// <param name="spatialTypeUsage">Spatial type usage used to create a union type usage of.</param>
 469         /// <returns>Type usage for the spatial union type of the correct topology.</returns>
 470         internal static TypeUsage CreateSpatialUnionTypeUsage(TypeUsage spatialTypeUsage)
 471         {
 472             Debug.Assert(spatialTypeUsage != null, "spatialTypeUsage != null");
 473             Debug.Assert(TypeSemantics.IsStrongSpatialType(spatialTypeUsage), "spatialTypeUsage is not a strong spatial type");
 474             return TypeUsage.Create(Helper.GetSpatialNormalizedPrimitiveType(spatialTypeUsage.EdmType), spatialTypeUsage.Facets);
 475         }
 476
 477         #endregion
 478
 479         //
 480         // Type extractors
 481         //
 482         #region Type Extractors
 483
 484         /// <summary>
 485         /// Retrieves Properties and/or RelationshipEnds declared by the specified type or any base type.
 486         /// </summary>
 487         /// <param name="type"></param>
 488         /// <returns></returns>
 489         internal static IBaseList<EdmMember> GetAllStructuralMembers(TypeUsage type)
 490         {
 491             return GetAllStructuralMembers(type.EdmType);
 492         }
 493
 494         internal static IBaseList<EdmMember> GetAllStructuralMembers(EdmType edmType)
 495         {
 496             System.Diagnostics.Debug.Assert(edmType != null);
 497             switch (edmType.BuiltInTypeKind)
 498             {
 499                 case BuiltInTypeKind.AssociationType:
 500                     return (IBaseList<EdmMember>)((AssociationType)edmType).AssociationEndMembers;
 501                 case BuiltInTypeKind.ComplexType:
 502                     return (IBaseList<EdmMember>)((ComplexType)edmType).Properties;
 503                 case BuiltInTypeKind.EntityType:
 504                     return (IBaseList<EdmMember>)((EntityType)edmType).Properties;
 505                 case BuiltInTypeKind.RowType:
 506                     return (IBaseList<EdmMember>)((RowType)edmType).Properties;
 507                 default:
 508                     return EmptyArrayEdmProperty;
 509             }
 510         }
 511
 512         /// <summary>
 513         /// Retrieves Properties and/or RelationshipEnds declared by (and ONLY by) the specified type.
 514         /// </summary>
 515         /// <param name="type"></param>
 516         /// <returns></returns>
 517         internal static IEnumerable GetDeclaredStructuralMembers(TypeUsage type)
 518         {
 519             return GetDeclaredStructuralMembers(type.EdmType);
 520         }
 521
 522         /// <summary>
 523         /// Retrieves Properties and/or RelationshipEnds declared by (and ONLY by) the specified type.
 524         /// </summary>
 525         /// <param name="edmType"></param>
 526         /// <returns></returns>
 527         internal static IEnumerable GetDeclaredStructuralMembers(EdmType edmType)
 528         {
 529             switch (edmType.BuiltInTypeKind)
 530             {
 531                 case BuiltInTypeKind.AssociationType:
 532                     return ((AssociationType)edmType).GetDeclaredOnlyMembers<AssociationEndMember>();
 533                 case BuiltInTypeKind.ComplexType:
 534                     return ((ComplexType)edmType).GetDeclaredOnlyMembers<EdmProperty>();
 535                 case BuiltInTypeKind.EntityType:
 536                     return ((EntityType)edmType).GetDeclaredOnlyMembers<EdmProperty>();
 537                 case BuiltInTypeKind.RowType:
 538                     return ((RowType)edmType).GetDeclaredOnlyMembers<EdmProperty>();
 539                 default:
 540                     return EmptyArrayEdmProperty;
 541             }
 542         }
 543
 544         internal static readonly ReadOnlyMetadataCollection<EdmMember> EmptyArrayEdmMember = new ReadOnlyMetadataCollection<EdmMember>(new MetadataCollection<EdmMember>().SetReadOnly());
 545         internal static readonly FilteredReadOnlyMetadataCollection<EdmProperty, EdmMember> EmptyArrayEdmProperty = new FilteredReadOnlyMetadataCollection<EdmProperty, EdmMember>(EmptyArrayEdmMember, null);
 546
 547         internal static ReadOnlyMetadataCollection<EdmProperty> GetProperties(TypeUsage typeUsage)
 548         {
 549             return GetProperties(typeUsage.EdmType);
 550         }
 551
 552         internal static ReadOnlyMetadataCollection<EdmProperty> GetProperties(EdmType edmType)
 553         {
 554             switch (edmType.BuiltInTypeKind)
 555             {
 556                 case BuiltInTypeKind.ComplexType:
 557                     return ((ComplexType)edmType).Properties;
 558                 case BuiltInTypeKind.EntityType:
 559                     return ((EntityType)edmType).Properties;
 560                 case BuiltInTypeKind.RowType:
 561                     return ((RowType)edmType).Properties;
 562                 default:
 563                     return EmptyArrayEdmProperty;
 564             }
 565         }
 566
 567         internal static TypeUsage GetElementTypeUsage(TypeUsage type)
 568         {
 569             if (TypeSemantics.IsCollectionType(type))
 570             {
 571                 return ((CollectionType)type.EdmType).TypeUsage;
 572             }
 573             else if (TypeSemantics.IsReferenceType(type))
 574             {
 575                 return TypeUsage.Create(((RefType)type.EdmType).ElementType);
 576             }
 577
 578             return null;
 579         }
 580
 581         /// <summary>
 582         /// Returns row type if supplied function is a tvf returning Collection(RowType), otherwise null.
 583         /// </summary>
 584         internal static RowType GetTvfReturnType(EdmFunction tvf)
 585         {
 586             if (tvf.ReturnParameter != null && TypeSemantics.IsCollectionType(tvf.ReturnParameter.TypeUsage))
 587             {
 588                 var expectedElementTypeUsage = ((CollectionType)tvf.ReturnParameter.TypeUsage.EdmType).TypeUsage;
 589                 if (TypeSemantics.IsRowType(expectedElementTypeUsage))
 590                 {
 591                     return (RowType)expectedElementTypeUsage.EdmType;
 592                 }
 593             }
 594             return null;
 595         }
 596
 597         //
 598         // Element type
 599         //
 600         internal static bool TryGetCollectionElementType(TypeUsage type, out TypeUsage elementType)
 601         {
 602             CollectionType collectionType;
 603             if (TypeHelpers.TryGetEdmType<CollectionType>(type, out collectionType))
 604             {
 605                 elementType = collectionType.TypeUsage;
 606                 return (elementType != null);
 607             }
 608
 609             elementType = null;
 610             return false;
 611         }
 612
 613         /// <summary>
 614         /// If the type refered to by the TypeUsage is a RefType, extracts the EntityType and returns true,
 615         /// otherwise returns false.
 616         /// </summary>
 617         /// <param name="type">TypeUsage that may or may not refer to a RefType</param>
 618         /// <param name="referencedEntityType">Non-null if the TypeUsage refers to a RefType, null otherwise</param>
 619         /// <returns>True if the TypeUsage refers to a RefType, false otherwise</returns>
 620         internal static bool TryGetRefEntityType(TypeUsage type, out EntityType referencedEntityType)
 621         {
 622             RefType refType;
 623             if (TryGetEdmType<RefType>(type, out refType) &&
 624                 Helper.IsEntityType(refType.ElementType))
 625             {
 626                 referencedEntityType = (EntityType)refType.ElementType;
 627                 return true;
 628             }
 629
 630             referencedEntityType = null;
 631             return false;
 632         }
 633
 634         internal static TEdmType GetEdmType<TEdmType>(TypeUsage typeUsage)
 635             where TEdmType : EdmType
 636         {
 637             return (TEdmType)typeUsage.EdmType;
 638         }
 639
 640         internal static bool TryGetEdmType<TEdmType>(TypeUsage typeUsage, out TEdmType type)
 641             where TEdmType : EdmType
 642         {
 643             type = typeUsage.EdmType as TEdmType;
 644             return (type != null);
 645         }
 646         #endregion
 647
 648         //
 649         // Misc
 650         //
 651         #region Misc
 652         internal static TypeUsage GetReadOnlyType(TypeUsage type)
 653         {
 654             if (!(type.IsReadOnly))
 655             {
 656                 type.SetReadOnly();
 657             }
 658             return type;
 659         }
 660
 661         //
 662         // Type Description
 663         //
 664
 665         internal static string GetFullName(TypeUsage type)
 666         {
 667             return type.ToString();
 668         }
 669
 670         internal static string GetFullName(EdmType type)
 671         {
 672             return GetFullName(type.NamespaceName, type.Name);
 673         }
 674
 675         internal static string GetFullName(EntitySetBase entitySet)
 676         {
 677             Debug.Assert(entitySet.EntityContainer != null, "entitySet.EntityContainer is null");
 678             return GetFullName(entitySet.EntityContainer.Name, entitySet.Name);
 679         }
 680
 681         internal static string GetFullName(string qualifier, string name)
 682         {
 683             if (string.IsNullOrEmpty(qualifier))
 684             {
 685                 return string.Format(CultureInfo.InvariantCulture, "{0}", name);
 686             }
 687             else
 688             {
 689                 return string.Format(CultureInfo.InvariantCulture, "{0}.{1}", qualifier, name);
 690             }
 691         }
 692
 693         /// <summary>
 694         /// Converts the given CLR type into a DbType
 695         /// </summary>
 696         /// <param name="clrType">The CLR type to convert</param>
 697         /// <returns></returns>
 698         internal static DbType ConvertClrTypeToDbType(Type clrType)
 699         {
 700             switch (Type.GetTypeCode(clrType))
 701             {
 702                 case TypeCode.Empty:
 703                     throw EntityUtil.InvalidDataType(TypeCode.Empty);
 704
 705                 case TypeCode.Object:
 706                     if (clrType == typeof(System.Byte[]))
 707                     {
 708                         return DbType.Binary;
 709                     }
 710                     if (clrType == typeof(System.Char[]))
 711                     {
 712                         // Always treat char and char[] as string
 713                         return DbType.String;
 714                     }
 715                     else if (clrType == typeof(System.Guid))
 716                     {
 717                         return DbType.Guid;
 718                     }
 719                     else if (clrType == typeof(System.TimeSpan))
 720                     {
 721                         return DbType.Time;
 722                     }
 723                     else if (clrType == typeof(System.DateTimeOffset))
 724                     {
 725                         return DbType.DateTimeOffset;
 726                     }
 727
 728                     return DbType.Object;
 729
 730                 case TypeCode.DBNull:
 731                     return DbType.Object;
 732                 case TypeCode.Boolean:
 733                     return DbType.Boolean;
 734                 case TypeCode.SByte:
 735                     return DbType.SByte;
 736                 case TypeCode.Byte:
 737                     return DbType.Byte;
 738                 case TypeCode.Char:
 739                     // Always treat char and char[] as string
 740                     return DbType.String;
 741                 case TypeCode.Int16:
 742                     return DbType.Int16;
 743                 case TypeCode.UInt16:
 744                     return DbType.UInt16;
 745                 case TypeCode.Int32:
 746                     return DbType.Int32;
 747                 case TypeCode.UInt32:
 748                     return DbType.UInt32;
 749                 case TypeCode.Int64:
 750                     return DbType.Int64;
 751                 case TypeCode.UInt64:
 752                     return DbType.UInt64;
 753                 case TypeCode.Single:
 754                     return DbType.Single;
 755                 case TypeCode.Double:
 756                     return DbType.Double;
 757                 case TypeCode.Decimal:
 758                     return DbType.Decimal;
 759                 case TypeCode.DateTime:
 760                     return DbType.DateTime;
 761                 case TypeCode.String:
 762                     return DbType.String;
 763                 default:
 764                     throw EntityUtil.UnknownDataTypeCode(clrType, Type.GetTypeCode(clrType));
 765             }
 766         }
 767
 768         internal static bool IsIntegerConstant(TypeUsage valueType, object value, long expectedValue)
 769         {
 770             if (!TypeSemantics.IsIntegerNumericType(valueType))
 771             {
 772                 return false;
 773             }
 774
 775             if (null == value)
 776             {
 777                 return false;
 778             }
 779
 780             PrimitiveType intType = (PrimitiveType)valueType.EdmType;
 781             switch (intType.PrimitiveTypeKind)
 782             {
 783                 case PrimitiveTypeKind.Byte:
 784                     return (expectedValue == (byte)value);
 785
 786                 case PrimitiveTypeKind.Int16:
 787                     return (expectedValue == (short)value);
 788
 789                 case PrimitiveTypeKind.Int32:
 790                     return (expectedValue == (int)value);
 791
 792                 case PrimitiveTypeKind.Int64:
 793                     return (expectedValue == (long)value);
 794
 795                 case PrimitiveTypeKind.SByte:
 796                     return (expectedValue == (sbyte)value);
 797
 798                 default:
 799                     {
 800                         Debug.Assert(false, "Integer primitive type was not one of Byte, Int16, Int32, Int64, SByte?");
 801                         return false;
 802                     }
 803             }
 804         }
 805
 806         /// <summary>
 807         /// returns a Typeusage
 808         /// </summary>
 809         /// <param name="primitiveTypeKind"></param>
 810         /// <returns></returns>
 811         static internal TypeUsage GetLiteralTypeUsage(PrimitiveTypeKind primitiveTypeKind)
 812         {
 813             // all clr strings by default are unicode
 814             return GetLiteralTypeUsage(primitiveTypeKind, true /* unicode */);
 815         }
 816
 817         static internal TypeUsage GetLiteralTypeUsage(PrimitiveTypeKind primitiveTypeKind, bool isUnicode)
 818         {
 819             TypeUsage typeusage;
 820             PrimitiveType primitiveType = EdmProviderManifest.Instance.GetPrimitiveType(primitiveTypeKind);
 821             switch (primitiveTypeKind)
 822             {
 823                 case PrimitiveTypeKind.String:
 824                     typeusage = TypeUsage.Create(primitiveType,
 825                         new FacetValues{ Unicode = isUnicode, MaxLength = TypeUsage.DefaultMaxLengthFacetValue, FixedLength = false, Nullable = false});
 826                     break;
 827
 828                 default:
 829                     typeusage = TypeUsage.Create(primitiveType,
 830                         new FacetValues{ Nullable = false });
 831                     break;
 832             }
 833             return typeusage;
 834         }
 835
 836         #endregion
 837
 838         #region EdmFunction Helpers
 839         internal static bool IsCanonicalFunction(EdmFunction function)
 840         {
 841             bool isCanonicalFunction = (function.DataSpace == DataSpace.CSpace && function.NamespaceName == EdmConstants.EdmNamespace);
 842
 843             Debug.Assert(!isCanonicalFunction || (isCanonicalFunction && !function.HasUserDefinedBody),
 844                 "Canonical function '" + function.FullName + "' can not have a user defined body");
 845
 846             return isCanonicalFunction;
 847         }
 848         #endregion
 849     }
 850 }