Use Type Converters for converting Scalar values

Author: mythz

src/ServiceStack.OrmLite.Sqlite/Converters/SqliteDateTimeConverter.cs

@@ -67,7 +67,14 @@ public override object GetValue(IDataReader reader, int columnIndex)
             }
             catch (Exception ex)
             {
-                var dateStr = reader.GetString(columnIndex);
+                var value = reader.GetValue(columnIndex);
+                if (value == DBNull.Value)
+                    return null;
+
+                var dateStr = value as string;
+                if (dateStr == null)
+                    throw new Exception("Converting from {0} to DateTime is not supported".Fmt(value.GetType().Name));
+
                 Log.Warn("Error reading string as DateTime in Sqlite: " + dateStr, ex);
                 return DateTime.Parse(dateStr);
             }

src/ServiceStack.OrmLite/Async/OrmLiteReadCommandExtensionsAsync.cs

@@ -239,7 +239,7 @@ internal static Task<T> ScalarFmtAsync<T>(this IDbCommand dbCmd, CancellationTok
         internal static Task<T> ScalarAsync<T>(this IDataReader reader, IOrmLiteDialectProvider dialectProvider, CancellationToken token)
         {
             return dialectProvider.ReaderRead(reader, () => 
-                OrmLiteReadCommandExtensions.ToScalar<T>(dialectProvider, reader.GetValue(0)), token);
+                OrmLiteReadCommandExtensions.ToScalar<T>(dialectProvider, reader), token);
         }
 
         public static Task<long> LongScalarAsync(this IDbCommand dbCmd, CancellationToken token)

src/ServiceStack.OrmLite/OrmLiteReadCommandExtensions.cs

@@ -37,7 +37,7 @@ internal static IDataReader ExecReader(this IDbCommand dbCmd, string sql)
         {
             dbCmd.CommandTimeout = OrmLiteConfig.CommandTimeout;
             dbCmd.CommandText = sql;
-            
+
             if (Log.IsDebugEnabled)
                 Log.DebugCommand(dbCmd);
 
@@ -274,7 +274,7 @@ internal static IDbCommand SetParameters(this IDbCommand dbCmd, object anonType,
 
         internal static IDbCommand SetParameters(this IDbCommand dbCmd, IDictionary<string, object> dict, bool excludeDefaults)
         {
-            if (dict == null) 
+            if (dict == null)
                 return dbCmd;
 
             dbCmd.Parameters.Clear();
@@ -377,17 +377,17 @@ internal static T Single<T>(this IDbCommand dbCmd, string sql, IEnumerable<IDbDa
         {
             dbCmd.SetParameters(sqlParams);
 
-            return OrmLiteUtils.IsScalar<T>() 
-                ? dbCmd.Scalar<T>(sql) 
+            return OrmLiteUtils.IsScalar<T>()
+                ? dbCmd.Scalar<T>(sql)
                 : dbCmd.ConvertTo<T>(dbCmd.GetDialectProvider().ToSelectStatement(typeof(T), sql));
         }
 
         internal static T Single<T>(this IDbCommand dbCmd, string sql, object anonType)
         {
             dbCmd.SetParameters<T>(anonType, excludeDefaults: false);
 
-            return OrmLiteUtils.IsScalar<T>() 
-                ? dbCmd.Scalar<T>(sql) 
+            return OrmLiteUtils.IsScalar<T>()
+                ? dbCmd.Scalar<T>(sql)
                 : dbCmd.ConvertTo<T>(dbCmd.GetDialectProvider().ToSelectStatement(typeof(T), sql));
         }
 
@@ -509,7 +509,7 @@ internal static List<T> SelectNonDefaults<T>(this IDbCommand dbCmd, object filte
 
         internal static List<T> SelectNonDefaults<T>(this IDbCommand dbCmd, string sql, object anonType = null)
         {
-            if (anonType != null) dbCmd.SetParameters<T>(anonType, excludeDefaults:true);
+            if (anonType != null) dbCmd.SetParameters<T>(anonType, excludeDefaults: true);
 
             return dbCmd.ConvertToList<T>(dbCmd.GetDialectProvider().ToSelectStatement(typeof(T), sql));
         }
@@ -575,7 +575,7 @@ private static IEnumerable<T> ColumnLazy<T>(this IDbCommand dbCmd, string sql)
                     if (value == DBNull.Value)
                         yield return default(T);
                     else
-                        yield return (T) value;
+                        yield return (T)value;
                 }
             }
         }
@@ -655,34 +655,38 @@ internal static T Scalar<T>(this IDataReader reader, IOrmLiteDialectProvider dia
         {
             while (reader.Read())
             {
-                object oValue = reader.GetValue(0);
-                return typeof(T) == typeof (object) 
-                    ? (T)oValue 
-                    : ToScalar<T>(dialectProvider, oValue);
+                return ToScalar<T>(dialectProvider, reader);
             }
 
             return default(T);
         }
 
-        internal static T ToScalar<T>(IOrmLiteDialectProvider dialectProvider, object oValue)
+        internal static T ToScalar<T>(IOrmLiteDialectProvider dialectProvider, IDataReader reader, int columnIndex = 0)
         {
-            if (oValue == DBNull.Value) return default(T);
+            var nullableType = Nullable.GetUnderlyingType(typeof(T));
+            if (nullableType != null)
+            {
+                object oValue = reader.GetValue(columnIndex);
+                if (oValue == DBNull.Value)
+                    return default(T);
+            }
 
-            var typeCode = typeof(T).GetUnderlyingTypeCode();
-            switch (typeCode)
+            var underlyingType = nullableType ?? typeof(T);
+            if (underlyingType == typeof(object))
+                return (T)reader.GetValue(0);
+
+            var converter = dialectProvider.GetConverter(underlyingType);
+            if (converter != null)
             {
-                case TypeCode.DateTime:
-                    return (T) (object) DateTime.Parse(oValue.ToString(), CultureInfo.CurrentCulture);
-                case TypeCode.Decimal:
-                    return (T) (object) Decimal.Parse(oValue.ToString(), CultureInfo.CurrentCulture);
-                case TypeCode.Single:
-                    return (T) (object) System.Single.Parse(oValue.ToString(), CultureInfo.CurrentCulture);
-                case TypeCode.Double:
-                    return (T) (object) Double.Parse(oValue.ToString(), CultureInfo.CurrentCulture);
+                object oValue = converter.GetValue(reader, columnIndex);
+                if (oValue == null || oValue == DBNull.Value)
+                    return default(T);
+
+                var convertedValue = converter.FromDbValue(underlyingType, oValue);
+                return convertedValue == null ? default(T) : (T)convertedValue;
             }
 
-            object o = dialectProvider.FromDbValue(oValue, typeof(T));
-            return o == null ? default(T) : (T) o;
+            return (T)reader.GetValue(0);
         }
 
         internal static long LastInsertId(this IDbCommand dbCmd)
@@ -863,10 +867,10 @@ public static long LongScalar(this IDbCommand dbCmd)
         internal static long ToLong(object result)
         {
             if (result is DBNull) return default(long);
-            if (result is int) return (int) result;
-            if (result is decimal) return Convert.ToInt64((decimal) result);
-            if (result is ulong) return (long) Convert.ToUInt64(result);
-            return (long) result;
+            if (result is int) return (int)result;
+            if (result is decimal) return Convert.ToInt64((decimal)result);
+            if (result is ulong) return (long)Convert.ToUInt64(result);
+            return (long)result;
         }
 
         internal static T LoadSingleById<T>(this IDbCommand dbCmd, object value)
@@ -941,8 +945,8 @@ public static FieldDefinition GetRefFieldDef(this ModelDefinition modelDef, Mode
 
         public static FieldDefinition GetRefFieldDefIfExists(this ModelDefinition modelDef, ModelDefinition refModelDef)
         {
-            var refField = 
-                   refModelDef.FieldDefinitions.FirstOrDefault(x => x.ForeignKey != null && x.ForeignKey.ReferenceType == modelDef.ModelType 
+            var refField =
+                   refModelDef.FieldDefinitions.FirstOrDefault(x => x.ForeignKey != null && x.ForeignKey.ReferenceType == modelDef.ModelType
                        && modelDef.IsRefField(x))
                 ?? refModelDef.FieldDefinitions.FirstOrDefault(x => x.ForeignKey != null && x.ForeignKey.ReferenceType == modelDef.ModelType)
                 ?? refModelDef.FieldDefinitions.FirstOrDefault(modelDef.IsRefField);
@@ -976,7 +980,7 @@ public static IDbDataParameter CreateParam(this IDbCommand dbCmd,
             string name,
             object value = null,
             ParameterDirection direction = ParameterDirection.Input,
-            DbType? dbType=null)
+            DbType? dbType = null)
         {
             var p = dbCmd.CreateParameter();
             var dialectProvider = dbCmd.GetDialectProvider();

tests/ServiceStack.OrmLite.Tests/Issues/SelectScalarTests.cs

@@ -0,0 +1,45 @@
+using System;
+using NUnit.Framework;
+
+namespace ServiceStack.OrmLite.Tests.Issues
+{
+    [TestFixture]
+    public class SelectScalarTests : OrmLiteTestBase
+    {
+        public class TestPerson
+        {
+            public Guid Id { get; set; }
+            public long Long { get; set; }
+            public float Float { get; set; }
+            public double Double { get; set; }
+            public decimal Decimal { get; set; }
+        }
+
+        [Test]
+        public void Should_Return_Scalar_Value()
+        {
+            using (var db = OpenDbConnection())
+            {
+                db.DropAndCreateTable<TestPerson>();
+
+                var row = new TestPerson
+                {
+                    Id = Guid.NewGuid(),
+                    Long = 1,
+                    Decimal = 1.1M,
+                    Double = 1.1,
+                    Float = 1.1f,
+                };
+                db.Insert(row);
+
+                var q = db.From<TestPerson>().Where(x => x.Id == row.Id);
+
+                Assert.That(db.Scalar<Guid>(q.Select(x => x.Id)), Is.EqualTo(row.Id));
+                Assert.That(db.Scalar<long>(q.Select(x => x.Long)), Is.EqualTo(row.Long));
+                Assert.That(db.Scalar<decimal>(q.Select(x => x.Decimal)), Is.EqualTo(row.Decimal));
+                Assert.That(db.Scalar<double>(q.Select(x => x.Double)), Is.EqualTo(row.Double));
+                Assert.That(db.Scalar<float>(q.Select(x => x.Float)), Is.EqualTo(row.Float));
+            }
+        }
+    }
+}

tests/ServiceStack.OrmLite.Tests/OrmLiteGetScalarTests.cs

@@ -71,7 +71,7 @@ public void Can_get_scalar_value()
                 r2 = db.Scalar<Author, DateTime?>(
                     e => Sql.Max(e.LastActivity),
                     e => e.City == "Bogota");
-                Assert.That(expectedNullableDate, Is.EqualTo(r2));
+                Assert.That(r2, Is.EqualTo(expectedNullableDate));
 
                 r2 = db.Scalar<Author, DateTime?>(e => Sql.Max(e.LastActivity), e => e.City == "SinCity");
                 Assert.That(default(DateTime?), Is.EqualTo(r2));

tests/ServiceStack.OrmLite.Tests/ServiceStack.OrmLite.Tests.csproj

@@ -143,6 +143,7 @@
     <Compile Include="Issues\LoadReferencesCaseSensitiveTest.cs" />
     <Compile Include="Issues\LoadSelectIssue.cs" />
     <Compile Include="Issues\MultipleSelfJoinsWithNullableInts.cs" />
+    <Compile Include="Issues\SelectScalarTests.cs" />
     <Compile Include="Issues\UtcDateTimeIssueTests.cs" />
     <Compile Include="Issues\JoinsWithSchemas.cs" />
     <Compile Include="Issues\MappingFieldsFromStoredProcedureTests.cs" />