Rewrite PopulateWithSqlReader to better utilize field cache and reader.GetValues() for improved perf

mythz · mythz · commit fa188dc7b240 · 2015-11-27T16:28:20.000-08:00
diff --git a/src/ServiceStack.OrmLite/Async/OrmLiteUtilExtensionsAsync.cs b/src/ServiceStack.OrmLite/Async/OrmLiteUtilExtensionsAsync.cs
@@ -18,93 +18,91 @@ public static T CreateInstance<T>()
             return (T)ReflectionExtensions.CreateInstance<T>();
         }
 
-        public static Task<T> ConvertToAsync<T>(this IDataReader dataReader, IOrmLiteDialectProvider dialectProvider, CancellationToken token)
+        public static Task<T> ConvertToAsync<T>(this IDataReader reader, IOrmLiteDialectProvider dialectProvider, CancellationToken token)
         {
-            var fieldDefs = ModelDefinition<T>.Definition.AllFieldDefinitionsArray;
-            return dialectProvider.ReaderRead(dataReader, () =>
+            var indexCache = reader.GetIndexFieldsCache(ModelDefinition<T>.Definition, dialectProvider);
+            var values = new object[reader.FieldCount];
+            return dialectProvider.ReaderRead(reader, () =>
             {
                 var row = CreateInstance<T>();
-                var indexCache = dataReader.GetIndexFieldsCache(ModelDefinition<T>.Definition);
-                row.PopulateWithSqlReader(dialectProvider, dataReader, fieldDefs, indexCache);
+                row.PopulateWithSqlReader(dialectProvider, reader, indexCache, values);
                 return row;
             }, token).Then(t => { 
-                dataReader.Dispose();
+                reader.Dispose();
                 return t;
             });
         }
 
-        public static Task<List<T>> ConvertToListAsync<T>(this IDataReader dataReader, IOrmLiteDialectProvider dialectProvider, CancellationToken token)
+        public static Task<List<T>> ConvertToListAsync<T>(this IDataReader reader, IOrmLiteDialectProvider dialectProvider, CancellationToken token)
         {
-            var fieldDefs = ModelDefinition<T>.Definition.AllFieldDefinitionsArray;
-            var indexCache = dataReader.GetIndexFieldsCache(ModelDefinition<T>.Definition);
+            var indexCache = reader.GetIndexFieldsCache(ModelDefinition<T>.Definition, dialectProvider);
+            var values = new object[reader.FieldCount];
             var isObjectList = typeof(T) == typeof(List<object>);
             var isObjectDict = typeof(T) == typeof(Dictionary<string,object>);
 
-            return dialectProvider.ReaderEach(dataReader, () =>
+            return dialectProvider.ReaderEach(reader, () =>
             {
                 if (isObjectList)
                 {
                     var row = new List<object>();
-                    for (var i = 0; i < dataReader.FieldCount; i++)
+                    for (var i = 0; i < reader.FieldCount; i++)
                     {
-                        row.Add(dataReader.GetValue(i));
+                        row.Add(reader.GetValue(i));
                     }
                     return (T)(object)row;
                 }
                 else if (isObjectDict)
                 {
                     var row = new Dictionary<string,object>();
-                    for (var i = 0; i < dataReader.FieldCount; i++)
+                    for (var i = 0; i < reader.FieldCount; i++)
                     {
-                        row[dataReader.GetName(i).Trim()] = dataReader.GetValue(i);
+                        row[reader.GetName(i).Trim()] = reader.GetValue(i);
                     }
                     return (T)(object)row;
                 }
                 else
                 {
                     var row = CreateInstance<T>();
-                    row.PopulateWithSqlReader(dialectProvider, dataReader, fieldDefs, indexCache);
+                    row.PopulateWithSqlReader(dialectProvider, reader, indexCache, values);
                     return row;
                 }
             }, token).Then(t => {
-                dataReader.Dispose();
+                reader.Dispose();
                 return t;
             });
         }
 
-        public static Task<object> ConvertToAsync(this IDataReader dataReader, IOrmLiteDialectProvider dialectProvider, Type type, CancellationToken token)
+        public static Task<object> ConvertToAsync(this IDataReader reader, IOrmLiteDialectProvider dialectProvider, Type type, CancellationToken token)
         {
             var modelDef = type.GetModelDefinition();
-            var fieldDefs = modelDef.AllFieldDefinitionsArray;
-
-            return dialectProvider.ReaderRead(dataReader, () =>
+            var indexCache = reader.GetIndexFieldsCache(modelDef, dialectProvider);
+            var values = new object[reader.FieldCount];
+            return dialectProvider.ReaderRead(reader, () =>
             {
                 var row = type.CreateInstance();
-                var indexCache = dataReader.GetIndexFieldsCache(modelDef);
-                row.PopulateWithSqlReader(dialectProvider, dataReader, fieldDefs, indexCache);
+                row.PopulateWithSqlReader(dialectProvider, reader, indexCache, values);
                 return row;
             }, token).Then(t =>
             {
-                dataReader.Dispose();
+                reader.Dispose();
                 return t;
             });
         }
 
-        public static Task<IList> ConvertToListAsync(this IDataReader dataReader, IOrmLiteDialectProvider dialectProvider, Type type, CancellationToken token)
+        public static Task<IList> ConvertToListAsync(this IDataReader reader, IOrmLiteDialectProvider dialectProvider, Type type, CancellationToken token)
         {
             var modelDef = type.GetModelDefinition();
-            var fieldDefs = modelDef.AllFieldDefinitionsArray;
-
-            var indexCache = dataReader.GetIndexFieldsCache(modelDef);
-            return dialectProvider.ReaderEach(dataReader, () =>
+            var indexCache = reader.GetIndexFieldsCache(modelDef, dialectProvider);
+            var values = new object[reader.FieldCount];
+            return dialectProvider.ReaderEach(reader, () =>
             {
                 var row = type.CreateInstance();
-                row.PopulateWithSqlReader(dialectProvider, dataReader, fieldDefs, indexCache);
+                row.PopulateWithSqlReader(dialectProvider, reader, indexCache, values);
                 return row;
             }, token)
             .Then(x =>
             {
-                dataReader.Dispose();
+                reader.Dispose();
                 var to = (IList)typeof(List<>).MakeGenericType(type).CreateInstance();
                 x.Each(o => to.Add(o));
                 return to;
diff --git a/src/ServiceStack.OrmLite/Async/ReadExpressionCommandExtensionsAsync.cs b/src/ServiceStack.OrmLite/Async/ReadExpressionCommandExtensionsAsync.cs
@@ -158,16 +158,15 @@ internal static Task<T> ExprConvertToAsync<T>(this IDataReader dataReader, IOrmL
                 () => dataReader.ConvertTo<T>(dialectProvider), token);
         }
 
-        internal static Task<List<T>> ExprConvertToListAsync<T>(this IDataReader dataReader, IOrmLiteDialectProvider dialectProvider, CancellationToken token)
+        internal static Task<List<T>> ExprConvertToListAsync<T>(this IDataReader reader, IOrmLiteDialectProvider dialectProvider, CancellationToken token)
         {
-            var fieldDefs = ModelDefinition<T>.Definition.AllFieldDefinitionsArray;
+            var indexCache = reader.GetIndexFieldsCache(ModelDefinition<T>.Definition, dialectProvider);
+            var values = new object[reader.FieldCount];
 
-            var indexCache = dataReader.GetIndexFieldsCache(ModelDefinition<T>.Definition);
-
-            return dialectProvider.ReaderEach(dataReader, () =>
+            return dialectProvider.ReaderEach(reader, () =>
             {
                 var row = OrmLiteUtils.CreateInstance<T>();
-                row.PopulateWithSqlReader(dialectProvider, dataReader, fieldDefs, indexCache);
+                row.PopulateWithSqlReader(dialectProvider, reader, indexCache, values);
                 return row;
             }, token);
         }
diff --git a/src/ServiceStack.OrmLite/IOrmLiteDialectProvider.cs b/src/ServiceStack.OrmLite/IOrmLiteDialectProvider.cs
@@ -36,6 +36,8 @@ public interface IOrmLiteDialectProvider
         /// </summary>
         IOrmLiteConverter GetConverterBestMatch(Type type);
 
+        IOrmLiteConverter GetConverterBestMatch(FieldDefinition fieldDef);
+
         string ParamString { get; set; }
 
         [Obsolete("Use GetStringConverter().UseUnicode")]
@@ -62,8 +64,6 @@ public interface IOrmLiteDialectProvider
 
         object GetParamValue(object value, Type fieldType);
 
-        void SetDbValue(FieldDefinition fieldDef, IDataReader reader, int colIndex, object instance);
-
         object ToDbValue(object value, Type type);
 
         object FromDbValue(object value, Type type);
diff --git a/src/ServiceStack.OrmLite/ModelDefinition.cs b/src/ServiceStack.OrmLite/ModelDefinition.cs
@@ -122,6 +122,11 @@ public FieldDefinition GetFieldDefinition<T>(Expression<Func<T, object>> field)
             return FieldDefinitions.First(f => f.Name == fn);
         }
 
+        public FieldDefinition GetFieldDefinition(string fieldName)
+        {
+            return FieldDefinitions.FirstOrDefault(f => f.Name == fieldName);
+        }
+
         string GetFieldName<T>(Expression<Func<T, object>> field)
         {
 
diff --git a/src/ServiceStack.OrmLite/OrmLiteDialectProviderBase.cs b/src/ServiceStack.OrmLite/OrmLiteDialectProviderBase.cs
@@ -295,47 +295,19 @@ public virtual ulong FromDbRowVersion(object value)
             return RowVersionConverter.FromDbRowVersion(value);
         }
 
-        /// <summary>
-        /// Populates row fields during re-hydration of results.
-        /// </summary>
-        public virtual void SetDbValue(FieldDefinition fieldDef, IDataReader reader, int colIndex, object instance)
+        public virtual IOrmLiteConverter GetConverterBestMatch(FieldDefinition fieldDef)
         {
-            if (OrmLiteUtils.HandledDbNullValue(fieldDef, reader, colIndex, instance)) return;
-
             var fieldType = Nullable.GetUnderlyingType(fieldDef.FieldType) ?? fieldDef.FieldType;
+            if (fieldDef.IsRowVersion)
+                return RowVersionConverter;
 
-            IOrmLiteConverter converter = null;
-            object value = null;
-            try
-            {
-                if (fieldDef.IsRowVersion)
-                {
-                    converter = RowVersionConverter;
-                    value = converter.FromDbValue(fieldDef.FieldType, converter.GetValue(reader, colIndex));
-                    if (value != null)
-                        fieldDef.SetValueFn(instance, value);
-                    return;
-                }
-
-                if (Converters.TryGetValue(fieldType, out converter))
-                {
-                    value = converter.FromDbValue(fieldDef.FieldType, converter.GetValue(reader, colIndex));
-                    fieldDef.SetValueFn(instance, value);
-                    return;
-                }
+            IOrmLiteConverter converter;
+            if (Converters.TryGetValue(fieldType, out converter))
+                return converter;
 
-                converter = fieldType.IsRefType()
-                    ? (IOrmLiteConverter)ReferenceTypeConverter
-                    : ValueTypeConverter;
-                value = converter.FromDbValue(fieldDef.FieldType, converter.GetValue(reader, colIndex));
-                fieldDef.SetValueFn(instance, value);
-            }
-            catch (Exception ex)
-            {
-                Log.Error("Error in {0}.FromDbValue() on field '{1}' converting from '{2}' to '{3}'"
-                    .Fmt(converter.GetType().Name, fieldDef.Name, value != null ? value.GetType().Name : "undefined", fieldDef.FieldType.Name), ex);
-                throw;
-            }
+            return fieldType.IsRefType()
+                ? (IOrmLiteConverter)ReferenceTypeConverter
+                : ValueTypeConverter;
         }
 
         public virtual object ToDbValue(object value, Type type)
@@ -408,7 +380,7 @@ public object GetValue(IDataReader reader, int columnIndex, Type type)
         {
             IOrmLiteConverter converter;
             if (Converters.TryGetValue(type, out converter))
-                return converter.GetValue(reader, columnIndex);
+                return converter.GetValue(reader, columnIndex, null);
 
             return reader.GetValue(columnIndex);
         }
diff --git a/src/ServiceStack.OrmLite/OrmLiteReadCommandExtensions.cs b/src/ServiceStack.OrmLite/OrmLiteReadCommandExtensions.cs
@@ -535,14 +535,14 @@ internal static IEnumerable<T> SelectLazy<T>(this IDbCommand dbCmd, string sql,
                 yield break;
             }
 
-            var fieldDefs = ModelDefinition<T>.Definition.FieldDefinitionsArray;
             using (var reader = dbCmd.ExecuteReader())
             {
-                var indexCache = reader.GetIndexFieldsCache(ModelDefinition<T>.Definition);
+                var indexCache = reader.GetIndexFieldsCache(ModelDefinition<T>.Definition, dialectProvider);
+                var values = new object[reader.FieldCount];
                 while (reader.Read())
                 {
                     var row = OrmLiteUtils.CreateInstance<T>();
-                    row.PopulateWithSqlReader(dialectProvider, reader, fieldDefs, indexCache);
+                    row.PopulateWithSqlReader(dialectProvider, reader, indexCache, values);
                     yield return row;
                 }
             }
@@ -598,15 +598,15 @@ internal static IEnumerable<T> WhereLazy<T>(this IDbCommand dbCmd, object anonTy
                 yield break;
             }
 
-            var fieldDefs = ModelDefinition<T>.Definition.FieldDefinitionsArray;
             var dialectProvider = dbCmd.GetDialectProvider();
             using (var reader = dbCmd.ExecuteReader())
             {
-                var indexCache = reader.GetIndexFieldsCache(ModelDefinition<T>.Definition);
+                var indexCache = reader.GetIndexFieldsCache(ModelDefinition<T>.Definition, dialectProvider);
+                var values = new object[reader.FieldCount];
                 while (reader.Read())
                 {
                     var row = OrmLiteUtils.CreateInstance<T>();
-                    row.PopulateWithSqlReader(dialectProvider, reader, fieldDefs, indexCache);
+                    row.PopulateWithSqlReader(dialectProvider, reader, indexCache, values);
                     yield return row;
                 }
             }
@@ -631,14 +631,14 @@ internal static IEnumerable<T> SelectLazyFmt<T>(this IDbCommand dbCmd, string fi
                 yield break;
             }
 
-            var fieldDefs = ModelDefinition<T>.Definition.FieldDefinitionsArray;
             using (var reader = dbCmd.ExecReader(dbCmd.CommandText))
             {
-                var indexCache = reader.GetIndexFieldsCache(ModelDefinition<T>.Definition);
+                var indexCache = reader.GetIndexFieldsCache(ModelDefinition<T>.Definition, dialectProvider);
+                var values = new object[reader.FieldCount];
                 while (reader.Read())
                 {
                     var row = OrmLiteUtils.CreateInstance<T>();
-                    row.PopulateWithSqlReader(dialectProvider, reader, fieldDefs, indexCache);
+                    row.PopulateWithSqlReader(dialectProvider, reader, indexCache, values);
                     yield return row;
                 }
             }
@@ -683,8 +683,8 @@ internal static T ToScalar<T>(IOrmLiteDialectProvider dialectProvider, IDataRead
             var converter = dialectProvider.GetConverterBestMatch(underlyingType);
             if (converter != null)
             {
-                object oValue = converter.GetValue(reader, columnIndex);
-                if (oValue == null || oValue == DBNull.Value)
+                object oValue = converter.GetValue(reader, columnIndex, null);
+                if (oValue == null)
                     return default(T);
 
                 var convertedValue = converter.FromDbValue(underlyingType, oValue);
diff --git a/src/ServiceStack.OrmLite/OrmLiteUtils.cs b/src/ServiceStack.OrmLite/OrmLiteUtils.cs
diff --git a/src/ServiceStack.OrmLite/OrmLiteWriteCommandExtensions.cs b/src/ServiceStack.OrmLite/OrmLiteWriteCommandExtensions.cs

Original file line number	Diff line number	Diff line change
`@@ -18,93 +18,91 @@ public static T CreateInstance<T>()`
`18`	`18`	`return (T)ReflectionExtensions.CreateInstance<T>();`
`19`	`19`	`}`
`20`	`20`
`21`		`- public static Task<T> ConvertToAsync<T>(this IDataReader dataReader, IOrmLiteDialectProvider dialectProvider, CancellationToken token)`
	`21`	`+ public static Task<T> ConvertToAsync<T>(this IDataReader reader, IOrmLiteDialectProvider dialectProvider, CancellationToken token)`
`22`	`22`	`{`
`23`		`- var fieldDefs = ModelDefinition<T>.Definition.AllFieldDefinitionsArray;`
`24`		`- return dialectProvider.ReaderRead(dataReader, () =>`
	`23`	`+ var indexCache = reader.GetIndexFieldsCache(ModelDefinition<T>.Definition, dialectProvider);`
	`24`	`+ var values = new object[reader.FieldCount];`
	`25`	`+ return dialectProvider.ReaderRead(reader, () =>`
`25`	`26`	`{`
`26`	`27`	`var row = CreateInstance<T>();`
`27`		`- var indexCache = dataReader.GetIndexFieldsCache(ModelDefinition<T>.Definition);`
`28`		`- row.PopulateWithSqlReader(dialectProvider, dataReader, fieldDefs, indexCache);`
	`28`	`+ row.PopulateWithSqlReader(dialectProvider, reader, indexCache, values);`
`29`	`29`	`return row;`
`30`	`30`	`}, token).Then(t => {`
`31`		`- dataReader.Dispose();`
	`31`	`+ reader.Dispose();`
`32`	`32`	`return t;`
`33`	`33`	`});`
`34`	`34`	`}`
`35`	`35`
`36`		`- public static Task<List<T>> ConvertToListAsync<T>(this IDataReader dataReader, IOrmLiteDialectProvider dialectProvider, CancellationToken token)`
	`36`	`+ public static Task<List<T>> ConvertToListAsync<T>(this IDataReader reader, IOrmLiteDialectProvider dialectProvider, CancellationToken token)`
`37`	`37`	`{`
`38`		`- var fieldDefs = ModelDefinition<T>.Definition.AllFieldDefinitionsArray;`
`39`		`- var indexCache = dataReader.GetIndexFieldsCache(ModelDefinition<T>.Definition);`
	`38`	`+ var indexCache = reader.GetIndexFieldsCache(ModelDefinition<T>.Definition, dialectProvider);`
	`39`	`+ var values = new object[reader.FieldCount];`
`40`	`40`	`var isObjectList = typeof(T) == typeof(List<object>);`
`41`	`41`	`var isObjectDict = typeof(T) == typeof(Dictionary<string,object>);`
`42`	`42`
`43`		`- return dialectProvider.ReaderEach(dataReader, () =>`
	`43`	`+ return dialectProvider.ReaderEach(reader, () =>`
`44`	`44`	`{`
`45`	`45`	`if (isObjectList)`
`46`	`46`	`{`
`47`	`47`	`var row = new List<object>();`
`48`		`- for (var i = 0; i < dataReader.FieldCount; i++)`
	`48`	`+ for (var i = 0; i < reader.FieldCount; i++)`
`49`	`49`	`{`
`50`		`- row.Add(dataReader.GetValue(i));`
	`50`	`+ row.Add(reader.GetValue(i));`
`51`	`51`	`}`
`52`	`52`	`return (T)(object)row;`
`53`	`53`	`}`
`54`	`54`	`else if (isObjectDict)`
`55`	`55`	`{`
`56`	`56`	`var row = new Dictionary<string,object>();`
`57`		`- for (var i = 0; i < dataReader.FieldCount; i++)`
	`57`	`+ for (var i = 0; i < reader.FieldCount; i++)`
`58`	`58`	`{`
`59`		`- row[dataReader.GetName(i).Trim()] = dataReader.GetValue(i);`
	`59`	`+ row[reader.GetName(i).Trim()] = reader.GetValue(i);`
`60`	`60`	`}`
`61`	`61`	`return (T)(object)row;`
`62`	`62`	`}`
`63`	`63`	`else`
`64`	`64`	`{`
`65`	`65`	`var row = CreateInstance<T>();`
`66`		`- row.PopulateWithSqlReader(dialectProvider, dataReader, fieldDefs, indexCache);`
	`66`	`+ row.PopulateWithSqlReader(dialectProvider, reader, indexCache, values);`
`67`	`67`	`return row;`
`68`	`68`	`}`
`69`	`69`	`}, token).Then(t => {`
`70`		`- dataReader.Dispose();`
	`70`	`+ reader.Dispose();`
`71`	`71`	`return t;`
`72`	`72`	`});`
`73`	`73`	`}`
`74`	`74`
`75`		`- public static Task<object> ConvertToAsync(this IDataReader dataReader, IOrmLiteDialectProvider dialectProvider, Type type, CancellationToken token)`
	`75`	`+ public static Task<object> ConvertToAsync(this IDataReader reader, IOrmLiteDialectProvider dialectProvider, Type type, CancellationToken token)`
`76`	`76`	`{`
`77`	`77`	`var modelDef = type.GetModelDefinition();`
`78`		`- var fieldDefs = modelDef.AllFieldDefinitionsArray;`
`79`		`-`
`80`		`- return dialectProvider.ReaderRead(dataReader, () =>`
	`78`	`+ var indexCache = reader.GetIndexFieldsCache(modelDef, dialectProvider);`
	`79`	`+ var values = new object[reader.FieldCount];`
	`80`	`+ return dialectProvider.ReaderRead(reader, () =>`
`81`	`81`	`{`
`82`	`82`	`var row = type.CreateInstance();`
`83`		`- var indexCache = dataReader.GetIndexFieldsCache(modelDef);`
`84`		`- row.PopulateWithSqlReader(dialectProvider, dataReader, fieldDefs, indexCache);`
	`83`	`+ row.PopulateWithSqlReader(dialectProvider, reader, indexCache, values);`
`85`	`84`	`return row;`
`86`	`85`	`}, token).Then(t =>`
`87`	`86`	`{`
`88`		`- dataReader.Dispose();`
	`87`	`+ reader.Dispose();`
`89`	`88`	`return t;`
`90`	`89`	`});`
`91`	`90`	`}`
`92`	`91`
`93`		`- public static Task<IList> ConvertToListAsync(this IDataReader dataReader, IOrmLiteDialectProvider dialectProvider, Type type, CancellationToken token)`
	`92`	`+ public static Task<IList> ConvertToListAsync(this IDataReader reader, IOrmLiteDialectProvider dialectProvider, Type type, CancellationToken token)`
`94`	`93`	`{`
`95`	`94`	`var modelDef = type.GetModelDefinition();`
`96`		`- var fieldDefs = modelDef.AllFieldDefinitionsArray;`
`97`		`-`
`98`		`- var indexCache = dataReader.GetIndexFieldsCache(modelDef);`
`99`		`- return dialectProvider.ReaderEach(dataReader, () =>`
	`95`	`+ var indexCache = reader.GetIndexFieldsCache(modelDef, dialectProvider);`
	`96`	`+ var values = new object[reader.FieldCount];`
	`97`	`+ return dialectProvider.ReaderEach(reader, () =>`
`100`	`98`	`{`
`101`	`99`	`var row = type.CreateInstance();`
`102`		`- row.PopulateWithSqlReader(dialectProvider, dataReader, fieldDefs, indexCache);`
	`100`	`+ row.PopulateWithSqlReader(dialectProvider, reader, indexCache, values);`
`103`	`101`	`return row;`
`104`	`102`	`}, token)`
`105`	`103`	`.Then(x =>`
`106`	`104`	`{`
`107`		`- dataReader.Dispose();`
	`105`	`+ reader.Dispose();`
`108`	`106`	`var to = (IList)typeof(List<>).MakeGenericType(type).CreateInstance();`
`109`	`107`	`x.Each(o => to.Add(o));`
`110`	`108`	`return to;`
Original file line number	Diff line number	Diff line change
`@@ -158,16 +158,15 @@ internal static Task<T> ExprConvertToAsync<T>(this IDataReader dataReader, IOrmL`
`158`	`158`	`() => dataReader.ConvertTo<T>(dialectProvider), token);`
`159`	`159`	`}`
`160`	`160`
`161`		`- internal static Task<List<T>> ExprConvertToListAsync<T>(this IDataReader dataReader, IOrmLiteDialectProvider dialectProvider, CancellationToken token)`
	`161`	`+ internal static Task<List<T>> ExprConvertToListAsync<T>(this IDataReader reader, IOrmLiteDialectProvider dialectProvider, CancellationToken token)`
`162`	`162`	`{`
`163`		`- var fieldDefs = ModelDefinition<T>.Definition.AllFieldDefinitionsArray;`
	`163`	`+ var indexCache = reader.GetIndexFieldsCache(ModelDefinition<T>.Definition, dialectProvider);`
	`164`	`+ var values = new object[reader.FieldCount];`
`164`	`165`
`165`		`- var indexCache = dataReader.GetIndexFieldsCache(ModelDefinition<T>.Definition);`
`166`		`-`
`167`		`- return dialectProvider.ReaderEach(dataReader, () =>`
	`166`	`+ return dialectProvider.ReaderEach(reader, () =>`
`168`	`167`	`{`
`169`	`168`	`var row = OrmLiteUtils.CreateInstance<T>();`
`170`		`- row.PopulateWithSqlReader(dialectProvider, dataReader, fieldDefs, indexCache);`
	`169`	`+ row.PopulateWithSqlReader(dialectProvider, reader, indexCache, values);`
`171`	`170`	`return row;`
`172`	`171`	`}, token);`
`173`	`172`	`}`
Original file line number	Diff line number	Diff line change
`@@ -122,6 +122,11 @@ public FieldDefinition GetFieldDefinition<T>(Expression<Func<T, object>> field)`
`122`	`122`	`return FieldDefinitions.First(f => f.Name == fn);`
`123`	`123`	`}`
`124`	`124`
	`125`	`+ public FieldDefinition GetFieldDefinition(string fieldName)`
	`126`	`+ {`
	`127`	`+ return FieldDefinitions.FirstOrDefault(f => f.Name == fieldName);`
	`128`	`+ }`
	`129`	`+`
`125`	`130`	`string GetFieldName<T>(Expression<Func<T, object>> field)`
`126`	`131`	`{`
`127`	`132`
Original file line number	Diff line number	Diff line change
`@@ -535,14 +535,14 @@ internal static IEnumerable<T> SelectLazy<T>(this IDbCommand dbCmd, string sql,`
`535`	`535`	`yield break;`
`536`	`536`	`}`
`537`	`537`
`538`		`- var fieldDefs = ModelDefinition<T>.Definition.FieldDefinitionsArray;`
`539`	`538`	`using (var reader = dbCmd.ExecuteReader())`
`540`	`539`	`{`
`541`		`- var indexCache = reader.GetIndexFieldsCache(ModelDefinition<T>.Definition);`
	`540`	`+ var indexCache = reader.GetIndexFieldsCache(ModelDefinition<T>.Definition, dialectProvider);`
	`541`	`+ var values = new object[reader.FieldCount];`
`542`	`542`	`while (reader.Read())`
`543`	`543`	`{`
`544`	`544`	`var row = OrmLiteUtils.CreateInstance<T>();`
`545`		`- row.PopulateWithSqlReader(dialectProvider, reader, fieldDefs, indexCache);`
	`545`	`+ row.PopulateWithSqlReader(dialectProvider, reader, indexCache, values);`
`546`	`546`	`yield return row;`
`547`	`547`	`}`
`548`	`548`	`}`
`@@ -598,15 +598,15 @@ internal static IEnumerable<T> WhereLazy<T>(this IDbCommand dbCmd, object anonTy`
`598`	`598`	`yield break;`
`599`	`599`	`}`
`600`	`600`
`601`		`- var fieldDefs = ModelDefinition<T>.Definition.FieldDefinitionsArray;`
`602`	`601`	`var dialectProvider = dbCmd.GetDialectProvider();`
`603`	`602`	`using (var reader = dbCmd.ExecuteReader())`
`604`	`603`	`{`
`605`		`- var indexCache = reader.GetIndexFieldsCache(ModelDefinition<T>.Definition);`
	`604`	`+ var indexCache = reader.GetIndexFieldsCache(ModelDefinition<T>.Definition, dialectProvider);`
	`605`	`+ var values = new object[reader.FieldCount];`
`606`	`606`	`while (reader.Read())`
`607`	`607`	`{`
`608`	`608`	`var row = OrmLiteUtils.CreateInstance<T>();`
`609`		`- row.PopulateWithSqlReader(dialectProvider, reader, fieldDefs, indexCache);`
	`609`	`+ row.PopulateWithSqlReader(dialectProvider, reader, indexCache, values);`
`610`	`610`	`yield return row;`
`611`	`611`	`}`
`612`	`612`	`}`
`@@ -631,14 +631,14 @@ internal static IEnumerable<T> SelectLazyFmt<T>(this IDbCommand dbCmd, string fi`
`631`	`631`	`yield break;`
`632`	`632`	`}`
`633`	`633`
`634`		`- var fieldDefs = ModelDefinition<T>.Definition.FieldDefinitionsArray;`
`635`	`634`	`using (var reader = dbCmd.ExecReader(dbCmd.CommandText))`
`636`	`635`	`{`
`637`		`- var indexCache = reader.GetIndexFieldsCache(ModelDefinition<T>.Definition);`
	`636`	`+ var indexCache = reader.GetIndexFieldsCache(ModelDefinition<T>.Definition, dialectProvider);`
	`637`	`+ var values = new object[reader.FieldCount];`
`638`	`638`	`while (reader.Read())`
`639`	`639`	`{`
`640`	`640`	`var row = OrmLiteUtils.CreateInstance<T>();`
`641`		`- row.PopulateWithSqlReader(dialectProvider, reader, fieldDefs, indexCache);`
	`641`	`+ row.PopulateWithSqlReader(dialectProvider, reader, indexCache, values);`
`642`	`642`	`yield return row;`
`643`	`643`	`}`
`644`	`644`	`}`
`@@ -683,8 +683,8 @@ internal static T ToScalar<T>(IOrmLiteDialectProvider dialectProvider, IDataRead`
`683`	`683`	`var converter = dialectProvider.GetConverterBestMatch(underlyingType);`
`684`	`684`	`if (converter != null)`
`685`	`685`	`{`
`686`		`- object oValue = converter.GetValue(reader, columnIndex);`
`687`		`- if (oValue == null \|\| oValue == DBNull.Value)`
	`686`	`+ object oValue = converter.GetValue(reader, columnIndex, null);`
	`687`	`+ if (oValue == null)`
`688`	`688`	`return default(T);`
`689`	`689`
`690`	`690`	`var convertedValue = converter.FromDbValue(underlyingType, oValue);`