/// <summary>
/// Adds every publicly-settable field or property of the root entity to the select list, removing any beginning underscore from the name of the selected column.
/// </summary>
/// <returns>
/// This RootQueryBuilder object.
/// </returns>
public RootQueryBuilder <T> Select(IEnumerable <Expression <Func <T, object> > > getterExprs)
{
// 1. Cache all setters for type T.
IDictionary <string, SetValue> setters = CachedTypeData.FetchSettersOf <T>();
// 2. Add "RootTable"."propOrFieldName" to the select list or just "propOrFieldName" if table_alias is null for every
// field and property returned in getterExprs
foreach (Expression <Func <T, object> > getterExpr in getterExprs)
{
string propOrFieldName = ExpressionTreeHelper.GetPropOrFieldNameFromLambdaExpr <T>(getterExpr);
// Only if there is a public setter for this property or if the field is public
if (setters.ContainsKey(propOrFieldName) == false)
{
continue;
}
// Remove a possible underscore before adding it to selection
if (propOrFieldName[0] == '_')
{
propOrFieldName = propOrFieldName.Substring(1);
}
string select_projection = RootTable + "." + propOrFieldName;
Qb.Select(select_projection);
}
return(this);
}
public void AddOneToManyCollection <C>(Expression <Func <T, IList <C> > > fetchManyExpr, IDictionary <string, string> projectionsMap)
where C : new()
{
if (FetchManyFetchers == null)
{
FetchManyFetchers = new Dictionary <string, ICollectionResultsFetcher <T> >();
}
string memberName = ExpressionTreeHelper.GetPropOrFieldNameFromLambdaExpr(fetchManyExpr);
ICollectionResultsFetcher <T> collectionFetcher = new CollectionResultsFetcher <T, C>(projectionsMap);
FetchManyFetchers.Add(memberName, collectionFetcher);
}
public MassUpdater(string table, Expression <Func <T, Object> > idGetterExpr, params Expression <Func <T, Object> >[] getterExprs)
{
this.table = table;
chosenPropsOrFields = new Dictionary <string, GetValue>(getterExprs.Length);
var tempGetters = CachedTypeData.FetchGettersOf <T>();
// Only add the ones we want
foreach (var getterExpr in getterExprs)
{
string propOrFieldName = ExpressionTreeHelper.GetPropOrFieldNameFromLambdaExpr <T>(getterExpr);
chosenPropsOrFields.Add(propOrFieldName, tempGetters[propOrFieldName]);
}
// Add the id getter
this.idColumn = ExpressionTreeHelper.GetPropOrFieldNameFromLambdaExpr <T>(idGetterExpr);
this.idGetter = chosenPropsOrFields[idColumn];
this.regs = new List <T>(50);
}
/// <summary>
/// Joins a table that has already been queried or joined, of alias <paramref name="already_queried_table_alias"/> and represented by type <typeparamref name="JT1" />, to the table of name <paramref name="joined_table_name"/>, represented by type <typeparamref name="JT2" />.
/// The join condition is the equality of columns associated to the properties expressed in <paramref name="alreadyQueriedTableColumnGetterExpr"/> and <paramref name="newlyJoinedTableColumnGetterExpr"/>.
/// This method allows joining a table represented by a type more than once (through their different aliases).
/// </summary>
/// <param name="already_queried_table_alias">The alias of a table that has already been queried/joined.</param>
/// <param name="joined_table_name">The real name of the table to be joined, as it is in the database.</param>
/// <param name="joinType">The type of join (inner, outer etc.)</param>
/// <param name="joinedTableAlias">An alias that has been defined for the joined table. Keep this in case you want to join this table to another (instead of joining the root table to something),</param>
/// <typeparam name="JT1">The type that represents the table that has already been joined or queried.</typeparam>
/// <typeparam name="JT2">The type of the newly joined table.</typeparam>
public RootQueryBuilder <T> Join <JT1, JT2>(string already_queried_table_alias, string joined_table_name, Expression <Func <JT1, object> > alreadyQueriedTableColumnGetterExpr, Expression <Func <JT2, object> > newlyJoinedTableColumnGetterExpr, JoinType joinType, out string joined_table_alias)
{
if (QueriedTables.ContainsKey(already_queried_table_alias) == false)
{
throw new InvalidOperationException("The table alias \"" + already_queried_table_alias + "\" has not been queried prior to this method's invocation.");
}
else if (QueriedTables[already_queried_table_alias] != typeof(JT1))
{
throw new InvalidOperationException("The type \"" + typeof(JT1) + "\" does not match the type of the table whose alias is \"" + already_queried_table_alias + "\" (" + QueriedTables[already_queried_table_alias] + ").");
}
// Now that we know who is new, join'em!
joined_table_alias = GetNewNameForQueriedTable(joined_table_name);
AddQueriedTable(joined_table_alias, typeof(JT2));
string column1 = already_queried_table_alias + "." + ExpressionTreeHelper.GetPropOrFieldNameFromLambdaExpr(alreadyQueriedTableColumnGetterExpr);
string column2 = joined_table_alias + "." + ExpressionTreeHelper.GetPropOrFieldNameFromLambdaExpr(newlyJoinedTableColumnGetterExpr);
Qb.Join(joined_table_name, column1, column2, joinType);
return(this);
}
public void Update <T>(string table, Object obj, Expression <Func <T, Object> > idGetterExpr, params Expression <Func <T, Object> >[] getterExprs)
{
ObjectAndColumns reg = new ObjectAndColumns {
table = table,
chosenPropsOrFields = new Dictionary <string, GetValue>(getterExprs.Length),
idColumn = ExpressionTreeHelper.GetPropOrFieldNameFromLambdaExpr <T>(idGetterExpr),
obj = obj
};
var tempGetters = CachedTypeData.FetchGettersOf <T>();
// Only add the ones we want
foreach (var getterExpr in getterExprs)
{
string propOrFieldName = ExpressionTreeHelper.GetPropOrFieldNameFromLambdaExpr <T>(getterExpr);
reg.chosenPropsOrFields.Add(propOrFieldName, tempGetters[propOrFieldName]);
}
// Add the id getter
reg.idGetter = tempGetters[reg.idColumn];
regs.Add(reg);
}
