Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

583 lines
19 KiB
C#

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Linq;
using System.Data.Linq.Mapping;
using System.Globalization;
namespace LinqToSqlShared.Mapping {
/// <summary>
/// DatabaseMapping and related classes represent a parsed version of the
/// XML mapping string. This unvalidated intermediate representation is
/// necessary because unused mappings are intentially never validated.
/// </summary>
internal class DatabaseMapping {
string databaseName;
string provider;
List<TableMapping> tables;
List<FunctionMapping> functions;
internal DatabaseMapping() {
this.tables = new List<TableMapping>();
this.functions = new List<FunctionMapping>();
}
internal string DatabaseName {
get { return this.databaseName; }
set { this.databaseName = value; }
}
internal string Provider {
get { return this.provider; }
set { this.provider = value; }
}
internal List<TableMapping> Tables {
get { return this.tables; }
}
internal List<FunctionMapping> Functions {
get { return this.functions; }
}
internal TableMapping GetTable(string tableName) {
foreach (TableMapping tmap in this.tables) {
if (string.Compare(tmap.TableName, tableName, StringComparison.Ordinal) == 0)
return tmap;
}
return null;
}
internal TableMapping GetTable(Type rowType) {
foreach (TableMapping tableMap in this.tables) {
if (this.IsType(tableMap.RowType, rowType)) {
return tableMap;
}
}
return null;
}
private bool IsType(TypeMapping map, Type type) {
if (string.Compare(map.Name, type.Name, StringComparison.Ordinal) == 0
|| string.Compare(map.Name, type.FullName, StringComparison.Ordinal) == 0
|| string.Compare(map.Name, type.AssemblyQualifiedName, StringComparison.Ordinal) == 0)
return true;
foreach (TypeMapping subMap in map.DerivedTypes) {
if (this.IsType(subMap, type))
return true;
}
return false;
}
internal FunctionMapping GetFunction(string functionName) {
foreach (FunctionMapping fmap in this.functions) {
if (string.Compare(fmap.Name, functionName, StringComparison.Ordinal) == 0)
return fmap;
}
return null;
}
}
/// <summary>
/// Constants in the mapping schema.
/// </summary>
class XmlMappingConstant {
internal const string Association = "Association";
internal const string AutoSync = "AutoSync";
internal const string Column = "Column";
internal const string Database = "Database";
internal const string DbType = "DbType";
internal const string DeleteRule = "DeleteRule";
internal const string DeleteOnNull = "DeleteOnNull";
internal const string Direction = "Direction";
internal const string ElementType = "ElementType";
internal const string Expression = "Expression";
internal const string False = "false";
internal const string Function = "Function";
internal const string InheritanceCode = "InheritanceCode";
internal const string IsComposable = "IsComposable";
internal const string IsDbGenerated = "IsDbGenerated";
internal const string IsDiscriminator = "IsDiscriminator";
internal const string IsPrimaryKey = "IsPrimaryKey";
internal const string IsInheritanceDefault = "IsInheritanceDefault";
internal const string IsForeignKey = "IsForeignKey";
internal const string IsUnique = "IsUnique";
internal const string IsVersion = "IsVersion";
internal const string MappingNamespace = "http://schemas.microsoft.com/linqtosql/mapping/2007";
internal const string Member = "Member";
internal const string Method = "Method";
internal const string Name = "Name";
internal const string CanBeNull = "CanBeNull";
internal const string OtherKey = "OtherKey";
internal const string Parameter = "Parameter";
internal const string Provider = "Provider";
internal const string Return = "Return";
internal const string Storage = "Storage";
internal const string Table = "Table";
internal const string ThisKey = "ThisKey";
internal const string True = "true";
internal const string Type = "Type";
internal const string UpdateCheck = "UpdateCheck";
}
internal class TableMapping {
string tableName;
string member;
TypeMapping rowType;
internal TableMapping() {
}
internal string TableName {
get { return this.tableName; }
set { this.tableName = value; }
}
internal string Member {
get { return this.member; }
set { this.member = value; }
}
internal TypeMapping RowType {
get { return this.rowType; }
set { this.rowType = value; }
}
}
internal class FunctionMapping {
string name;
string methodName;
bool isComposable;
List<ParameterMapping> parameters;
List<TypeMapping> types;
ReturnMapping funReturn;
internal FunctionMapping() {
this.parameters = new List<ParameterMapping>();
this.types = new List<TypeMapping>();
}
internal string Name {
get { return this.name; }
set { this.name = value; }
}
internal string MethodName {
get { return this.methodName; }
set { this.methodName = value; }
}
internal bool IsComposable {
get { return this.isComposable; }
set { this.isComposable = value; }
}
internal string XmlIsComposable {
get { return this.isComposable ? XmlMappingConstant.True : null; }
set { this.isComposable = (value != null) ? bool.Parse(value) : false; }
}
internal List<ParameterMapping> Parameters {
get { return this.parameters; }
}
internal List<TypeMapping> Types {
get { return this.types; }
}
internal ReturnMapping FunReturn {
get { return this.funReturn; }
set { this.funReturn = value; }
}
}
internal enum MappingParameterDirection {
In,
Out,
InOut
}
internal class ParameterMapping {
string name;
string parameterName;
string dbType;
MappingParameterDirection direction;
internal string Name {
get { return this.name; }
set { this.name = value; }
}
internal string ParameterName {
get { return this.parameterName; }
set { this.parameterName = value; }
}
internal string DbType {
get { return this.dbType; }
set { this.dbType = value; }
}
public string XmlDirection {
get { return this.direction == MappingParameterDirection.In ? null : this.direction.ToString(); }
set {
this.direction = (value == null)
? MappingParameterDirection.In
: (MappingParameterDirection)Enum.Parse(typeof(MappingParameterDirection), value, true);
}
}
public MappingParameterDirection Direction {
get { return this.direction; }
set { this.direction = value; }
}
}
internal class ReturnMapping {
string dbType;
internal string DbType {
get { return this.dbType; }
set { this.dbType = value; }
}
}
internal class TypeMapping {
string name;
TypeMapping baseType;
List<MemberMapping> members;
string inheritanceCode;
bool isInheritanceDefault;
List<TypeMapping> derivedTypes;
internal TypeMapping() {
this.members = new List<MemberMapping>();
this.derivedTypes = new List<TypeMapping>();
}
internal TypeMapping BaseType {
get { return this.baseType; }
set { this.baseType = value; }
}
internal string Name {
get { return this.name; }
set { this.name = value; }
}
internal List<MemberMapping> Members {
get { return this.members; }
}
internal string InheritanceCode {
get { return this.inheritanceCode; }
set { this.inheritanceCode = value; }
}
internal bool IsInheritanceDefault {
get { return this.isInheritanceDefault; }
set { this.isInheritanceDefault = value; }
}
internal string XmlIsInheritanceDefault {
get { return this.isInheritanceDefault ? XmlMappingConstant.True : null; }
set { this.isInheritanceDefault = (value != null) ? bool.Parse(value) : false; }
}
internal List<TypeMapping> DerivedTypes {
get { return this.derivedTypes; }
}
}
internal abstract class MemberMapping {
string name;
string member;
string storageMember;
internal MemberMapping() {
}
internal string DbName {
get { return this.name; }
set { this.name = value; }
}
internal string MemberName {
get { return this.member; }
set { this.member = value; }
}
internal string StorageMemberName {
get { return this.storageMember; }
set { this.storageMember = value; }
}
}
internal sealed class ColumnMapping : MemberMapping {
string dbType;
string expression;
bool isPrimaryKey;
bool isDBGenerated;
bool isVersion;
bool isDiscriminator;
bool? canBeNull = null;
UpdateCheck updateCheck;
AutoSync autoSync;
internal ColumnMapping() {
}
internal string DbType {
get { return this.dbType; }
set { this.dbType = value; }
}
internal bool? CanBeNull {
get { return this.canBeNull; }
set { this.canBeNull = value; }
}
internal string XmlCanBeNull {
get {
if (this.canBeNull == null) return null;
return this.canBeNull == true ? null : XmlMappingConstant.False;
}
set { this.canBeNull = (value != null) ? bool.Parse(value) : true; }
}
internal string Expression {
get { return this.expression; }
set { this.expression = value; }
}
internal bool IsPrimaryKey {
get { return this.isPrimaryKey; }
set { this.isPrimaryKey = value; }
}
internal string XmlIsPrimaryKey {
get { return this.isPrimaryKey ? XmlMappingConstant.True : null; }
set { this.isPrimaryKey = (value != null) ? bool.Parse(value) : false; }
}
internal bool IsDbGenerated {
get { return this.isDBGenerated; }
set { this.isDBGenerated = value; }
}
internal string XmlIsDbGenerated {
get { return this.isDBGenerated ? XmlMappingConstant.True : null; }
set { this.isDBGenerated = (value != null) ? bool.Parse(value) : false; }
}
internal bool IsVersion {
get { return this.isVersion; }
set { this.isVersion = value; }
}
internal string XmlIsVersion {
get { return this.isVersion ? XmlMappingConstant.True : null; }
set { this.isVersion = (value != null) ? bool.Parse(value) : false; }
}
internal bool IsDiscriminator {
get { return this.isDiscriminator; }
set { this.isDiscriminator = value; }
}
internal string XmlIsDiscriminator {
get { return this.isDiscriminator ? XmlMappingConstant.True : null; }
set { this.isDiscriminator = (value != null) ? bool.Parse(value) : false; }
}
internal UpdateCheck UpdateCheck {
get { return this.updateCheck; }
set { this.updateCheck = value; }
}
internal string XmlUpdateCheck {
get { return this.updateCheck != UpdateCheck.Always ? this.updateCheck.ToString() : null; }
set { this.updateCheck = (value == null) ? UpdateCheck.Always : (UpdateCheck)Enum.Parse(typeof(UpdateCheck), value); }
}
internal AutoSync AutoSync {
get { return this.autoSync; }
set { this.autoSync = value; }
}
internal string XmlAutoSync {
get { return this.autoSync != AutoSync.Default ? this.autoSync.ToString() : null; }
set { this.autoSync = (value != null) ? (AutoSync)Enum.Parse(typeof(AutoSync), value) : AutoSync.Default; }
}
}
internal sealed class AssociationMapping : MemberMapping {
string thisKey;
string otherKey;
string deleteRule;
bool deleteOnNull;
bool isForeignKey;
bool isUnique;
internal AssociationMapping() {
}
internal string ThisKey {
get { return this.thisKey; }
set { this.thisKey = value; }
}
internal string OtherKey {
get { return this.otherKey; }
set { this.otherKey = value; }
}
internal string DeleteRule {
get { return this.deleteRule; }
set { this.deleteRule = value; }
}
internal bool DeleteOnNull {
get { return this.deleteOnNull; }
set { this.deleteOnNull = value; }
}
internal bool IsForeignKey {
get { return this.isForeignKey; }
set { this.isForeignKey = value; }
}
internal string XmlIsForeignKey {
get { return this.isForeignKey ? XmlMappingConstant.True : null; }
set { this.isForeignKey = (value != null) ? bool.Parse(value) : false; }
}
internal string XmlDeleteOnNull {
get { return this.deleteOnNull ? XmlMappingConstant.True : null; }
set { this.deleteOnNull = (value != null) ? bool.Parse(value) : false; }
}
internal bool IsUnique {
get { return this.isUnique; }
set { this.isUnique = value; }
}
internal string XmlIsUnique {
get { return this.isUnique ? XmlMappingConstant.True : null; }
set { this.isUnique = (value != null) ? bool.Parse(value) : false; }
}
}
/// <summary>
/// Shared rules governing the mapping system.
/// </summary>
internal static class MappingSystem {
/// <summary>
/// Return true if this is a clr type supported as an inheritance discriminator.
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
internal static bool IsSupportedDiscriminatorType(Type type) {
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>)) {
type = type.GetGenericArguments()[0];
}
switch (Type.GetTypeCode(type)) {
case TypeCode.Byte:
case TypeCode.SByte:
case TypeCode.Int16:
case TypeCode.Int32:
case TypeCode.Int64:
case TypeCode.UInt16:
case TypeCode.UInt32:
case TypeCode.UInt64:
case TypeCode.Char:
case TypeCode.String:
case TypeCode.Boolean:
return true;
}
return false;
}
/// <summary>
/// Return true if this is a clr type supported as an inheritance discriminator.
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
internal static bool IsSupportedDiscriminatorType(SqlDbType type) {
switch (type) {
case SqlDbType.BigInt:
case SqlDbType.Bit:
case SqlDbType.Char:
case SqlDbType.Int:
case SqlDbType.NChar:
case SqlDbType.NVarChar:
case SqlDbType.SmallInt:
case SqlDbType.TinyInt:
case SqlDbType.VarChar:
return true;
}
return false;
}
/// <summary>
/// Return true if this is a CLR type supported as an identity member. Since identity
/// management (caching) relies on key members being hashable, only types implementing
/// GetHashCode are supported. Also, the runtime relies on identity members being comparable,
/// so only types implementing Equals are supported.
/// </summary>
internal static bool IsSupportedIdentityType(Type type)
{
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>))
{
type = type.GetGenericArguments()[0];
}
if (type == typeof(Guid) || type == typeof(DateTime) || type == typeof(DateTimeOffset) ||
type == typeof(TimeSpan) || type == typeof(Binary))
{
return true;
}
switch (Type.GetTypeCode(type))
{
case TypeCode.Byte:
case TypeCode.SByte:
case TypeCode.Int16:
case TypeCode.Int32:
case TypeCode.Int64:
case TypeCode.UInt16:
case TypeCode.UInt32:
case TypeCode.UInt64:
case TypeCode.Char:
case TypeCode.String:
case TypeCode.Boolean:
case TypeCode.Decimal:
case TypeCode.Single:
case TypeCode.Double:
return true;
}
return false;
}
/// <summary>
/// Types that do not support comparison cannot be used as primary keys. The
/// database will restrict this, but we can't rely on that, since it is possible
/// to create a key mapping to a column that isn't truly a key in the DB.
/// </summary>
internal static bool IsSupportedIdentityType(SqlDbType type)
{
switch (type) {
case SqlDbType.NText:
case SqlDbType.Image:
case SqlDbType.Xml:
case SqlDbType.Text:
case SqlDbType.Variant:
case SqlDbType.Udt:
return false;
default:
return true;
}
}
}
}