Code:
/ Dotnetfx_Vista_SP2 / Dotnetfx_Vista_SP2 / 8.0.50727.4016 / DEVDIV / depot / DevDiv / releases / Orcas / QFE / ndp / fx / src / DataEntity / System / Data / Common / CommandTrees / Internal / CommandTreeTypeHelper.cs / 2 / CommandTreeTypeHelper.cs
//----------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//
// @owner [....], [....]
//---------------------------------------------------------------------
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Data.Metadata.Edm;
using System.Data.Common.CommandTrees;
using System.Data.Common; // for TypeHelpers
namespace System.Data.Common.CommandTrees.Internal
{
internal class CommandTreeTypeHelper
{
private DbCommandTree _owner;
private TypeUsage _boolType;
///
/// Constructs a new CommandTreeTypeHelper that is associated with the specified DbCommandTree
///
/// The DbCommandTree that specifies the metadata collection and dataspace against which this TypeHelper should operate
internal CommandTreeTypeHelper(DbCommandTree owner)
{
_owner = owner;
}
internal static void CheckReadOnly(GlobalItem item, string varName)
{
EntityUtil.CheckArgumentNull(item, varName);
if (!(item.IsReadOnly))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_General_MetadataNotReadOnly, varName);
}
}
internal static void CheckReadOnly(TypeUsage item, string varName)
{
EntityUtil.CheckArgumentNull(item, varName);
if (!(item.IsReadOnly))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_General_MetadataNotReadOnly, varName);
}
}
internal static void CheckReadOnly(EntitySetBase item, string varName)
{
EntityUtil.CheckArgumentNull(item, varName);
if (!(item.IsReadOnly))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_General_MetadataNotReadOnly, varName);
}
}
internal static void CheckType(EdmType type)
{
EntityUtil.CheckArgumentNull(type, "type");
CheckReadOnly(type, "type");
}
///
/// Ensures that the specified type is non-null, associated with the correct metadata workspace/dataspace, and is not NullType.
///
/// The type usage instance to verify.
/// If the specified type metadata is null
/// If the specified type metadata belongs to a metadata workspace other than the workspace of the command tree
/// If the specified type metadata belongs to a dataspace other than the dataspace of the command tree
internal void CheckType(TypeUsage type)
{
CheckType(type, "type");
}
internal void CheckType(TypeUsage type, string varName)
{
EntityUtil.CheckArgumentNull(type, varName);
CheckReadOnly(type, varName);
if (TypeSemantics.IsNullType(type))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_General_NullTypeInvalid, varName);
}
if (null == type.EdmType)
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_General_TypeUsageNullEdmTypeInvalid, "type");
}
if (!CheckWorkspaceAndDataSpace(type))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Metadata_TypeUsageIncorrectSpace, "type");
}
}
///
/// Ensures that the specified type is non-null, associated with the correct metadata workspace/dataspace,
/// is not NullType, and is polymorphic.
///
/// The type usage instance to verify.
/// If the specified type metadata is null
/// If the specified type metadata belongs to a metadata workspace other than the workspace of the command tree
/// If the specified type metadata belongs to a dataspace other than the dataspace of the command tree
/// If the specified type metadata does not represent a polymorphic type
internal void CheckPolymorphicType(TypeUsage type)
{
this.CheckType(type);
if (!TypeSemantics.IsPolymorphicType(type))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_General_PolymorphicTypeRequired(TypeHelpers.GetFullName(type)), "type");
}
}
///
/// Verifies that the specified member is valid - non-null, from the same metadata workspace and data space as the command tree, etc
///
/// The member to verify
/// The name of the variable to which this member instance is being assigned
internal void CheckMember(EdmMember memberMeta, string varName)
{
EntityUtil.CheckArgumentNull(memberMeta, varName);
CheckReadOnly(memberMeta.DeclaringType, varName);
if (null == memberMeta.Name)
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Metadata_EdmMemberNameNull, varName);
}
if (TypeSemantics.IsNullOrNullType(memberMeta.TypeUsage))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Metadata_EdmMemberTypeNull, varName);
}
if (TypeSemantics.IsNullOrNullType(memberMeta.DeclaringType))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Metadata_EdmMemberDeclaringTypeNull, varName);
}
if(!CheckWorkspaceAndDataSpace(memberMeta.TypeUsage) || !CheckWorkspaceAndDataSpace(memberMeta.DeclaringType))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Metadata_EdmMemberIncorrectSpace, varName);
}
}
internal void CheckParameter(FunctionParameter paramMeta, string varName)
{
EntityUtil.CheckArgumentNull(paramMeta, varName);
CheckReadOnly(paramMeta.DeclaringFunction, varName);
if (null == paramMeta.Name)
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Metadata_FunctionParameterNameNull, varName);
}
if (TypeSemantics.IsNullOrNullType(paramMeta.TypeUsage))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Metadata_FunctionParameterTypeNull, varName);
}
// Verify that the parameter is from the same workspace as the DbCommandTree
if (!CheckWorkspaceAndDataSpace(paramMeta.TypeUsage))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Metadata_FunctionParameterIncorrectSpace, varName);
}
}
///
/// Verifies that the specified function metadata is valid - non-null and either created by this command tree (if a LambdaFunction) or from the same metadata collection and data space as the command tree (for ordinary function metadata)
///
/// The function metadata to verify
internal void CheckFunction(EdmFunction function)
{
EntityUtil.CheckArgumentNull(function, "function");
CheckReadOnly(function, "function");
if (null == function.Name)
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Metadata_FunctionNameNull, "function");
}
if (!CheckWorkspaceAndDataSpace(function))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Metadata_FunctionIncorrectSpace, "function");
}
// Composable functions must have a return parameter.
if (function.IsComposableAttribute && null == function.ReturnParameter)
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Metadata_FunctionReturnParameterNull, "function");
}
// Verify that the function ReturnType - if present - is from the DbCommandTree's metadata collection and dataspace
// A return parameter is not required for non-composable functions.
if (function.ReturnParameter != null)
{
if (TypeSemantics.IsNullOrNullType(function.ReturnParameter.TypeUsage))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Metadata_FunctionParameterTypeNull, "function.ReturnParameter");
}
if (!CheckWorkspaceAndDataSpace(function.ReturnParameter.TypeUsage))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Metadata_FunctionParameterIncorrectSpace, "function.ReturnParameter");
}
}
// Verify that the function parameters collection is non-null and,
// if non-empty, contains valid IParameterMetadata instances.
IList functionParams = function.Parameters;
if (null == functionParams)
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Metadata_FunctionParametersNull, "function");
}
for (int idx = 0; idx < functionParams.Count; idx++)
{
this.CheckParameter(functionParams[idx], CommandTreeUtils.FormatIndex("function.Parameters", idx));
}
}
///
/// Verifies that the specified EntitySet is valid with respect to the command tree
///
/// The EntitySet to verify
/// The variable name to use if an exception should be thrown
internal void CheckEntitySet(EntitySetBase entitySet, string varName)
{
EntityUtil.CheckArgumentNull(entitySet, varName);
CheckReadOnly(entitySet, varName);
if (null == entitySet.Name)
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Metadata_EntitySetNameNull, varName);
}
//
// Verify the Extent's Container
//
if (null == entitySet.EntityContainer)
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Metadata_EntitySetEntityContainerNull, varName);
}
if(!CheckWorkspaceAndDataSpace(entitySet.EntityContainer))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Metadata_EntitySetIncorrectSpace, varName);
}
//
// Verify the Extent's Entity Type
//
if (null == entitySet.ElementType)
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Metadata_EntitySetElementTypeNull, varName);
}
if(!CheckWorkspaceAndDataSpace(entitySet.ElementType))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Metadata_EntitySetIncorrectSpace, varName);
}
}
private bool CheckWorkspaceAndDataSpace(TypeUsage type)
{
return CheckWorkspaceAndDataSpace(type.EdmType);
}
private bool CheckWorkspaceAndDataSpace(GlobalItem item)
{
// Since the set of primitive types and canonical functions are shared, we don't need to check for them.
// Additionally, any non-canonical function in the C-Space must be a cached store function, which will
// also not be present in the workspace.
if (BuiltInTypeKind.PrimitiveType == item.BuiltInTypeKind ||
(BuiltInTypeKind.EdmFunction == item.BuiltInTypeKind && DataSpace.CSpace == item.DataSpace))
{
return true;
}
GlobalItem newGlobalItem = null;
if((item.DataSpace == DataSpace.SSpace || item.DataSpace == DataSpace.CSpace) &&
_owner.MetadataWorkspace.TryGetItem(item.Identity, item.DataSpace, out newGlobalItem) &&
object.ReferenceEquals(item, newGlobalItem))
{
return true;
}
if (Helper.IsRowType(item))
{
foreach (EdmProperty prop in ((RowType)item).Properties)
{
if (!CheckWorkspaceAndDataSpace(prop.TypeUsage))
{
return false;
}
}
return true;
}
if (Helper.IsCollectionType(item))
{
return CheckWorkspaceAndDataSpace(((CollectionType)item).TypeUsage);
}
if (Helper.IsRefType(item))
{
return CheckWorkspaceAndDataSpace(((RefType)item).ElementType);
}
return false;
}
///
/// Verifies that the specified EntitySet is valid with respect to the command tree
///
/// The EntitySet to verify
internal void CheckEntitySet(EntitySetBase entitySet)
{
CheckEntitySet(entitySet, "entitySet");
}
internal static TypeUsage CreateCollectionOfRowResultType(List> columns)
{
TypeUsage retUsage = TypeUsage.Create(
TypeHelpers.CreateCollectionType(
TypeUsage.Create(
TypeHelpers.CreateRowType(columns)
)
)
);
return retUsage;
}
internal static TypeUsage CreateCollectionResultType(EdmType type)
{
TypeUsage retUsage = TypeUsage.Create(
TypeHelpers.CreateCollectionType(
TypeUsage.Create(type)
)
);
return retUsage;
}
internal static TypeUsage CreateCollectionResultType(TypeUsage type)
{
TypeUsage retUsage = TypeUsage.Create(TypeHelpers.CreateCollectionType(type));
return retUsage;
}
internal TypeUsage CreateBooleanResultType()
{
if (null == _boolType)
{
_boolType = _owner.MetadataWorkspace.GetCanonicalModelTypeUsage(PrimitiveTypeKind.Boolean);
}
return _boolType;
}
internal static TypeUsage CreateResultType(EdmType resultType)
{
return TypeUsage.Create(resultType);
}
internal static TypeUsage CreateReferenceResultType(EntityTypeBase referencedEntityType)
{
return TypeUsage.Create(TypeHelpers.CreateReferenceType(referencedEntityType));
}
///
/// Requires: non-null expression
/// Determines whether the expression is a constant negative integer value. Always returns
/// false for non-constant, non-integer expression instances.
///
internal static bool IsConstantNegativeInteger(DbExpression expression)
{
return (expression.ExpressionKind == DbExpressionKind.Constant &&
TypeSemantics.IsIntegerNumericType(expression.ResultType) &&
Convert.ToInt64(((DbConstantExpression)expression).Value, CultureInfo.InvariantCulture) < 0);
}
internal static TypeUsage SetResultAsNullable(TypeUsage typeUsage)
{
TypeUsage newTypeUsage = typeUsage;
if (!TypeSemantics.IsNullable(typeUsage))
{
newTypeUsage = newTypeUsage.ShallowCopy(new FacetValues { Nullable = true });
}
return newTypeUsage;
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//----------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//
// @owner [....], [....]
//---------------------------------------------------------------------
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Data.Metadata.Edm;
using System.Data.Common.CommandTrees;
using System.Data.Common; // for TypeHelpers
namespace System.Data.Common.CommandTrees.Internal
{
internal class CommandTreeTypeHelper
{
private DbCommandTree _owner;
private TypeUsage _boolType;
///
/// Constructs a new CommandTreeTypeHelper that is associated with the specified DbCommandTree
///
/// The DbCommandTree that specifies the metadata collection and dataspace against which this TypeHelper should operate
internal CommandTreeTypeHelper(DbCommandTree owner)
{
_owner = owner;
}
internal static void CheckReadOnly(GlobalItem item, string varName)
{
EntityUtil.CheckArgumentNull(item, varName);
if (!(item.IsReadOnly))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_General_MetadataNotReadOnly, varName);
}
}
internal static void CheckReadOnly(TypeUsage item, string varName)
{
EntityUtil.CheckArgumentNull(item, varName);
if (!(item.IsReadOnly))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_General_MetadataNotReadOnly, varName);
}
}
internal static void CheckReadOnly(EntitySetBase item, string varName)
{
EntityUtil.CheckArgumentNull(item, varName);
if (!(item.IsReadOnly))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_General_MetadataNotReadOnly, varName);
}
}
internal static void CheckType(EdmType type)
{
EntityUtil.CheckArgumentNull(type, "type");
CheckReadOnly(type, "type");
}
///
/// Ensures that the specified type is non-null, associated with the correct metadata workspace/dataspace, and is not NullType.
///
/// The type usage instance to verify.
/// If the specified type metadata is null
/// If the specified type metadata belongs to a metadata workspace other than the workspace of the command tree
/// If the specified type metadata belongs to a dataspace other than the dataspace of the command tree
internal void CheckType(TypeUsage type)
{
CheckType(type, "type");
}
internal void CheckType(TypeUsage type, string varName)
{
EntityUtil.CheckArgumentNull(type, varName);
CheckReadOnly(type, varName);
if (TypeSemantics.IsNullType(type))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_General_NullTypeInvalid, varName);
}
if (null == type.EdmType)
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_General_TypeUsageNullEdmTypeInvalid, "type");
}
if (!CheckWorkspaceAndDataSpace(type))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Metadata_TypeUsageIncorrectSpace, "type");
}
}
///
/// Ensures that the specified type is non-null, associated with the correct metadata workspace/dataspace,
/// is not NullType, and is polymorphic.
///
/// The type usage instance to verify.
/// If the specified type metadata is null
/// If the specified type metadata belongs to a metadata workspace other than the workspace of the command tree
/// If the specified type metadata belongs to a dataspace other than the dataspace of the command tree
/// If the specified type metadata does not represent a polymorphic type
internal void CheckPolymorphicType(TypeUsage type)
{
this.CheckType(type);
if (!TypeSemantics.IsPolymorphicType(type))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_General_PolymorphicTypeRequired(TypeHelpers.GetFullName(type)), "type");
}
}
///
/// Verifies that the specified member is valid - non-null, from the same metadata workspace and data space as the command tree, etc
///
/// The member to verify
/// The name of the variable to which this member instance is being assigned
internal void CheckMember(EdmMember memberMeta, string varName)
{
EntityUtil.CheckArgumentNull(memberMeta, varName);
CheckReadOnly(memberMeta.DeclaringType, varName);
if (null == memberMeta.Name)
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Metadata_EdmMemberNameNull, varName);
}
if (TypeSemantics.IsNullOrNullType(memberMeta.TypeUsage))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Metadata_EdmMemberTypeNull, varName);
}
if (TypeSemantics.IsNullOrNullType(memberMeta.DeclaringType))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Metadata_EdmMemberDeclaringTypeNull, varName);
}
if(!CheckWorkspaceAndDataSpace(memberMeta.TypeUsage) || !CheckWorkspaceAndDataSpace(memberMeta.DeclaringType))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Metadata_EdmMemberIncorrectSpace, varName);
}
}
internal void CheckParameter(FunctionParameter paramMeta, string varName)
{
EntityUtil.CheckArgumentNull(paramMeta, varName);
CheckReadOnly(paramMeta.DeclaringFunction, varName);
if (null == paramMeta.Name)
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Metadata_FunctionParameterNameNull, varName);
}
if (TypeSemantics.IsNullOrNullType(paramMeta.TypeUsage))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Metadata_FunctionParameterTypeNull, varName);
}
// Verify that the parameter is from the same workspace as the DbCommandTree
if (!CheckWorkspaceAndDataSpace(paramMeta.TypeUsage))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Metadata_FunctionParameterIncorrectSpace, varName);
}
}
///
/// Verifies that the specified function metadata is valid - non-null and either created by this command tree (if a LambdaFunction) or from the same metadata collection and data space as the command tree (for ordinary function metadata)
///
/// The function metadata to verify
internal void CheckFunction(EdmFunction function)
{
EntityUtil.CheckArgumentNull(function, "function");
CheckReadOnly(function, "function");
if (null == function.Name)
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Metadata_FunctionNameNull, "function");
}
if (!CheckWorkspaceAndDataSpace(function))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Metadata_FunctionIncorrectSpace, "function");
}
// Composable functions must have a return parameter.
if (function.IsComposableAttribute && null == function.ReturnParameter)
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Metadata_FunctionReturnParameterNull, "function");
}
// Verify that the function ReturnType - if present - is from the DbCommandTree's metadata collection and dataspace
// A return parameter is not required for non-composable functions.
if (function.ReturnParameter != null)
{
if (TypeSemantics.IsNullOrNullType(function.ReturnParameter.TypeUsage))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Metadata_FunctionParameterTypeNull, "function.ReturnParameter");
}
if (!CheckWorkspaceAndDataSpace(function.ReturnParameter.TypeUsage))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Metadata_FunctionParameterIncorrectSpace, "function.ReturnParameter");
}
}
// Verify that the function parameters collection is non-null and,
// if non-empty, contains valid IParameterMetadata instances.
IList functionParams = function.Parameters;
if (null == functionParams)
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Metadata_FunctionParametersNull, "function");
}
for (int idx = 0; idx < functionParams.Count; idx++)
{
this.CheckParameter(functionParams[idx], CommandTreeUtils.FormatIndex("function.Parameters", idx));
}
}
///
/// Verifies that the specified EntitySet is valid with respect to the command tree
///
/// The EntitySet to verify
/// The variable name to use if an exception should be thrown
internal void CheckEntitySet(EntitySetBase entitySet, string varName)
{
EntityUtil.CheckArgumentNull(entitySet, varName);
CheckReadOnly(entitySet, varName);
if (null == entitySet.Name)
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Metadata_EntitySetNameNull, varName);
}
//
// Verify the Extent's Container
//
if (null == entitySet.EntityContainer)
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Metadata_EntitySetEntityContainerNull, varName);
}
if(!CheckWorkspaceAndDataSpace(entitySet.EntityContainer))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Metadata_EntitySetIncorrectSpace, varName);
}
//
// Verify the Extent's Entity Type
//
if (null == entitySet.ElementType)
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Metadata_EntitySetElementTypeNull, varName);
}
if(!CheckWorkspaceAndDataSpace(entitySet.ElementType))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Metadata_EntitySetIncorrectSpace, varName);
}
}
private bool CheckWorkspaceAndDataSpace(TypeUsage type)
{
return CheckWorkspaceAndDataSpace(type.EdmType);
}
private bool CheckWorkspaceAndDataSpace(GlobalItem item)
{
// Since the set of primitive types and canonical functions are shared, we don't need to check for them.
// Additionally, any non-canonical function in the C-Space must be a cached store function, which will
// also not be present in the workspace.
if (BuiltInTypeKind.PrimitiveType == item.BuiltInTypeKind ||
(BuiltInTypeKind.EdmFunction == item.BuiltInTypeKind && DataSpace.CSpace == item.DataSpace))
{
return true;
}
GlobalItem newGlobalItem = null;
if((item.DataSpace == DataSpace.SSpace || item.DataSpace == DataSpace.CSpace) &&
_owner.MetadataWorkspace.TryGetItem(item.Identity, item.DataSpace, out newGlobalItem) &&
object.ReferenceEquals(item, newGlobalItem))
{
return true;
}
if (Helper.IsRowType(item))
{
foreach (EdmProperty prop in ((RowType)item).Properties)
{
if (!CheckWorkspaceAndDataSpace(prop.TypeUsage))
{
return false;
}
}
return true;
}
if (Helper.IsCollectionType(item))
{
return CheckWorkspaceAndDataSpace(((CollectionType)item).TypeUsage);
}
if (Helper.IsRefType(item))
{
return CheckWorkspaceAndDataSpace(((RefType)item).ElementType);
}
return false;
}
///
/// Verifies that the specified EntitySet is valid with respect to the command tree
///
/// The EntitySet to verify
internal void CheckEntitySet(EntitySetBase entitySet)
{
CheckEntitySet(entitySet, "entitySet");
}
internal static TypeUsage CreateCollectionOfRowResultType(List> columns)
{
TypeUsage retUsage = TypeUsage.Create(
TypeHelpers.CreateCollectionType(
TypeUsage.Create(
TypeHelpers.CreateRowType(columns)
)
)
);
return retUsage;
}
internal static TypeUsage CreateCollectionResultType(EdmType type)
{
TypeUsage retUsage = TypeUsage.Create(
TypeHelpers.CreateCollectionType(
TypeUsage.Create(type)
)
);
return retUsage;
}
internal static TypeUsage CreateCollectionResultType(TypeUsage type)
{
TypeUsage retUsage = TypeUsage.Create(TypeHelpers.CreateCollectionType(type));
return retUsage;
}
internal TypeUsage CreateBooleanResultType()
{
if (null == _boolType)
{
_boolType = _owner.MetadataWorkspace.GetCanonicalModelTypeUsage(PrimitiveTypeKind.Boolean);
}
return _boolType;
}
internal static TypeUsage CreateResultType(EdmType resultType)
{
return TypeUsage.Create(resultType);
}
internal static TypeUsage CreateReferenceResultType(EntityTypeBase referencedEntityType)
{
return TypeUsage.Create(TypeHelpers.CreateReferenceType(referencedEntityType));
}
///
/// Requires: non-null expression
/// Determines whether the expression is a constant negative integer value. Always returns
/// false for non-constant, non-integer expression instances.
///
internal static bool IsConstantNegativeInteger(DbExpression expression)
{
return (expression.ExpressionKind == DbExpressionKind.Constant &&
TypeSemantics.IsIntegerNumericType(expression.ResultType) &&
Convert.ToInt64(((DbConstantExpression)expression).Value, CultureInfo.InvariantCulture) < 0);
}
internal static TypeUsage SetResultAsNullable(TypeUsage typeUsage)
{
TypeUsage newTypeUsage = typeUsage;
if (!TypeSemantics.IsNullable(typeUsage))
{
newTypeUsage = newTypeUsage.ShallowCopy(new FacetValues { Nullable = true });
}
return newTypeUsage;
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- CustomErrorsSection.cs
- XmlSchemaSimpleContent.cs
- CallTemplateAction.cs
- KeyInstance.cs
- InlineCategoriesDocument.cs
- RootBrowserWindowAutomationPeer.cs
- DataControlButton.cs
- DocumentPageView.cs
- MaskedTextBox.cs
- XsltException.cs
- QueryExtender.cs
- CompilerError.cs
- MetadataFile.cs
- HtmlButton.cs
- TypedReference.cs
- LineBreakRecord.cs
- NameTable.cs
- DataObject.cs
- MultiDataTrigger.cs
- TraceSection.cs
- TemplatePropertyEntry.cs
- TextTreeTextNode.cs
- Rules.cs
- XmlQueryOutput.cs
- ByteStreamMessage.cs
- SafeSecurityHelper.cs
- SurrogateEncoder.cs
- SqlUtils.cs
- IisTraceWebEventProvider.cs
- VectorCollectionConverter.cs
- SessionParameter.cs
- DataGridViewTopRowAccessibleObject.cs
- RegistrySecurity.cs
- ProfileService.cs
- OracleColumn.cs
- XmlWrappingWriter.cs
- propertyentry.cs
- SimpleRecyclingCache.cs
- XmlExpressionDumper.cs
- SocketException.cs
- MenuStrip.cs
- SqlDesignerDataSourceView.cs
- KeyedPriorityQueue.cs
- dsa.cs
- FileSecurity.cs
- Keyboard.cs
- GlobalDataBindingHandler.cs
- ScrollViewerAutomationPeer.cs
- InheritedPropertyChangedEventArgs.cs
- Size3D.cs
- AutoSizeToolBoxItem.cs
- XmlSchemaType.cs
- DefaultShape.cs
- TypeDescriptor.cs
- RemotingConfigParser.cs
- Matrix.cs
- DeviceSpecificDesigner.cs
- CompositeDispatchFormatter.cs
- DynamicValidatorEventArgs.cs
- HorizontalAlignConverter.cs
- FileDialog.cs
- ServiceModelConfigurationSectionGroup.cs
- Encoder.cs
- CodeNamespaceImportCollection.cs
- ScriptIgnoreAttribute.cs
- ZipIOExtraFieldElement.cs
- LogFlushAsyncResult.cs
- SoapElementAttribute.cs
- BlockCollection.cs
- UseLicense.cs
- FieldDescriptor.cs
- WindowsFormsHostPropertyMap.cs
- InkCanvasFeedbackAdorner.cs
- NameValuePermission.cs
- BasicExpressionVisitor.cs
- IdSpace.cs
- ConfigUtil.cs
- Vector3DAnimationUsingKeyFrames.cs
- XhtmlBasicControlAdapter.cs
- SiteMapNode.cs
- ImageKeyConverter.cs
- FormatterServices.cs
- ReferencedCollectionType.cs
- PtsContext.cs
- BinaryUtilClasses.cs
- SafeReversePInvokeHandle.cs
- _NetworkingPerfCounters.cs
- CommonGetThemePartSize.cs
- SubMenuStyle.cs
- TableRowGroup.cs
- SchemaNamespaceManager.cs
- ProtocolInformationReader.cs
- ValueOfAction.cs
- FocusWithinProperty.cs
- SchemaContext.cs
- CodeGroup.cs
- List.cs
- Vector.cs
- WebPartCloseVerb.cs
- DataTableClearEvent.cs