public static object ConvertNumber(this IOrmLiteConverter converter, Type toIntegerType, object value)
{
if (value.GetType() == toIntegerType)
{
return(value);
}
var typeCode = toIntegerType.GetUnderlyingTypeCode();
switch (typeCode)
{
case TypeCode.Byte:
return(Convert.ToByte(value));
case TypeCode.Int16:
return(Convert.ToInt16(value));
case TypeCode.UInt16:
return(Convert.ToUInt16(value));
case TypeCode.Int32:
return(Convert.ToInt32(value));
case TypeCode.UInt32:
return(Convert.ToUInt32(value));
case TypeCode.Int64:
return(Convert.ToInt64(value));
case TypeCode.UInt64:
var byteValue = value as byte[];
if (byteValue != null)
{
return(OrmLiteUtils.ConvertToULong(byteValue));
}
return(Convert.ToUInt64(value));
case TypeCode.Single:
return(Convert.ToSingle(value));
case TypeCode.Double:
return(Convert.ToDouble(value));
case TypeCode.Decimal:
return(Convert.ToDecimal(value));
}
var convertedValue = converter.DialectProvider.StringSerializer.DeserializeFromString(value.ToString(), toIntegerType);
return(convertedValue);
}
public static string ToArray <T>(this IOrmLiteConverter converter, T[] source)
{
var values = StringBuilderCache.Allocate();
foreach (var value in source)
{
if (values.Length > 0)
{
values.Append(",");
}
values.Append(converter.DialectProvider.GetQuotedValue(value, typeof(T)));
}
return("ARRAY[" + StringBuilderCache.ReturnAndFree(values) + "]");
}
public override string GetQuotedValue(object value, Type fieldType)
{
if (value == null)
{
return("NULL");
}
IOrmLiteConverter converter = null;
try
{
var isEnum = fieldType.IsEnum || value.GetType().IsEnum;
if (isEnum)
{
return(EnumConverter.ToQuotedString(fieldType, value));
}
if (Converters.TryGetValue(fieldType, out converter))
{
return(converter.ToQuotedString(fieldType, value));
}
if (fieldType.IsRefType())
{
return(ReferenceTypeConverter.ToQuotedString(fieldType, value));
}
if (fieldType.IsValueType())
{
return(ValueTypeConverter.ToQuotedString(fieldType, value));
}
}
catch (Exception ex)
{
Log.Error("Error in {0}.ToQuotedString() value '{0}' and Type '{1}'"
.Fmt(converter.GetType().Name, value != null ? value.GetType().Name : "undefined", fieldType.Name), ex);
throw;
}
return(ShouldQuoteValue(fieldType)
? GetQuotedValue(value.ToString())
: value.ToString());
}
/// <summary>
/// based on Npgsql2's source: Npgsql2\src\NpgsqlTypes\NpgsqlTypeConverters.cs
/// </summary>
public static string ToBinary(this IOrmLiteConverter converter, object NativeData)
{
var byteArray = (byte[])NativeData;
var res = StringBuilderCache.Allocate();
foreach (byte b in byteArray)
{
if (b >= 0x20 && b < 0x7F && b != 0x27 && b != 0x5C)
{
res.Append((char)b);
}
else
{
res.Append("\\\\")
.Append((char)('0' + (7 & (b >> 6))))
.Append((char)('0' + (7 & (b >> 3))))
.Append((char)('0' + (7 & b)));
}
}
return(StringBuilderCache.ReturnAndFree(res));
}
/// <summary>
/// based on Npgsql2's source: Npgsql2\src\NpgsqlTypes\NpgsqlTypeConverters.cs
/// </summary>
public static string ToBinary(this IOrmLiteConverter converter, object NativeData)
{
var byteArray = (byte[])NativeData;
var res = new StringBuilder(byteArray.Length * 5);
foreach (byte b in byteArray)
{
if (b >= 0x20 && b < 0x7F && b != 0x27 && b != 0x5C)
{
res.Append((char)b);
}
else
{
res.Append("\\\\")
.Append((char)('0' + (7 & (b >> 6))))
.Append((char)('0' + (7 & (b >> 3))))
.Append((char)('0' + (7 & b)));
}
}
return(res.ToString());
}
protected override void Load(ContainerBuilder builder)
{
builder
.RegisterAssemblyTypes(GetType().Assembly)
.WithPublicConstructors()
.AsDefaultInterface()
.AsSelf();
builder.RegisterType <FileSystem>().As <IFileSystem>();
builder.Register(_ => SystemClock.Instance).As <IClock>();
builder.RegisterType <MemoryCacheClient>().As <ICacheClient>().SingleInstance();
string connectionString = _configuration.GetConnectionString("DefaultConnection");
builder.Register(_ =>
{
string dbType = _configuration.GetValue("DbType", "Sqlite");
OrmLiteConnectionFactory connectionFactory = new(
connectionString,
dbType switch
{
"SQLServer" => SqlServer2019OrmLiteDialectProvider.Instance,
"MySQL" => MySqlConnectorDialectProvider.Instance,
"PostgreSQL" => PostgreSqlDialectProvider.Instance,
"Sqlite" => SqliteOrmLiteDialectProvider.Instance,
_ => throw new ArgumentOutOfRangeException(nameof(dbType), "The database type is not supported")
});
IOrmLiteConverter dateTimeConverter = connectionFactory.DialectProvider.GetConverter <DateTime>();
connectionFactory.DialectProvider.RegisterConverter <Instant>(new InstantConverter(dateTimeConverter));
if (connectionFactory.DialectProvider == SqliteOrmLiteDialectProvider.Instance)
{
connectionFactory.ConnectionString =
connectionFactory.ConnectionString.Replace("Data Source=", string.Empty);
}
return(connectionFactory);
})
public override object ToDbValue(object value, Type type)
{
if (value == null || value is DBNull)
{
return(null);
}
if (type.IsEnum && !type.HasAttribute <EnumAsIntAttribute>())
{
return(EnumConverter.ToDbValue(type, value));
}
if (type.IsRefType())
{
return(ReferenceTypeConverter.ToDbValue(type, value));
}
IOrmLiteConverter converter = null;
try
{
if (Converters.TryGetValue(type, out converter))
{
if (type == typeof(DateTimeOffset))
{
return(converter.ToQuotedString(type, value));
}
return(converter.ToDbValue(type, value));
}
}
catch (Exception ex)
{
Log.Error("Error in {0}.ToDbValue() value '{1}' and Type '{2}'"
.Fmt(converter.GetType().Name, value != null ? value.GetType().Name : "undefined", type.Name), ex);
throw;
}
return(base.ToDbValue(value, type));
}
public static object ConvertNumber(this IOrmLiteConverter converter, Type toIntegerType, object value)
{
return(converter.DialectProvider.ConvertNumber(toIntegerType, value));
}
public InstantConverter(IOrmLiteConverter dateTimeConverter)
{
_dateTimeConverter = dateTimeConverter;
}
