public IEnumerable <T> ExecuteQuery <T>(Func <IDataReader, T> mapper = null)
{
using (_cmd)
{
using (var rd = GetReader())
{
T d;
while (true)
{
try
{
if (!rd.Read())
{
break;
}
if (mapper == null)
{
mapper = PocoFactory.GetPocoMapper <T>(rd, _cmd.CommandText);
}
d = mapper(rd);
}
catch (Exception ex)
{
Db.OnException(this, ex);
Db.CloseConnection();
throw;
}
yield return(d);
}
Db.CloseConnection();
}
}
}
public T ExecuteScalar <T>(Func <object, T> converter = null)
{
using (_cmd)
{
FormatCommand();
object rez;
try
{
rez = _cmd.ExecuteScalar();
Db.OnCommand(_cmd);
}
catch (Exception ex)
{
Db.OnException(this, ex);
throw;
}
finally
{
_db.CloseConnection();
}
if (converter == null)
{
converter = PocoFactory.GetConverter <T>();
}
return(converter(rez));
}
}
public T QuerySingle <T>(Func <IDataReader, T> mapper = null)
{
T d = default(T);
using (_cmd)
{
using (var rd = GetReader())
{
try
{
if (rd.Read())
{
if (mapper == null)
{
mapper = PocoFactory.GetPocoMapper <T>(rd, _cmd.CommandText);
}
d = mapper(rd);
}
}
catch (Exception ex)
{
Db.OnException(this, ex);
Db.CloseConnection();
throw;
}
Db.CloseConnection();
}
}
return(d);
}
public static T GetValue <T>(this DbConnection cnx, string sql, params object[] args)
{
using (var cmd = cnx.CreateAndSetupCommand(sql, args))
{
return(cmd.GetValue(PocoFactory.GetConverter <T>()));
}
}
public static List <T> Fetch <T>(this DbCommand cmd, Func <IDataReader, T> mapper = null,
bool firstRowOnly = false)
{
List <T> rez = new List <T>();
try
{
CommandBehavior behavior = firstRowOnly ? CommandBehavior.SingleRow : CommandBehavior.Default;
using (var reader = cmd.ExecuteReader(behavior))
{
OnCommand(cmd);
while (reader.Read())
{
if (mapper == null)
{
mapper = PocoFactory.GetPocoMapper <T>(reader, cmd.CommandText);
}
rez.Add(mapper(reader));
}
}
return(rez);
}
catch (DbException ex)
{
OnException(cmd, ex);
throw;
}
}
public static async Task <List <T> > FetchAsync <T>(this DbCommand cmd, CancellationToken cancellation, Func <IDataReader, T> mapper = null,
bool firstRowOnly = false)
{
List <T> rez = new List <T>();
try
{
CommandBehavior behavior = firstRowOnly ? CommandBehavior.SingleRow : CommandBehavior.Default;
using (var reader = await cmd.ExecuteReaderAsync(behavior, cancellation))
{
SqlFuDao.OnCommand(cmd);
while (await reader.ReadAsync(cancellation))
{
if (mapper == null)
{
mapper = PocoFactory.GetPocoMapper <T>(reader, cmd.CommandText);
}
rez.Add(mapper(reader));
}
}
return(rez);
}
catch (DbException ex)
{
SqlFuDao.OnException(cmd, ex);
throw;
}
}
public static async Task <T> GetValueAsync <T>(this DbConnection cnx, CancellationToken token, string sql, params object[] args)
{
using (var cmd = cnx.CreateAndSetupCommand(sql, args))
{
return(await cmd.GetValueAsync <T>(PocoFactory.GetConverter <T>(), token));
}
}
public PagedResult <T> ExecutePagedQuery <T>(Func <IDataReader, T> mapper = null)
{
string select;
string count;
_db.Provider.MakePaged(_cmd.CommandText, out @select, out count);
var rez = new PagedResult <T>();
using (_cmd)
{
_cmd.CommandText = count;
FormatCommand();
try
{
var cnt = _cmd.ExecuteScalar();
cnt.MustNotBeNull();
if (cnt.GetType() == typeof(Int32))
{
rez.Count = (int)cnt;
}
else
{
rez.LongCount = (long)cnt;
}
_db.OnCommand(_cmd);
if (rez.Count == 0)
{
return(rez);
}
var it = new List <T>();
_cmd.CommandText = select;
AddPagingParams();
FormatCommand();
using (var rd = _cmd.ExecuteReader())
{
while (rd.Read())
{
if (mapper == null)
{
mapper = PocoFactory.GetPocoMapper <T>(rd, _cmd.CommandText);
}
it.Add(mapper(rd));
}
}
rez.Items = it;
_db.OnCommand(_cmd);
}
catch (Exception ex)
{
Db.OnException(this, ex);
Db.CloseConnection();
throw;
}
}
return(rez);
}
internal static IList <TModel> MapReaderToModel <TModel>(IDataReader reader, IDbCommand command, bool useNextResult = false)
{
var results = new List <TModel>();
if (useNextResult)
{
if (!reader.NextResult())
{
return(results);
}
}
while (reader.Read())
{
var mapper = PocoFactory.GetPocoMapper <TModel>(reader, command.CommandText);
results.Add(mapper(reader));
}
return(results);
}
public virtual bool EmitMapping(ILGenerator il, Type poco, IDataReader rd, int idx)
{
var name = rd.GetName(idx);
var props = GetProperties(poco, name);
if (props == null)
{
return(true);
}
PropertyInfo p;
il.EmitLoadLocal(0);
il.EmitDup();
il.EmitStoreLocal(1);
for (int i = 0; i < props.Length - 1; i++)
{
p = props[i];
var endLoop = il.DefineLabel();
il.Emit(OpCodes.Callvirt, p.GetGetMethod()); //get property value
il.Emit(OpCodes.Dup); //value, value
il.Emit(OpCodes.Ldnull); //value, value, null
il.Emit(OpCodes.Ceq); //compare to null
var hasValue = il.DefineLabel();
il.Emit(OpCodes.Brfalse_S, hasValue); //if not null jump, value stays on stack
il.Emit(OpCodes.Pop); //remove null
il.Emit(OpCodes.Ldloc, 1);
var inv = GetCreatorFor(p.PropertyType);
if (inv == null)
{
il.Emit(OpCodes.Newobj, p.PropertyType.GetConstructor(Type.EmptyTypes));
}
else
{
il.EmitPushType(p.PropertyType);
il.Emit(OpCodes.Call,
typeof(DefaultComplexTypeMapper).GetMethod("GetCreatorFor",
BindingFlags.NonPublic | BindingFlags.Static));
il.EmitLoadLocal(0); //load poco
il.Emit(OpCodes.Call, typeof(Func <dynamic, object>).GetMethod("Invoke"));
}
il.Emit(OpCodes.Dup);
il.Emit(OpCodes.Stloc, 1); //curr obj, value
il.Emit(OpCodes.Callvirt, p.GetSetMethod()); //set val, curr
il.Emit(OpCodes.Ldloc, 1);
il.Emit(OpCodes.Br_S, endLoop);
il.MarkLabel(hasValue);
il.EmitDup();
il.EmitStoreLocal(1);
il.MarkLabel(endLoop);
}
p = props[props.Length - 1];
PocoFactory.EmitGetColumnValue(il, idx, p.PropertyType);
il.Emit(OpCodes.Callvirt, p.GetSetMethod()); //set final value, stack is empty
return(true);
}
