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
