private IQueryableCommand <T> GetQuery(IDatabaseDriver driver, IMapper mapper)
{
if (query == null)
{
if (fetches == null)
{
query = FluentBaseBuilder <T, FolkeTuple <object> > .Select(driver, mapper).All().From().Where((x, y) => x.Key().Equals(y.Item0));
}
else
{
var selectQuery = FluentBaseBuilder <T, FolkeTuple <object> > .Select(driver, mapper).All();
foreach (var fetch in fetches)
{
selectQuery.All(fetch);
}
var fromQuery = selectQuery.From();
foreach (var fetch in fetches)
{
fromQuery.LeftJoinOnId(fetch);
}
fromQuery.Where((x, y) => x.Key().Equals(y.Item0));
query = fromQuery;
}
}
return(query);
}
public IQueryableCommand <T> Build(IFolkeConnection connection)
{
if (query == null)
{
var select = FluentBaseBuilder <T, FolkeTuple> .Select(connection.Driver, connection.Mapper);
query = prepare.Invoke(select);
}
return(query.Build(connection));
}
internal static IEnumerable <T> Enumerate <T>(this IQueryableCommand <T> queryable)
{
using (var command = queryable.Connection.CreateCommand(queryable.Sql, queryable.Parameters))
{
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
yield return((T)queryable.MappedClass.Read(queryable.Connection, typeof(T), reader));
}
}
}
}
public static object Scalar(this IQueryableCommand baseQueryBuilder)
{
using (var command = baseQueryBuilder.CreateCommand())
{
using (var reader = command.ExecuteReader())
{
if (!reader.Read() || reader.IsDBNull(0))
{
return(null);
}
return(reader.GetValue(0));
}
}
}
public static async Task <object> ScalarAsync(this IQueryableCommand baseQueryBuilder)
{
using (var command = baseQueryBuilder.Connection.CreateCommand(baseQueryBuilder.Sql, baseQueryBuilder.Parameters))
{
using (var reader = await command.ExecuteReaderAsync())
{
if (!reader.Read() || reader.IsDBNull(0))
{
return(null);
}
return(reader.GetValue(0));
}
}
}
public static async Task <TU> ScalarAsync <TU>(this IQueryableCommand baseQueryBuilder)
{
using (var command = baseQueryBuilder.CreateCommand())
{
using (var reader = await command.ExecuteReaderAsync())
{
if (!reader.Read() || reader.IsDBNull(0))
{
return(default(TU));
}
var ret = baseQueryBuilder.Connection.Driver.ConvertReaderValueToValue(reader, typeof(TU), 0);
return((TU)ret);
}
}
}
public static async Task <T> FirstOrDefaultAsync <T>(this IQueryableCommand <T> baseQueryBuilder)
{
using (var command = baseQueryBuilder.Connection.CreateCommand(baseQueryBuilder.Sql, baseQueryBuilder.Parameters))
{
using (var reader = command.ExecuteReader())
{
if (!await reader.ReadAsync())
{
return(default(T));
}
var value = baseQueryBuilder.MappedClass.Read(baseQueryBuilder.Connection, typeof(T), reader);
return((T)value);
}
}
}
/// <summary>
/// Gets the first result asynchronously.
/// Throws an exception if there is no result.
/// </summary>
/// <returns></returns>
public static async Task <T> FirstAsync <T>(this IQueryableCommand <T> baseQueryBuilder)
{
using (var command = baseQueryBuilder.Connection.CreateCommand(baseQueryBuilder.Sql, baseQueryBuilder.Parameters))
{
using (var reader = command.ExecuteReader())
{
if (!await reader.ReadAsync())
{
throw new InvalidOperationException("No result found");
}
var value = baseQueryBuilder.MappedClass.Read(baseQueryBuilder.Connection, typeof(T), reader);
return((T)value);
}
}
}
public static IList <T> ToList <T>(this IQueryableCommand <T> queryableCommand)
{
using (var command = queryableCommand.Connection.CreateCommand(queryableCommand.Sql, queryableCommand.Parameters))
{
using (var reader = command.ExecuteReader())
{
var ret = new List <T>();
while (reader.Read())
{
var value = queryableCommand.MappedClass.Read(queryableCommand.Connection, typeof(T), reader);
ret.Add((T)value);
}
return(ret);
}
}
}
public static async Task <IList <T> > ToListAsync <T>(this IQueryableCommand <T> baseQueryBuilder)
{
using (var command = baseQueryBuilder.Connection.CreateCommand(baseQueryBuilder.Sql, baseQueryBuilder.Parameters))
{
using (var reader = await command.ExecuteReaderAsync())
{
var ret = new List <T>();
while (reader.Read())
{
var value = baseQueryBuilder.MappedClass.Read(baseQueryBuilder.Connection, typeof(T), reader);
ret.Add((T)value);
}
return(ret);
}
}
}
public static async Task <T> SingleOrDefaultAsync <T>(this IQueryableCommand <T> baseQueryBuilder)
{
using (var command = baseQueryBuilder.Connection.CreateCommand(baseQueryBuilder.Sql, baseQueryBuilder.Parameters))
{
using (var reader = await command.ExecuteReaderAsync())
{
if (!reader.Read())
{
return(default(T));
}
var value = baseQueryBuilder.MappedClass.Read(baseQueryBuilder.Connection, typeof(T), reader);
if (reader.Read())
{
throw new InvalidOperationException("Not single");
}
return((T)value);
}
}
}
public static IQueryableCommand <T> Build <T>(this IQueryableCommand <T> baseQueryBuilder,
IFolkeConnection connection, params object[] parameters)
{
return(new QueryableCommand <T>(connection, baseQueryBuilder.MappedClass, baseQueryBuilder.Sql, parameters));
}
public static IFolkeCommand CreateCommand(this IQueryableCommand queryableCommand)
{
return(queryableCommand.Connection.CreateCommand(queryableCommand.Sql, queryableCommand.Parameters));
}
