static void StructuralTypeVisitRecord(IExtendedDataRecord record)
{
int fieldCount = record.DataRecordInfo.FieldMetadata.Count;
for (int fieldIndex = 0; fieldIndex < fieldCount; fieldIndex++)
{
Console.Write(record.GetName(fieldIndex) + ": ");
// If the field is flagged as DbNull, the shape of the value is undetermined.
// An attempt to get such a value may trigger an exception.
if (record.IsDBNull(fieldIndex) == false)
{
BuiltInTypeKind fieldTypeKind = record.DataRecordInfo.FieldMetadata[fieldIndex].
FieldType.TypeUsage.EdmType.BuiltInTypeKind;
// The EntityType, ComplexType and RowType are structural types
// that have members.
// Read only the PrimitiveType members of this structural type.
if (fieldTypeKind == BuiltInTypeKind.PrimitiveType)
{
// Primitive types are surfaced as plain objects.
Console.WriteLine(record.GetValue(fieldIndex).ToString());
}
}
}
}
private static XmlElement GetElementForKind(XmlDocument document, BuiltInTypeKind kind)
{
Debug.Assert(document != null, "document != null");
string xpath;
switch (kind)
{
case BuiltInTypeKind.EdmProperty:
xpath = "/csdl1:Schema/csdl1:EntityType[@Name='Customers']/csdl1:Property[@Name='CompanyName']";
break;
case BuiltInTypeKind.EntityContainer:
xpath = "/csdl1:Schema/csdl1:EntityContainer";
break;
case BuiltInTypeKind.EntityType:
xpath = "/csdl1:Schema/csdl1:EntityType[@Name='Customers']";
break;
case BuiltInTypeKind.EdmFunction:
default:
throw new NotSupportedException("Built in type kind not supported: " + kind);
}
return((XmlElement)document.SelectSingleNode(xpath, TestUtil.TestNamespaceManager));
}
public static ArmType?AsArmType(this BuiltInTypeKind builtinType)
{
switch (builtinType)
{
case BuiltInTypeKind.Any:
return(null);
case BuiltInTypeKind.Array:
return(ArmType.Array);
case BuiltInTypeKind.Bool:
return(ArmType.Bool);
case BuiltInTypeKind.Int:
return(ArmType.Int);
case BuiltInTypeKind.Null:
return(ArmType.Null);
case BuiltInTypeKind.Object:
return(ArmType.Object);
case BuiltInTypeKind.ResourceRef:
return(null);
case BuiltInTypeKind.String:
return(ArmType.String);
default:
throw new ArgumentException($"Unknown ARM builtin type: '{builtinType}'");
}
}
public static string AsPowerShellTypeString(this BuiltInTypeKind builtinType)
{
switch (builtinType)
{
case BuiltInTypeKind.Object:
case BuiltInTypeKind.Null:
case BuiltInTypeKind.Any:
case BuiltInTypeKind.ResourceRef:
return("object");
case BuiltInTypeKind.Array:
return("array");
case BuiltInTypeKind.Bool:
return("bool");
case BuiltInTypeKind.Int:
return("int");
case BuiltInTypeKind.String:
return("string");
default:
throw new ArgumentException($"Unknown ARM builtin type: '{builtinType}'");
}
}
static void RefTypeVisitRecord(IExtendedDataRecord record)
{
// For RefType the record contains exactly one field.
int fieldIndex = 0;
// If the field is flagged as DbNull, the shape of the value is undetermined.
// An attempt to get such a value may trigger an exception.
if (record.IsDBNull(fieldIndex) == false)
{
BuiltInTypeKind fieldTypeKind = record.DataRecordInfo.FieldMetadata[fieldIndex].
FieldType.TypeUsage.EdmType.BuiltInTypeKind;
//read only fields that contain PrimitiveType
if (fieldTypeKind == BuiltInTypeKind.RefType)
{
// Ref types are surfaced as EntityKey instances.
// The containing record sees them as atomic.
EntityKey key = record.GetValue(fieldIndex) as EntityKey;
// Get the EntitySet name.
Console.WriteLine("EntitySetName " + key.EntitySetName);
// Get the Name and the Value information of the EntityKey.
foreach (EntityKeyMember keyMember in key.EntityKeyValues)
{
Console.WriteLine(" Key Name: " + keyMember.Key);
Console.WriteLine(" Key Value: " + keyMember.Value);
}
}
}
}
private bool TryGetTypeNameForBuiltin(BuiltInTypeKind kind, out string typeName)
{
switch (kind)
{
case BuiltInTypeKind.Array:
typeName = "array";
return(true);
case BuiltInTypeKind.Bool:
typeName = "bool";
return(true);
case BuiltInTypeKind.Int:
typeName = "int";
return(true);
case BuiltInTypeKind.String:
typeName = "string";
return(true);
default:
typeName = null;
return(false);
}
}
public IEnumerable <GlobalItem> GetSourceTypes()
{
foreach (EntityContainer container in _edmItemCollection.GetItems <EntityContainer>())
{
BuiltInTypeKind kind = container.BuiltInTypeKind;
yield return(container);
}
foreach (EdmType item in _edmItemCollection.GetItems <EdmType>())
{
switch (item.BuiltInTypeKind)
{
case BuiltInTypeKind.AssociationType:
case BuiltInTypeKind.ComplexType:
case BuiltInTypeKind.EntityType:
yield return(item);
break;
case BuiltInTypeKind.EdmFunction:
case BuiltInTypeKind.PrimitiveType:
break;
default:
Debug.Assert(false, item.BuiltInTypeKind.ToString());
break;
}
}
}
private void GenerateFieldInfos(DbSetInfo dbSetInfo, string[] keys, EdmProperty[] edmProps)
{
short pkNum = 0;
Array.ForEach(edmProps, (edmProp) =>
{
Field fieldInfo = new Field()
{
fieldName = edmProp.Name
};
if (keys.Contains(fieldInfo.fieldName))
{
++pkNum;
fieldInfo.isPrimaryKey = pkNum;
fieldInfo.isReadOnly = true;
}
bool isComputed = this.isComputed(edmProp);
fieldInfo.isAutoGenerated = isAutoGenerated(edmProp);
fieldInfo.isNullable = edmProp.Nullable;
fieldInfo.isReadOnly = fieldInfo.isAutoGenerated;
bool isArray = false;
string propType = edmProp.TypeUsage.EdmType.Name;
try
{
fieldInfo.dataType = DataTypeFromType(propType, out isArray);
ReadOnlyMetadataCollection <Facet> facets = edmProp.TypeUsage.Facets;
Facet maxLenFacet = facets.Where(f => f.Name == "MaxLength").FirstOrDefault();
if (maxLenFacet != null)
{
try
{
fieldInfo.maxLength = (short)Convert.ChangeType(maxLenFacet.Value, typeof(short));
}
catch
{
}
}
//gess that the property is rowversion
fieldInfo.fieldType = (isComputed && fieldInfo.dataType == DataType.Binary) ? FieldType.RowTimeStamp : FieldType.None;
}
catch (UnSupportedTypeException)
{
BuiltInTypeKind typeKind = edmProp.TypeUsage.EdmType.BuiltInTypeKind;
if (typeKind == BuiltInTypeKind.ComplexType)
{
fieldInfo.dataType = DataType.None;
fieldInfo.fieldType = FieldType.Object;
}
else
{
throw;
}
}
dbSetInfo.fieldInfos.Add(fieldInfo);
});
}
// <summary>
// Add properties for all the build in complex type
// </summary>
// <param name="builtInTypeKind"> The type of the built In type whose properties are being added </param>
// <param name="properties"> properties of the built in type </param>
private static void AddBuiltInTypeProperties(BuiltInTypeKind builtInTypeKind, EdmProperty[] properties)
{
var complexType = (ComplexType)GetBuiltInType(builtInTypeKind);
if (properties != null)
{
for (var i = 0; i < properties.Length; i++)
{
complexType.AddMember(properties[i]);
}
}
}
private static void InitializeEnumType(
BuiltInTypeKind builtInTypeKind,
string name,
string[] enumMemberNames)
{
EnumType builtInType = (EnumType)MetadataItem.GetBuiltInType(builtInTypeKind);
EdmType.Initialize((EdmType)builtInType, name, "Edm", DataSpace.CSpace, false, (EdmType)null);
for (int index = 0; index < enumMemberNames.Length; ++index)
{
builtInType.AddMember(new EnumMember(enumMemberNames[index], (object)index));
}
}
private static void AddBuiltInTypeProperties(
BuiltInTypeKind builtInTypeKind,
EdmProperty[] properties)
{
ComplexType builtInType = (ComplexType)MetadataItem.GetBuiltInType(builtInTypeKind);
if (properties == null)
{
return;
}
for (int index = 0; index < properties.Length; ++index)
{
builtInType.AddMember((EdmMember)properties[index]);
}
}
/// <summary>
/// Initializes the enum type
/// </summary>
/// <param name="builtInTypeKind">The built-in type kind enum value of this enum type</param>
/// <param name="name">The name of this enum type</param>
/// <param name="enumMemberNames">The member names of this enum type</param>
private static void InitializeEnumType(BuiltInTypeKind builtInTypeKind,
string name,
string[] enumMemberNames)
{
EnumType enumType = (EnumType)GetBuiltInType(builtInTypeKind);
// Initialize item attributes for all ancestor types
EdmType.Initialize(enumType,
name,
EdmConstants.EdmNamespace,
DataSpace.CSpace,
false,
null);
for (int i = 0; i < enumMemberNames.Length; i++)
{
enumType.AddMember(new EnumMember(enumMemberNames[i], i));
}
}
/// <summary>
/// Add properties for all the build in complex type
/// </summary>
/// <param name="builtInTypeKind">The type of the built In type whose properties are being added</param>
/// <param name="properties">properties of the built in type</param>
private static void AddBuiltInTypeProperties(BuiltInTypeKind builtInTypeKind, EdmProperty[] properties)
{
ComplexType complexType = (ComplexType)GetBuiltInType(builtInTypeKind);
if (properties != null)
{
for (int i = 0; i < properties.Length; i++)
{
complexType.AddMember(properties[i]);
}
}
}
/// <summary>
/// Returns the list of EDM builtin types
/// </summary>
public static EdmType GetBuiltInType(BuiltInTypeKind builtInTypeKind)
{
return _builtInTypes[(int)builtInTypeKind];
}
private void VerifyMember(IProviderMember actualMember, bool expectedIsKey, string expectedEdmTypeName, BuiltInTypeKind expectedEdmTypeKind, string expectedMimeType, EntityType expectedCollectionType)
{
string memberName = actualMember.Name;
Assert.AreEqual(expectedEdmTypeKind, actualMember.EdmTypeKind, "IProviderMember.EdmTypeKind is not the expected value for the member {0}.", memberName);
Assert.AreEqual(expectedIsKey, actualMember.IsKey, "IProviderMember.IsKey is not the expected value for the member {0}.", memberName);
Assert.AreEqual(expectedEdmTypeName, actualMember.EdmTypeName, "IProviderMember.EdmTypeName is not the expected value for the member {0}.", memberName);
Assert.AreEqual(expectedMimeType, actualMember.MimeType, "IProviderMember.MimeType is not the expected value for the member {0}.", memberName);
Assert.AreEqual(expectedCollectionType, actualMember.CollectionItemType, "IProviderMember.ExpectedCollectionType is not the expected value for the member {0}.", memberName);
}
public void WebDataServiceCsdlMimeTypes()
{
object[] targets = new object[]
{
// BuiltInTypeKind.EdmFunction,
// BuiltInTypeKind.ComplexType,
// BuiltInTypeKind.EntityContainer,
// BuiltInTypeKind.EntityType,
BuiltInTypeKind.EdmProperty,
};
// Ensure the NorthwindModel service is ready to be used.
Trace.WriteLine("NorthwindModel IsValid: " + ServiceModelData.Northwind.IsValid);
CombinatorialEngine engine = CombinatorialEngine.FromDimensions(
new Dimension("Target", targets),
new Dimension("MimeType", new object[] { "", "text/html" }));
int schemaCounter = 0;
TestUtil.RunCombinatorialEngineFail(engine, delegate(Hashtable values)
{
BuiltInTypeKind target = (BuiltInTypeKind)values["Target"];
string mimeType = (string)values["MimeType"];
// Create a copy of Northwind model files.
schemaCounter++;
const bool overwriteTrue = true;
string sourceFileName = Path.Combine(TestUtil.NorthwindMetadataDirectory, "Northwind.csdl");
string destFileName = sourceFileName + schemaCounter + ".csdl";
File.Copy(sourceFileName, destFileName, overwriteTrue);
File.SetAttributes(destFileName, FileAttributes.Normal);
// Add an attribute at specific values.
string csdlFileName = destFileName;
XmlDocument document = new XmlDocument();
document.Load(csdlFileName);
XmlElement element = GetElementForKind(document, target);
element.SetAttribute("MimeType", "http://docs.oasis-open.org/odata/ns/metadata", mimeType);
document.Save(csdlFileName);
using (TestWebRequest request = TestWebRequest.CreateForInProcess())
{
// Get the generated CSDL.
string connectionString = NorthwindModel.NorthwindContext.ContextConnectionString;
try
{
string northwindConnectionString = connectionString;
northwindConnectionString = northwindConnectionString
.Replace("Northwind.csdl", "Northwind.csdl" + schemaCounter + ".csdl");
NorthwindModel.NorthwindContext.ContextConnectionString = northwindConnectionString;
request.DataServiceType = typeof(NorthwindModel.NorthwindContext);
request.RequestUriString = "/$metadata";
Exception exception = TestUtil.RunCatching(request.SendRequest);
TestUtil.AssertExceptionExpected(exception,
target != BuiltInTypeKind.EdmProperty,
mimeType == "");
if (exception != null)
{
return;
}
XmlDocument metadataResult = new XmlDocument(TestUtil.TestNameTable);
metadataResult.Load(request.GetResponseStream());
Trace.WriteLine(metadataResult.OuterXml);
// Get a value using a primitive serializer.
request.RequestUriString = "/Customers?$format=atom&$top=1";
request.SendRequest();
XmlDocument customerDocument = SerializationFormatData.Atom.LoadXmlDocumentFromStream(request.GetResponseStream());
XmlElement customerId = TestUtil.AssertSelectSingleElement(customerDocument, "/atom:feed/atom:entry/atom:id");
request.FullRequestUriString = customerId.InnerText + "/CompanyName/$value";
request.SendRequest();
Assert.AreEqual(mimeType, TestUtil.GetMediaType(request.ResponseContentType));
}
finally
{
NorthwindModel.NorthwindContext.ContextConnectionString = connectionString;
}
}
});
}
private void VerifyMember(IProviderMember actualMember, bool expectedIsKey, string expectedEdmTypeName, BuiltInTypeKind expectedEdmTypeKind, string expectedMimeType, EntityType expectedCollectionType)
{
string memberName = actualMember.Name;
Assert.AreEqual(expectedEdmTypeKind, actualMember.EdmTypeKind, "IProviderMember.EdmTypeKind is not the expected value for the member {0}.", memberName);
Assert.AreEqual(expectedIsKey, actualMember.IsKey, "IProviderMember.IsKey is not the expected value for the member {0}.", memberName);
Assert.AreEqual(expectedEdmTypeName, actualMember.EdmTypeName, "IProviderMember.EdmTypeName is not the expected value for the member {0}.", memberName);
Assert.AreEqual(expectedMimeType, actualMember.MimeType, "IProviderMember.MimeType is not the expected value for the member {0}.", memberName);
Assert.AreEqual(expectedCollectionType, actualMember.CollectionItemType, "IProviderMember.ExpectedCollectionType is not the expected value for the member {0}.", memberName);
}
static internal InvalidOperationException NonSerializableType(BuiltInTypeKind kind)
{
return(InvalidOperation(Strings.Serialization_UnknownGlobalItem(kind)));
}
/// <summary>
/// Returns a conceptual model built-in type that matches one of the
/// <see
/// cref="T:System.Data.Entity.Core.Metadata.Edm.BuiltInTypeKind" />
/// values.
/// </summary>
/// <returns>
/// An <see cref="T:System.Data.Entity.Core.Metadata.Edm.EdmType" /> object that represents the built-in type in the EDM.
/// </returns>
/// <param name="builtInTypeKind">
/// One of the <see cref="T:System.Data.Entity.Core.Metadata.Edm.BuiltInTypeKind" /> values.
/// </param>
public static EdmType GetBuiltInType(BuiltInTypeKind builtInTypeKind)
{
return(_builtInTypes[(int)builtInTypeKind]);
}
public BuiltInType(BuiltInTypeKind kind)
{
Kind = kind;
}
/// <summary>
/// Initializes the enum type
/// </summary>
/// <param name="builtInTypeKind">The built-in type kind enum value of this enum type</param>
/// <param name="name">The name of this enum type</param>
/// <param name="enumMemberNames">The member names of this enum type</param>
private static void InitializeEnumType(BuiltInTypeKind builtInTypeKind,
string name,
string[] enumMemberNames)
{
EnumType enumType = (EnumType)GetBuiltInType(builtInTypeKind);
// Initialize item attributes for all ancestor types
EdmType.Initialize(enumType,
name,
EdmConstants.EdmNamespace,
DataSpace.CSpace,
false,
null);
for (int i = 0; i < enumMemberNames.Length; i++)
{
enumType.AddMember(new EnumMember(enumMemberNames[i], i));
}
}
/// <summary>
/// Initializes a new attribute with built in type kind
/// </summary>
/// <param name="builtInTypeKind">Built in type setting Type property</param>
/// <param name="isCollectionType">Sets IsCollectionType property</param>
internal MetadataPropertyAttribute(BuiltInTypeKind builtInTypeKind, bool isCollectionType)
: this(MetadataItem.GetBuiltInType(builtInTypeKind), isCollectionType)
{
}
// <summary>
// Initializes a new attribute with built in type kind
// </summary>
// <param name="builtInTypeKind"> Built in type setting Type property </param>
// <param name="isCollectionType"> Sets IsCollectionType property </param>
internal MetadataPropertyAttribute(BuiltInTypeKind builtInTypeKind, bool isCollectionType)
: this(MetadataItem.GetBuiltInType(builtInTypeKind), isCollectionType)
{
}
static internal InvalidOperationException MissingGenerationPatternForType(BuiltInTypeKind kind)
{
return(InvalidOperation(Strings.ModelGeneration_UnGeneratableType(kind)));
}
/// <summary>
/// Returns a conceptual model built-in type that matches one of the
/// <see cref="T:System.Data.Entity.Core.Metadata.Edm.BuiltInTypeKind" />
/// values.
/// </summary>
/// <returns>
/// An <see cref="T:System.Data.Entity.Core.Metadata.Edm.EdmType" /> object that represents the built-in type in the EDM.
/// </returns>
/// <param name="builtInTypeKind">
/// One of the <see cref="T:System.Data.Entity.Core.Metadata.Edm.BuiltInTypeKind" /> values.
/// </param>
public static EdmType GetBuiltInType(BuiltInTypeKind builtInTypeKind)
{
return(MetadataItem._builtInTypes[(int)builtInTypeKind]);
}
