public QueryBuilderBase(Type databaseType)
{
var methods = databaseType.GetTypeInfo()
.GetMethods(BindingFlags.Public | BindingFlags.Static)
.Where(m => m.GetCustomAttributes(typeof(DatabaseModelProviderAttribute)).Any())
.ToList();
if (methods.Count != 1)
{
throw QueryBuilderError.DatabaseTypeNoModelProvider(databaseType.Name).AsException();
}
var method = methods.Single();
var modelBuilderType = typeof(DatabaseBuilder <>).MakeGenericType(databaseType);
if (method.ReturnType != typeof(DatabaseModel) || method.GetParameters().FirstOrDefault()?.ParameterType != modelBuilderType)
{
throw QueryBuilderError.DatabaseTypeModelProviderIncorrectType(databaseType.Name).AsException();
}
var modelBuilder = Activator.CreateInstance(modelBuilderType);
try
{
DatabaseModel = method.Invoke(null, new object[] { modelBuilder }) as DatabaseModel;
}
catch (TargetInvocationException ex)
{
// Exceptions thrown by the model builder code will be wrapped in a target invocation exception
throw ex.InnerException;
}
}
public static void Check(bool condition, QueryBuilderError queryBuilderError)
{
if (condition != true)
{
throw new QueryBuilderException(queryBuilderError);
}
}
public SelectQueryBase(QueryBase innerQuery, LambdaExpression selector)
{
InnerQuery = innerQuery;
Selector = selector;
Columns = GetColumns(selector);
var groupByQuery = GetGroupByQuery(innerQuery);
if (groupByQuery != null)
{
// All group by keys must be present in the select statement
var groupByNames = new HashSet <string>(groupByQuery.KeyColumns.Select(k => k.Property.Name));
foreach (var expression in (selector.Body as NewExpression).Arguments)
{
if (expression is MemberExpression keyProperty &&
keyProperty.Member is PropertyInfo &&
keyProperty.Expression is MemberExpression keysProperty &&
keysProperty.Member is PropertyInfo &&
keysProperty.Expression.NodeType == ExpressionType.Parameter &&
keysProperty.Member.Name == nameof(IGroupedRow <object, object> .Keys))
{
groupByNames.Remove(keyProperty.Member.Name);
}
}
if (groupByNames.Count > 0)
{
throw QueryBuilderError.SelectGroupByKeyNotPresentInSelect().AsException();
}
}
}
public GroupByQueryBase(QueryBase innerQuery, LambdaExpression keys)
{
InnerQuery = innerQuery;
if (keys == null)
{
throw BuilderError.ArgumentNull(nameof(keys)).AsException();
}
// Keys must be named
if (keys.Body is NewExpression newExpression)
{
KeyColumns = newExpression.Members.Zip(newExpression.Arguments, (l, r) => (Left: l, Right: r))
.Select(p => (p.Left as PropertyInfo, p.Right))
.ToImmutableArray();
}
else
{
throw QueryBuilderError.GroupByNotNewExpression().AsException();
}
}
public QueryBuilderException(QueryBuilderError queryBuilderError)
: base($"Fail to create QueryBuilder. {nameof(QueryBuilderError)} : {queryBuilderError}")
{
QueryBuilderError = queryBuilderError;
}
public async void Error_On_Keys_Not_New_Expression(string groupBy, string location)
{
await VerifyGroupByErrorRaised(QueryBuilderError.GroupByNotNewExpression(), groupBy, location);
}
public async void Error_On_All_GroupBy_Keys_Not_Present_In_Select_Statement(string location, string query)
{
await VerifySelectErrorRaised(QueryBuilderError.SelectGroupByKeyNotPresentInSelect(), query, location);
}
