Code:
/ Net / Net / 3.5.50727.3053 / DEVDIV / depot / DevDiv / releases / Orcas / SP / ndp / fx / src / DataEntity / System / Data / Common / CommandTrees / Internal / CommandTreeTypeHelper.cs / 4 / 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
- HistoryEventArgs.cs
- WebBrowserProgressChangedEventHandler.cs
- PLINQETWProvider.cs
- TextPointerBase.cs
- SimpleMailWebEventProvider.cs
- ConfigXmlElement.cs
- NativeMethodsCLR.cs
- OdbcConnectionPoolProviderInfo.cs
- PartBasedPackageProperties.cs
- PolyBezierSegmentFigureLogic.cs
- SecurityTokenParametersEnumerable.cs
- TableRowCollection.cs
- ChineseLunisolarCalendar.cs
- WebPartVerbCollection.cs
- SqlServer2KCompatibilityAnnotation.cs
- TypedTableBase.cs
- PipelineDeploymentState.cs
- PartitionResolver.cs
- PasswordPropertyTextAttribute.cs
- ExpandSegmentCollection.cs
- MultiPropertyDescriptorGridEntry.cs
- Size3D.cs
- Encoder.cs
- Attributes.cs
- CompressedStack.cs
- ProcessModule.cs
- OpenFileDialog.cs
- ReflectEventDescriptor.cs
- CompiledRegexRunner.cs
- MSHTMLHost.cs
- DataGridPreparingCellForEditEventArgs.cs
- EntityDataSourceChangedEventArgs.cs
- WindowsUpDown.cs
- DataGridViewCellStyle.cs
- X509UI.cs
- ParallelActivityDesigner.cs
- Nullable.cs
- RelatedView.cs
- CheckBoxStandardAdapter.cs
- CodeMemberProperty.cs
- SimpleHandlerBuildProvider.cs
- GraphicsPathIterator.cs
- PageScaling.cs
- CqlParser.cs
- InsufficientMemoryException.cs
- CodeCommentStatement.cs
- BaseDataListPage.cs
- XmlEntityReference.cs
- TrackingMemoryStream.cs
- WindowsFormsHelpers.cs
- FilteredDataSetHelper.cs
- CommandBinding.cs
- WindowsComboBox.cs
- HtmlListAdapter.cs
- CellParaClient.cs
- connectionpool.cs
- PassportAuthenticationEventArgs.cs
- DataSourceDesigner.cs
- CompositionAdorner.cs
- QilChoice.cs
- HtmlMobileTextWriter.cs
- SettingsProviderCollection.cs
- XmlIlTypeHelper.cs
- VerticalAlignConverter.cs
- DeviceFilterDictionary.cs
- DataServiceHostFactory.cs
- BinaryEditor.cs
- DbParameterCollection.cs
- EntryWrittenEventArgs.cs
- ServiceOperation.cs
- OdbcParameter.cs
- DirectionalLight.cs
- Rect.cs
- PrintDialogException.cs
- CodeChecksumPragma.cs
- XmlUrlResolver.cs
- WinEventWrap.cs
- ZipIOExtraFieldPaddingElement.cs
- Compiler.cs
- PagedDataSource.cs
- ObjectQueryExecutionPlan.cs
- HotSpotCollection.cs
- XmlQueryOutput.cs
- TemplatedMailWebEventProvider.cs
- MouseGestureValueSerializer.cs
- SmtpMail.cs
- BinaryNode.cs
- ParallelTimeline.cs
- WebConvert.cs
- Types.cs
- FontStretches.cs
- WindowsFormsSynchronizationContext.cs
- SplitContainerDesigner.cs
- CompositeFontParser.cs
- webproxy.cs
- DataPagerFieldCollection.cs
- SystemNetworkInterface.cs
- ReadWriteSpinLock.cs
- BitmapData.cs
- HtmlElement.cs