public NodaTimeSqlServerTypeMappingSource(TypeMappingSourceDependencies dependencies, RelationalTypeMappingSourceDependencies relationalDependencies) : base(dependencies, relationalDependencies) { }
public NpgsqlTypeMappingSource([NotNull] TypeMappingSourceDependencies dependencies, [NotNull] RelationalTypeMappingSourceDependencies relationalDependencies, [NotNull] ISqlGenerationHelper sqlGenerationHelper, [CanBeNull] INpgsqlOptions npgsqlOptions = null) : base(dependencies, relationalDependencies) { _sqlGenerationHelper = Check.NotNull(sqlGenerationHelper, nameof(sqlGenerationHelper)); // Initialize some mappings which depend on other mappings _int4range = new NpgsqlRangeTypeMapping("int4range", typeof(NpgsqlRange <int>), _int4, sqlGenerationHelper); _int8range = new NpgsqlRangeTypeMapping("int8range", typeof(NpgsqlRange <long>), _int8, sqlGenerationHelper); _numrange = new NpgsqlRangeTypeMapping("numrange", typeof(NpgsqlRange <decimal>), _numeric, sqlGenerationHelper); _tsrange = new NpgsqlRangeTypeMapping("tsrange", typeof(NpgsqlRange <DateTime>), _timestamp, sqlGenerationHelper); _tstzrange = new NpgsqlRangeTypeMapping("tstzrange", typeof(NpgsqlRange <DateTime>), _timestamptz, sqlGenerationHelper); _daterange = new NpgsqlRangeTypeMapping("daterange", typeof(NpgsqlRange <DateTime>), _timestamptz, sqlGenerationHelper); // Note that PostgreSQL has aliases to some built-in type name aliases (e.g. int4 for integer), // these are mapped as well. // https://www.postgresql.org/docs/current/static/datatype.html#DATATYPE-TABLE var storeTypeMappings = new Dictionary <string, RelationalTypeMapping[]>(StringComparer.OrdinalIgnoreCase) { { "boolean", new[] { _bool } }, { "bool", new[] { _bool } }, { "bytea", new[] { _bytea } }, { "real", new[] { _float4 } }, { "float4", new[] { _float4 } }, { "double precision", new[] { _float8 } }, { "float8", new[] { _float8 } }, { "numeric", new[] { _numeric } }, { "decimal", new[] { _numeric } }, { "money", new[] { _money } }, { "uuid", new[] { _uuid } }, { "smallint", new RelationalTypeMapping[] { _int2, _int2Byte } }, { "int2", new RelationalTypeMapping[] { _int2, _int2Byte } }, { "integer", new[] { _int4 } }, { "int", new[] { _int4 } }, { "int4", new[] { _int4 } }, { "bigint", new[] { _int8 } }, { "int8", new[] { _int8 } }, { "text", new[] { _text } }, { "jsonb", new RelationalTypeMapping[] { _jsonbString, _jsonbDocument, _jsonbElement } }, { "json", new RelationalTypeMapping[] { _jsonString, _jsonDocument, _jsonElement } }, { "xml", new[] { _xml } }, { "citext", new[] { _citext } }, { "character varying", new[] { _varchar } }, { "varchar", new[] { _varchar } }, { "character", new[] { _char } }, { "char", new[] { _char } }, { "char(1)", new RelationalTypeMapping[] { _singleChar, _stringAsSingleChar } }, { "character(1)", new RelationalTypeMapping[] { _singleChar, _stringAsSingleChar } }, { "date", new[] { _date } }, { "timestamp without time zone", new[] { _timestamp } }, { "timestamp", new[] { _timestamp } }, { "timestamp with time zone", new[] { _timestamptz, _timestamptzDto } }, { "timestamptz", new[] { _timestamptz, _timestamptzDto } }, { "interval", new[] { _interval } }, { "time without time zone", new[] { _time } }, { "time", new[] { _time } }, { "time with time zone", new[] { _timetz } }, { "timetz", new[] { _timetz } }, { "macaddr", new[] { _macaddr } }, { "macaddr8", new[] { _macaddr8 } }, { "inet", new[] { _inet } }, { "cidr", new[] { _cidr } }, { "bit", new[] { _bit } }, { "bit varying", new[] { _varbit } }, { "varbit", new[] { _varbit } }, { "hstore", new[] { _hstore } }, { "point", new[] { _point } }, { "box", new[] { _box } }, { "line", new[] { _line } }, { "lseg", new[] { _lseg } }, { "path", new[] { _path } }, { "polygon", new[] { _polygon } }, { "circle", new[] { _circle } }, { "xid", new[] { _xid } }, { "oid", new[] { _oid } }, { "cid", new[] { _cid } }, { "regtype", new[] { _regtype } }, { "lo", new[] { _lo } }, { "tid", new[] { _tid } }, { "int4range", new[] { _int4range } }, { "int8range", new[] { _int8range } }, { "numrange", new[] { _numrange } }, { "tsrange", new[] { _tsrange } }, { "tstzrange", new[] { _tstzrange } }, { "daterange", new[] { _daterange } }, { "tsquery", new[] { _tsquery } }, { "tsvector", new[] { _tsvector } }, { "regconfig", new[] { _regconfig } } }; var clrTypeMappings = new Dictionary <Type, RelationalTypeMapping> { { typeof(bool), _bool },
/// <summary> /// 实例化类型映射源 /// </summary> /// <param name="dependencies">类型映射源</param> /// <param name="relationalDependencies">关系类型映射源</param> /// <param name="oracleOptions">选项</param> /// <param name="logger">日志</param> public OracleTypeMappingSource( [NotNull] TypeMappingSourceDependencies dependencies, [NotNull] RelationalTypeMappingSourceDependencies relationalDependencies, [NotNull] IOracleOptions oracleOptions, IDiagnosticsLogger <DbLoggerCategory.Model> logger = null) : base(dependencies, relationalDependencies) { m_oracleLogger = logger; if (oracleOptions != null && oracleOptions.OracleSQLCompatibility != null) { _oracleSQLCompatibility = oracleOptions.OracleSQLCompatibility; } string oracleSQLCompatibility = _oracleSQLCompatibility; _xml = new OracleStringTypeMapping("XML", null, oracleSQLCompatibility, unicode: true); _fixedLengthUnicodeString = new OracleStringTypeMapping("NCHAR", oracleSQLCompatibility: _oracleSQLCompatibility, dbType: DbType.String, unicode: true, size: null, fixedLength: true); oracleSQLCompatibility = _oracleSQLCompatibility; _variableLengthUnicodeString = new OracleStringTypeMapping("NVARCHAR2", null, oracleSQLCompatibility, unicode: true); _fixedLengthAnsiString = new OracleStringTypeMapping("CHAR", oracleSQLCompatibility: _oracleSQLCompatibility, dbType: DbType.AnsiString, unicode: false, size: null, fixedLength: true); _variableLengthAnsiString = new OracleStringTypeMapping("VARCHAR2", oracleSQLCompatibility: _oracleSQLCompatibility, dbType: DbType.AnsiString); _timeYTM = new OracleStringTypeMapping("INTERVAL YEAR(2) TO MONTH", oracleSQLCompatibility: _oracleSQLCompatibility, dbType: DbType.String); oracleSQLCompatibility = _oracleSQLCompatibility; _urowID = new OracleStringTypeMapping("UROWID", null, oracleSQLCompatibility); if (Check.IsTraceEnabled(m_oracleLogger?.Logger)) { Trace <DbLoggerCategory.Model> .Write(m_oracleLogger, LogLevel.Trace, OracleTraceTag.Entry, OracleTraceClassName.OracleTypeMappingSource, OracleTraceFuncName.ctor); } // 通用语言运行时类型映射表,通用语言运行时(CLR)支持的数据类型与数据库支持的类型之间的映射 _clrTypeMappings = new Dictionary <Type, RelationalTypeMapping> { { typeof(bool), _bool }, { typeof(sbyte), _sbyte }, { typeof(byte), _byte }, { typeof(short), _short }, { typeof(ushort), _ushort }, { typeof(int), _int }, { typeof(uint), _uint }, { typeof(long), _long }, { typeof(ulong), _ulong }, { typeof(float), _float }, { typeof(double), _double }, { typeof(decimal), _decimal }, { typeof(DateTime), _datetime }, { typeof(DateTimeOffset), _datetimeoffset3 }, { typeof(TimeSpan), _time }, { typeof(Guid), _guid } }; // 存储类型映射表, 模型上的类型名称注解(TypeName)与数据库支持的类型之间的映射 _storeTypeMappings = new Dictionary <string, RelationalTypeMapping>(StringComparer.OrdinalIgnoreCase) { { "number(1)", _bool }, { "number(3)", _byte }, { "number(5)", _short }, { "number(10)", _int }, { "number(19)", _long }, { "number(17,4)", _real }, { "number(26,9)", _real }, // 兼容 { "number(29,9)", _decimal }, { "decimal(17,4)", _real }, { "decimal(29,9)", _decimal }, { "binary_integer", _int }, { "binary_float", _float }, { "binary_double", _double }, { "char", _fixedLengthAnsiString }, { "nchar", _fixedLengthUnicodeString }, { "varchar2", _variableLengthAnsiString }, { "nvarchar2", _variableLengthUnicodeString }, { "long", _variableLengthAnsiString }, { "long raw", _variableLengthBinary }, { "clob", _unboundedAnsiString }, { "nclob", _unboundedUnicodeString }, { "blob", _variableLengthBinary }, { "bfile", _variableLengthBinary }, { "date", _date }, { "timestamp", _datetime }, { "timestamp(0) with time zone", _datetimeoffset }, { "timestamp(1) with time zone", _datetimeoffset }, { "timestamp(2) with time zone", _datetimeoffset }, { "timestamp(3) with time zone", _datetimeoffset3 }, { "timestamp(4) with time zone", _datetimeoffset }, { "timestamp(5) with time zone", _datetimeoffset }, { "timestamp(6) with time zone", _datetimeoffset }, { "timestamp(7) with time zone", _datetimeoffset }, { "timestamp(8) with time zone", _datetimeoffset }, { "timestamp(9) with time zone", _datetimeoffset }, { "timestamp with time zone", _datetimeoffset }, { "timestamp(0) with local time zone", _datetimeoffsetlocal }, { "timestamp(1) with local time zone", _datetimeoffsetlocal }, { "timestamp(2) with local time zone", _datetimeoffsetlocal }, { "timestamp(3) with local time zone", _datetimeoffsetlocal }, { "timestamp(4) with local time zone", _datetimeoffsetlocal }, { "timestamp(5) with local time zone", _datetimeoffsetlocal }, { "timestamp(6) with local time zone", _datetimeoffsetlocal }, { "timestamp(7) with local time zone", _datetimeoffsetlocal }, { "timestamp(8) with local time zone", _datetimeoffsetlocal }, { "timestamp(9) with local time zone", _datetimeoffsetlocal }, { "timestamp with local time zone", _datetimeoffsetlocal }, { "interval", _time }, { "interval day", _time }, { "interval year", _timeYTM }, { "ROWID", _fixedLengthAnsiString }, { "UROWID", _urowID }, { "XMLTYPE", _xml }, { "xml", _xml } }; if (Check.IsTraceEnabled(m_oracleLogger?.Logger)) { Trace <DbLoggerCategory.Model> .Write(m_oracleLogger, LogLevel.Trace, OracleTraceTag.Exit, OracleTraceClassName.OracleTypeMappingSource, OracleTraceFuncName.ctor); } }
public MongoTypeMappingSource( TypeMappingSourceDependencies dependencies) : base(dependencies) { }
public TestRelationalTypeMappingSource( TypeMappingSourceDependencies dependencies, RelationalTypeMappingSourceDependencies relationalDependencies) : base(dependencies, relationalDependencies) { }
public TypeMapperWrapper([NotNull] TypeMappingSourceDependencies dependencies, [NotNull] RelationalTypeMappingSourceDependencies relationalDependencies) : base(dependencies, relationalDependencies) { }
public ElasticTypeMappingSource([NotNull] TypeMappingSourceDependencies dependencies) : base(dependencies) { }
/// <summary> /// This API supports the Entity Framework Core infrastructure and is not intended to be used /// directly from your code. This API may change or be removed in future releases. /// </summary> public SqliteTypeMappingSource( [NotNull] TypeMappingSourceDependencies dependencies, [NotNull] RelationalTypeMappingSourceDependencies relationalDependencies) : base(dependencies, relationalDependencies) { }
public OpenEdgeTypeMappingSource(TypeMappingSourceDependencies dependencies, RelationalTypeMappingSourceDependencies relationalDependencies) : base(dependencies, relationalDependencies) { _clrTypeMappings = new Dictionary <Type, RelationalTypeMapping> { { typeof(int), _integer }, { typeof(long), _bigint }, { typeof(DateTime), _datetime }, { typeof(bool), _boolean }, { typeof(byte), _tinyint }, { typeof(byte[]), _binary }, { typeof(double), _double }, { typeof(DateTimeOffset), _datetime }, { typeof(short), _smallint }, { typeof(float), _float }, { typeof(decimal), _decimal }, { typeof(TimeSpan), _time } }; _storeTypeMappings = new Dictionary <string, RelationalTypeMapping>(StringComparer.OrdinalIgnoreCase) { { "bigint", _bigint }, { "int64", _bigint }, { "binary varying", _binary }, { "raw", _binary }, { "binary", _binary }, { "bit", _boolean }, { "logical", _boolean }, { "char varying", _char }, { "char", _char }, { "character varying", _char }, { "character", _char }, { "date", _date }, { "datetime", _datetime }, { "datetime2", _datetime }, { "datetimeoffset", _datetimeOffset }, { "datetime-tz", _datetimeOffset }, { "dec", _decimal }, { "decimal", _decimal }, { "double precision", _double }, { "float", _double }, { "image", _binary }, { "int", _integer }, { "integer", _integer }, { "money", _decimal }, { "numeric", _decimal }, { "real", _float }, { "smalldatetime", _datetime }, { "smallint", _smallint }, { "short", _smallint }, { "smallmoney", _decimal }, { "text", _char }, { "time", _time }, { "timestamp", _timeStamp }, { "tinyint", _tinyint }, { "varbinary", _binary }, { "varchar", _varchar } }; }
/// <summary> /// This API supports the Entity Framework Core infrastructure and is not intended to be used /// directly from your code. This API may change or be removed in future releases. /// </summary> public JetTypeMappingSource( [NotNull] TypeMappingSourceDependencies dependencies, [NotNull] RelationalTypeMappingSourceDependencies relationalDependencies) : base(dependencies, relationalDependencies) { _storeTypeMappings = new Dictionary <string, RelationalTypeMapping>(StringComparer.OrdinalIgnoreCase) { { "binary", _fixedLengthBinary }, { "bit", _bool }, { "byte", _byte }, { "char", _fixedLengthUnicodeString }, { "date", _date }, { "datetime", _datetime }, { "decimal", _decimal }, { "float", _double }, { "double", _double }, { "image", _variableLengthBinary }, { "int", _int }, { "guid", _uniqueidentifier }, { "money", _decimal }, { "numeric", _decimal }, { "real", _real }, { "single", _real }, { "smalldatetime", _datetime }, { "smallint", _short }, { "smallmoney", _decimal }, { "text", _variableLengthUnicodeString }, { "time", _time }, { "timestamp", _rowversion }, { "tinyint", _byte }, { "uniqueidentifier", _uniqueidentifier }, { "varbinary", _variableLengthBinary }, { "varchar", _variableLengthUnicodeString }, { "xml", _xml } }; // Note: sbyte, ushort, uint, char and ulong type mappings are not supported by Jet. // We would need the type conversions feature to allow this to work - see https://github.com/aspnet/EntityFramework/issues/242. _clrTypeMappings = new Dictionary <Type, RelationalTypeMapping> { { typeof(int), _int }, { typeof(long), _long }, { typeof(DateTime), _datetime }, { typeof(Guid), _uniqueidentifier }, { typeof(bool), _bool }, { typeof(byte), _byte }, { typeof(double), _double }, { typeof(DateTimeOffset), _datetimeoffset }, { typeof(short), _short }, { typeof(float), _real }, { typeof(decimal), _decimal }, { typeof(TimeSpan), _time } }; // These are disallowed only if specified without any kind of length specified in parenthesis. // This is because we don't try to make a new type from this string and any max length value // specified in the model, which means use of these strings is almost certainly an error, and // if it is not an error, then using, for example, varbinary(1) will work instead. _disallowedMappings = new HashSet <string>(StringComparer.OrdinalIgnoreCase) { "binary varying", "binary", "char varying", "char", "character varying", "character", "national char varying", "national character varying", "national character", "nchar", "nvarchar", "varbinary", "varchar" }; }
/// <inheritdoc /> public MongoDbTypeMappingSource([NotNull] TypeMappingSourceDependencies dependencies) : base(dependencies) { }
public SpannerTypeMappingSource( TypeMappingSourceDependencies dependencies, RelationalTypeMappingSourceDependencies relationalDependencies) : base(dependencies, relationalDependencies) { _clrTypeMappings = new Dictionary <System.Type, RelationalTypeMapping> { { typeof(short), s_short }, { typeof(int), s_int }, { typeof(long), s_long }, { typeof(decimal), s_numeric }, { typeof(SpannerNumeric), s_numeric }, { typeof(uint), s_uint }, { typeof(bool), s_bool }, { typeof(SpannerDate), s_date }, { typeof(DateTime), s_datetime }, { typeof(float), s_float }, { typeof(double), s_double }, { typeof(string), s_defaultString }, { typeof(char), s_char }, { typeof(Guid), s_guid }, { typeof(Regex), s_defaultString }, { typeof(byte), s_byte }, { typeof(sbyte), s_sbyte }, { typeof(ulong), s_ulong }, { typeof(ushort), s_ushort }, { typeof(byte[]), s_bytes }, { typeof(decimal[]), s_numericArray }, { typeof(decimal?[]), s_nullableNumericArray }, { typeof(SpannerNumeric[]), s_numericArray }, { typeof(SpannerNumeric?[]), s_nullableNumericArray }, { typeof(List <decimal>), s_numericList }, { typeof(List <decimal?>), s_nullableNumericList }, { typeof(List <SpannerNumeric>), s_numericList }, { typeof(List <SpannerNumeric?>), s_nullableNumericList }, { typeof(string[]), s_stringArray }, { typeof(List <string>), s_stringList }, { typeof(bool[]), s_boolArray }, { typeof(bool?[]), s_nullableBoolArray }, { typeof(List <bool>), s_boolList }, { typeof(List <bool?>), s_nullableBoolList }, { typeof(double[]), s_doubleArray }, { typeof(double?[]), s_nullableDoubleArray }, { typeof(List <double>), s_doubleList }, { typeof(List <double?>), s_nullableDoubleList }, { typeof(long[]), s_longArray }, { typeof(long?[]), s_nullableLongArray }, { typeof(List <long>), s_longList }, { typeof(List <long?>), s_nullableLongList }, { typeof(SpannerDate[]), s_dateArray }, { typeof(SpannerDate?[]), s_nullableDateArray }, { typeof(List <SpannerDate>), s_dateList }, { typeof(List <SpannerDate?>), s_nullableDateList }, { typeof(List <DateTime>), s_timestampList }, { typeof(List <DateTime?>), s_nullableTimestampList }, { typeof(DateTime[]), s_timestampArray }, { typeof(DateTime?[]), s_nullableTimestampArray }, { typeof(byte[][]), s_byteArray }, { typeof(List <byte[]>), s_byteList }, }; _storeTypeMappings = new Dictionary <string, RelationalTypeMapping> { { SpannerDbType.Bool.ToString(), s_bool }, { SpannerDbType.Bytes.ToString(), s_bytes }, { SpannerDbType.Date.ToString(), s_date }, { SpannerDbType.Float64.ToString(), s_double }, { SpannerDbType.Int64.ToString(), s_long }, { SpannerDbType.Timestamp.ToString(), s_datetime }, { SpannerDbType.String.ToString(), s_defaultString }, { SpannerDbType.Numeric.ToString(), s_numeric }, { "ARRAY<BOOL>", s_nullableBoolList }, { "ARRAY<BYTES", s_byteList }, { "ARRAY<DATE>", s_nullableDateList }, { "ARRAY<FLOAT64>", s_nullableDoubleList }, { "ARRAY<INT64>", s_nullableLongList }, { "ARRAY<STRING", s_stringList }, { "ARRAY<TIMESTAMP>", s_nullableTimestampList }, { "ARRAY<NUMERIC>", s_nullableNumericList } }; _arrayTypeMappings = new Dictionary <string, RelationalTypeMapping> { { "ARRAY<BOOL>", s_nullableBoolArray }, { "ARRAY<BYTES", s_byteArray }, { "ARRAY<DATE>", s_nullableDateArray }, { "ARRAY<FLOAT64>", s_nullableDoubleArray }, { "ARRAY<INT64>", s_nullableLongArray }, { "ARRAY<STRING", s_stringArray }, { "ARRAY<TIMESTAMP>", s_nullableTimestampArray }, { "ARRAY<NUMERIC>", s_nullableNumericArray } }; }
public FileContextTypeMappingSource([NotNull] TypeMappingSourceDependencies dependencies) : base(dependencies) { }
/// <summary> /// This is an internal API that supports the Entity Framework Core infrastructure and not subject to /// the same compatibility standards as public APIs. It may be changed or removed without notice in /// any release. You should only use it directly in your code with extreme caution and knowing that /// doing so can result in application failures when updating to a new Entity Framework Core release. /// </summary> public InMemoryTypeMappingSource(TypeMappingSourceDependencies dependencies) : base(dependencies) { }
/// <summary> /// This API supports the Entity Framework Core infrastructure and is not intended to be used /// directly from your code. This API may change or be removed in future releases. /// </summary> public JetTypeMappingSource( [NotNull] TypeMappingSourceDependencies dependencies, [NotNull] RelationalTypeMappingSourceDependencies relationalDependencies, [NotNull] IJetOptions options) : base(dependencies, relationalDependencies) { // References: // https://docs.microsoft.com/en-us/previous-versions/office/developer/office2000/aa140015(v=office.10) // https://docs.microsoft.com/en-us/office/vba/access/concepts/error-codes/comparison-of-data-types // https://support.office.com/en-us/article/equivalent-ansi-sql-data-types-7a0a6bef-ef25-45f9-8a9a-3c5f21b5c65d // https://sourcedaddy.com/ms-access/sql-data-types.html // TODO: Check the types and their mappings against // https://docs.microsoft.com/en-us/previous-versions/office/developer/office2000/aa140015(v=office.10) _datetime = new JetDateTimeTypeMapping("datetime", options, dbType: DbType.DateTime); _datetimeoffset = new JetDateTimeOffsetTypeMapping("datetime", options); _date = new JetDateTimeTypeMapping("datetime", options, dbType: DbType.Date); _time = new JetTimeSpanTypeMapping("datetime", options); _storeTypeMappings = new Dictionary <string, RelationalTypeMapping>(StringComparer.OrdinalIgnoreCase) { { "binary", _fixedLengthBinary }, { "varbinary", _variableLengthBinary }, { "binary varying", _variableLengthBinary }, { "bit varying", _variableLengthBinary }, { "longbinary", _unboundedBinary }, { "general", _unboundedBinary }, { "image", _unboundedBinary }, { "oleobject", _unboundedBinary }, { "bit", _bit }, { "boolean", _bit }, { "logical", _bit }, { "logical1", _bit }, { "yesno", _bit }, { "counter", _counter }, { "identity", _counter }, { "autoincrement", _counter }, { "byte", _byte }, { "tinyint", _byte }, { "integer1", _byte }, { "smallint", _smallint }, { "short", _smallint }, { "integer2", _smallint }, { "integer", _integer }, { "long", _integer }, { "int", _integer }, { "integer4", _integer }, { "single", _single }, { "real", _single }, { "float4", _single }, { "ieeesingle", _single }, { "double", _double }, { "float", _double }, { "float8", _double }, { "ieeedouble", _double }, { "number", _double }, { "decimal", _decimal }, { "numeric", _decimal }, { "dec", _decimal }, { "currency", _currency }, { "money", _currency }, { "datetime", _datetime }, { "date", _date }, { "time", _time }, { "char", _fixedLengthUnicodeString }, { "alphanumeric", _fixedLengthUnicodeString }, { "character", _fixedLengthUnicodeString }, { "nchar", _fixedLengthUnicodeString }, { "national char", _fixedLengthUnicodeString }, { "national character", _fixedLengthUnicodeString }, { "varchar", _variableLengthUnicodeString }, { "string", _variableLengthUnicodeString }, { "char varying", _variableLengthUnicodeString }, { "character varying", _variableLengthUnicodeString }, { "national char varying", _variableLengthUnicodeString }, { "national character varying", _variableLengthUnicodeString }, { "longchar", _unboundedUnicodeString }, { "longtext", _unboundedUnicodeString }, { "memo", _unboundedUnicodeString }, { "note", _unboundedUnicodeString }, { "ntext", _unboundedUnicodeString }, { "guid", _guid }, { "uniqueidentifier", _guid }, { "timestamp", _rowversion }, }; // Note: sbyte, ushort, uint, char, long and ulong type mappings are not supported by Jet. // We would need the type conversions feature to allow this to work - see https://github.com/aspnet/EntityFramework/issues/242. _clrTypeMappings = new Dictionary <Type, RelationalTypeMapping> { { typeof(bool), _bool }, { typeof(byte), _byte }, { typeof(sbyte), _smallint }, { typeof(short), _smallint }, { typeof(int), _integer }, // {typeof(long), _bigint}, // uses DECIMAL(28,0) { typeof(float), _single }, { typeof(double), _double }, { typeof(decimal), _decimal }, // CHECK: Is this supported or do we need to use CURRENCY? { typeof(DateTime), _datetime }, { typeof(DateTimeOffset), _datetimeoffset }, { typeof(TimeSpan), _time }, { typeof(Guid), _guid }, }; // These are disallowed only if specified without any kind of length specified in parenthesis. // This is because we don't try to make a new type from this string and any max length value // specified in the model, which means use of these strings is almost certainly an error, and // if it is not an error, then using, for example, varbinary(1) will work instead. _disallowedMappings = new HashSet <string>(StringComparer.OrdinalIgnoreCase) { "binary", "varbinary", "image", "binary varying", "bit varying", "char", "alphanumeric", "character", "nchar", "national char", "national character", "varchar", "string", "char varying", "character varying", "national char varying", "national character varying", }; }
public JsonTypeMappingSource([NotNullAttribute] TypeMappingSourceDependencies dependencies, [NotNullAttribute] RelationalTypeMappingSourceDependencies relationalDependencies) : base(dependencies, relationalDependencies) { }
public TestTypeMappingSource(TypeMappingSourceDependencies dependencies) : base(dependencies) { }
/// <summary> /// This API supports the Entity Framework Core infrastructure and is not intended to be used /// directly from your code. This API may change or be removed in future releases. /// </summary> public CosmosTypeMappingSource([NotNull] TypeMappingSourceDependencies dependencies) : base(dependencies) { }
public MySqlTypeMappingSource( [NotNull] TypeMappingSourceDependencies dependencies, [NotNull] RelationalTypeMappingSourceDependencies relationalDependencies, [NotNull] IMySqlOptions options) : base(dependencies, relationalDependencies) { _options = options; _storeTypeMappings = new Dictionary <string, RelationalTypeMapping>(StringComparer.OrdinalIgnoreCase) { // boolean { "bit", _bit }, // integers { "tinyint", _tinyint }, { "tinyint unsigned", _utinyint }, { "smallint", _smallint }, { "smallint unsigned", _usmallint }, { "mediumint", _int }, { "mediumint unsigned", _uint }, { "int", _int }, { "int unsigned", _uint }, { "bigint", _bigint }, { "bigint unsigned", _ubigint }, // decimals { "decimal", _decimal }, { "dec", _decimal }, { "fixed", _decimal }, { "double", _double }, { "double precision", _double }, { "real", _double }, { "float", _float }, // binary { "binary", _binary }, { "varbinary", _varbinary }, { "tinyblob", _varbinary }, { "blob", _varbinary }, { "mediumblob", _varbinary }, { "longblob", _varbinary }, // string { "char", _char }, { "varchar", _varchar }, { "nchar", _nchar }, { "nvarchar", _nvarchar }, { "tinytext", _varcharmax }, { "text", _varcharmax }, { "mediumtext", _varcharmax }, { "longtext", _varcharmax }, // DateTime { "date", _date } }; _unicodeStoreTypeMappings = new Dictionary <string, RelationalTypeMapping>(StringComparer.OrdinalIgnoreCase) { { "char", _nchar }, { "varchar", _nvarchar }, { "nchar", _nchar }, { "nvarchar", _nvarchar }, { "tinytext", _nvarcharmax }, { "text", _nvarcharmax }, { "mediumtext", _nvarcharmax }, { "longtext", _nvarcharmax } }; _clrTypeMappings = new Dictionary <Type, RelationalTypeMapping> { // boolean { typeof(bool), _bit }, // integers { typeof(short), _smallint }, { typeof(ushort), _usmallint }, { typeof(int), _int }, { typeof(uint), _uint }, { typeof(long), _bigint }, { typeof(ulong), _ubigint }, // decimals { typeof(decimal), _decimal }, { typeof(float), _float }, { typeof(double), _double }, // byte / char { typeof(sbyte), _tinyint }, { typeof(byte), _utinyint } }; // guid _clrTypeMappings[typeof(Guid)] = _options.ConnectionSettings.OldGuids ? _oldGuid : _uniqueidentifier; // DateTime if (_options.ServerVersion.SupportsDateTime6) { _storeTypeMappings["time"] = _time6; _clrTypeMappings[typeof(DateTime)] = _dateTime6; _clrTypeMappings[typeof(DateTimeOffset)] = _dateTimeOffset6; _clrTypeMappings[typeof(TimeSpan)] = _time6; } else { _storeTypeMappings["time"] = _time; _clrTypeMappings[typeof(DateTime)] = _dateTime; _clrTypeMappings[typeof(DateTimeOffset)] = _dateTimeOffset; _clrTypeMappings[typeof(TimeSpan)] = _time; } }
public ReplacementTypeMappingSource( TypeMappingSourceDependencies dependencies, RelationalTypeMappingSourceDependencies relationalDependencies) : base(dependencies, relationalDependencies) { }
public InfoCarrierTypeMappingSource(TypeMappingSourceDependencies dependencies) : base(dependencies) { }
/// <summary> /// This API supports the Entity Framework Core infrastructure and is not intended to be used /// directly from your code. This API may change or be removed in future releases. /// </summary> public MySqlTypeMappingSource( [NotNull] TypeMappingSourceDependencies dependencies, [NotNull] RelationalTypeMappingSourceDependencies relationalDependencies) : base(dependencies, relationalDependencies) { _clrTypeMappings = new Dictionary <Type, RelationalTypeMapping> { { typeof(int), _int }, { typeof(long), _long }, { typeof(DateTime), _datetime2 }, { typeof(Guid), _uniqueidentifier }, { typeof(bool), _bool }, { typeof(byte), _byte }, { typeof(double), _double }, { typeof(DateTimeOffset), _datetimeoffset }, { typeof(short), _short }, { typeof(float), _real }, { typeof(decimal), _decimal }, { typeof(TimeSpan), _time } }; _storeTypeMappings = new Dictionary <string, RelationalTypeMapping>(StringComparer.OrdinalIgnoreCase) { { "bigint", _long }, { "binary varying", _variableLengthBinary }, { "binary", _fixedLengthBinary }, { "bit", _bool }, { "char varying", _variableLengthAnsiString }, { "char", _fixedLengthAnsiString }, { "character varying", _variableLengthAnsiString }, { "character", _fixedLengthAnsiString }, { "date", _date }, { "datetime", _datetime }, { "datetime2", _datetime2 }, { "datetimeoffset", _datetimeoffset }, { "dec", _decimal }, { "decimal", _decimal }, { "double precision", _double }, { "float", _double }, { "image", _variableLengthBinary }, { "int", _int }, { "money", _money }, { "national char varying", _variableLengthUnicodeString }, { "national character varying", _variableLengthUnicodeString }, { "national character", _fixedLengthUnicodeString }, { "nchar", _fixedLengthUnicodeString }, { "ntext", _variableLengthUnicodeString }, { "numeric", _decimal }, { "nvarchar", _variableLengthUnicodeString }, { "nvarchar(max)", _variableLengthMaxUnicodeString }, { "real", _real }, { "rowversion", _rowversion }, { "smalldatetime", _datetime }, { "smallint", _short }, { "smallmoney", _money }, { "sql_variant", _sqlVariant }, { "text", _variableLengthAnsiString }, { "time", _time }, { "timestamp", _rowversion }, { "tinyint", _byte }, { "uniqueidentifier", _uniqueidentifier }, { "varbinary", _variableLengthBinary }, { "varbinary(max)", _variableLengthMaxBinary }, { "varchar", _variableLengthAnsiString }, { "varchar(max)", _variableLengthMaxAnsiString }, { "xml", _xml } }; }
/// <summary> /// This API supports the Entity Framework Core infrastructure and is not intended to be used /// directly from your code. This API may change or be removed in future releases. /// </summary> public LiteDBTypeMappingSource([NotNull] TypeMappingSourceDependencies dependencies) : base(dependencies) { }