public virtual DbTypeInfo Map(Type clrType, DbTypeDef typeDef, long size = 0, byte prec = 0, byte scale = 0) { var mapping = CreateDbTypeInfo(clrType, typeDef, size, prec, scale); DbTypesByClrType[clrType] = mapping; return(mapping); }
public virtual DbTypeInfo GetDbTypeInfo(EntityMemberInfo forMember) { var colType = forMember.DataType.GetUnderlyingStorageClrType(); if (DbTypesByClrType.TryGetValue(colType, out var typeInfo)) { return(typeInfo); } // direct mapping by col type (CLR type) not found. DbTypeDef storageType = null; // find by value kind var mappedTo = GetDbSpecialType(colType, forMember); if (mappedTo != DbSpecialType.None) { SpecialTypeDefs.TryGetValue(mappedTo, out storageType); } // if not found try by col type if (storageType == null) { TypeDefsByColumnOutType.TryGetValue(colType, out storageType); } if (storageType == null) { return(null); } // found storage type; try default mapping if (storageType.DefaultTypeInfo != null) { return(storageType.DefaultTypeInfo); } // create new mapping return(CreateDbTypeInfo(colType, storageType, forMember.Size, forMember.Precision, forMember.Scale)); }
public virtual void MapMany(Type[] clrTypes, DbTypeDef typeDef, long size = 0, byte prec = 0, byte scale = 0, bool overwriteAsDefault = false) { foreach (var type in clrTypes) { Map(type, typeDef, size, prec, scale); } }
public virtual string FormatTypeSpec(DbTypeDef typeDef, long size = 0, byte prec = 0, byte scale = 0) { var name = typeDef.Name; var flags = typeDef.Flags; if (!flags.IsSet(DbTypeFlags.HasArgs)) { return(name); } //Size if (flags.IsSet(DbTypeFlags.Size)) { if (size < 0) { return(name); } else { return($"{name}({size})"); } } // precision, scale - both if (flags.IsSet(DbTypeFlags.Precision) && flags.IsSet(DbTypeFlags.Scale)) { if (prec != 0 && scale != 0) { return($"{name}({prec}, {scale})"); } if (prec != 0) { return($"{name}({prec})"); } if (scale != 0) { return($"{name}({scale})"); } } // prec only if (flags.IsSet(DbTypeFlags.Precision) && prec != 0) { return($"{name}({prec})"); } // scale only if (flags.IsSet(DbTypeFlags.Scale) && scale != 0) { return($"{name}({scale})"); } // default return(name); } //method
} //method protected virtual DbTypeInfo CreateDbTypeInfo(Type clrType, DbTypeDef typeDef, long size = 0, byte prec = 0, byte scale = 0) { if (prec == 0 && typeDef.DefaultPrecision != null) { prec = typeDef.DefaultPrecision.Value; } if (scale == 0 && typeDef.DefaultScale != null) { scale = typeDef.DefaultScale.Value; } var typeSpec = FormatTypeSpec(typeDef, size, prec, scale); return(new DbTypeInfo(typeDef, clrType, typeSpec, size, prec, scale)); }
public virtual DbTypeDef AddDbTypeDef(string name, Type columnOutType, DbTypeFlags flags = DbTypeFlags.None, string specTemplate = null, string aliases = null, byte?defaultPrecision = null, byte?defaultScale = null, ToLiteralFunc toLiteral = null, string columnInit = null, bool mapColumnType = true, //map to column out type if typeDef has no args and not unlimited object providerDbType = null, //used by Postgres only DbSpecialType specialType = DbSpecialType.None) { var arrAliases = string.IsNullOrEmpty(aliases) ? _emptyStrings : aliases.Split(','); toLiteral = toLiteral ?? DbValueToLiteralConverters.GetDefaultToLiteralConverter(columnOutType); columnInit = columnInit ?? GetDefaultColumnInitExpression(columnOutType); var typeDef = new DbTypeDef() { Name = name, ColumnOutType = columnOutType, Flags = flags, Aliases = arrAliases, ToLiteral = toLiteral, ColumnInit = columnInit, DefaultPrecision = defaultPrecision, DefaultScale = defaultScale }; TypeDefsByName.Add(name, typeDef); // register under aliases foreach (var alias in typeDef.Aliases) { TypeDefsByName.Add(alias, typeDef); } if (specialType != DbSpecialType.None) { Util.Check(!SpecialTypeDefs.ContainsKey(specialType), "TypeDef for special type {0} already registered.", specialType); SpecialTypeDefs[specialType] = typeDef; } // Register by columnOutType if (!TypeDefsByColumnOutType.ContainsKey(columnOutType)) { TypeDefsByColumnOutType[columnOutType] = typeDef; } // If has a form without args, register it as default type def if (!flags.IsSet(DbTypeFlags.HasArgs)) { typeDef.DefaultTypeInfo = CreateDbTypeInfo(columnOutType, typeDef); if (mapColumnType && !flags.IsSet(DbTypeFlags.Unlimited) && !DbTypesByClrType.ContainsKey(columnOutType)) { DbTypesByClrType[columnOutType] = typeDef.DefaultTypeInfo; } } if (providerDbType != null) { typeDef.ProviderDbType = (int)providerDbType; } return(typeDef); }
public DbTypeInfo(DbTypeDef typeDef, Type clrType, string typeSpec, long size, byte prec, byte scale) { ClrType = clrType; TypeDef = typeDef; Size = size; Precision = prec; Scale = scale; DbTypeSpec = typeSpec; if (typeDef.Flags.IsSet(DbTypeFlags.Unlimited)) { Size = -1; } ColumnOutType = typeDef.ColumnOutType; ColumnReader = ReadColumnValue; }
} //method public virtual DbTypeInfo MapWithArgs(Type clrType, DbTypeDef typeDef, int[] args) { var flags = typeDef.Flags; if (flags.IsSet(DbTypeFlags.Size)) { Util.Check(args.Length == 1, "Invalid DbTypeSpec ({0}, expected size parameter."); return(CreateDbTypeInfo(clrType, typeDef, size: args[0])); } if (flags.IsSet(DbTypeFlags.Precision | DbTypeFlags.Scale)) { switch (args.Length) { case 1: return(CreateDbTypeInfo(clrType, typeDef, prec: (byte)args[0], scale: 0)); case 2: return(CreateDbTypeInfo(clrType, typeDef, prec: (byte)args[0], scale: (byte)args[1])); } } return(CreateDbTypeInfo(clrType, typeDef)); } //method