public SqlSelect<T> AddFields<TEntity>(SqlAlias<TEntity> alias,
params Expression<Func<TEntity, object>>[] fields)
{
if (alias == null) throw new ArgumentNullException(nameof(alias));
if (fields == null) throw new ArgumentNullException(nameof(fields));
return AddFields(CreateSqlFields(alias, fields));
}
ISqlSelect ISqlSelect.Join <TJoin>(JoinType joinType, ISqlFilter condition, SqlAlias <TJoin> joinAlias)
{
ISqlSelect result;
switch (joinType)
{
case JoinType.Inner:
result = InnerJoin(condition, joinAlias);
break;
case JoinType.Left:
result = LeftJoin(condition, joinAlias);
break;
case JoinType.Right:
result = RightJoin(condition, joinAlias);
break;
case JoinType.Full:
result = FullJoin(condition, joinAlias);
break;
default:
throw new NotSupportedException($"{joinType.ToString()} is not supported");
}
return(result);
}
ISqlSelect ISqlSelect.AddFields<TEntity>(SqlAlias<TEntity> alias,
params Expression<Func<TEntity, object>>[] fields)
{
if (alias == null)
MetadataProvider.AliasFor<TEntity>();
return AddFields(alias, fields);
}
public SqlSelect FullJoin <TJoin>(ISqlFilter condition, SqlAlias <TJoin> joinAlias = null)
{
if (condition == null)
{
throw new ArgumentNullException(nameof(condition));
}
return(CreateSqlSelect(Join(JoinType.Full, condition, joinAlias)));
}
private SqlAlias <TEntity> InitAlias <TEntity>()
{
var entityType = typeof(TEntity);
var alias = new SqlAlias <TEntity>(GenerateAliasName(entityType));
_aliases.Add(entityType, alias);
return(alias);
}
public SqlSelect<T> FullJoin<TLeft, TJoin>(Expression<Func<TLeft, TJoin, bool>> condition,
SqlAlias<TLeft> leftAlias = null, SqlAlias<TJoin> joinAlias = null)
{
if (condition == null) throw new ArgumentNullException(nameof(condition));
if (leftAlias == null)
leftAlias = MetadataProvider.AliasFor<TLeft>();
if (joinAlias == null)
joinAlias = MetadataProvider.AliasFor<TJoin>();
return FullJoin(GetJoinFilter(condition.Body as BinaryExpression, leftAlias, joinAlias), joinAlias);
}
public bool Equals(SqlAlias <T> obj)
{
return(obj != null && string.Equals(Value, obj.Value));
}
protected SqlSelectInfo Join <TJoin>(JoinType joinType, ISqlFilter condition, SqlAlias <TJoin> joinAlias = null)
{
if (condition == null)
{
throw new ArgumentNullException(nameof(condition));
}
if (joinAlias == null)
{
joinAlias = MetadataProvider.AliasFor <TJoin>();
}
if (Info.Joins().Any(j => j.JoinAlias.Value == joinAlias.Value))
{
throw new JoinException($"Alias '{joinAlias.Value}' is already registered");
}
var join = new SqlJoin <TJoin>(joinType, condition, joinAlias);
return(Info.Joins(join));
}
protected ISqlFilter GetJoinFilter <TLeft, TJoin>(BinaryExpression expression, SqlAlias <TLeft> leftAlias, SqlAlias <TJoin> joinAlias)
{
if (leftAlias == null)
{
throw new ArgumentNullException(nameof(leftAlias));
}
if (joinAlias == null)
{
throw new ArgumentNullException(nameof(joinAlias));
}
if (expression == null || expression.NodeType != ExpressionType.Equal)
{
throw new JoinException("Invalid join expression");
}
var leftExpr = LibHelper.GetMemberExpression(expression.Left);
var rightExpr = LibHelper.GetMemberExpression(expression.Right);
if (leftExpr == null)
{
throw new ArgumentNullException(nameof(leftExpr));
}
if (rightExpr == null)
{
throw new ArgumentNullException(nameof(rightExpr));
}
var rightField = leftExpr.Expression.Type == leftAlias.EntityType
? CreateSqlField <TJoin>(MetadataProvider.GetPropertyName(rightExpr), joinAlias)
: (ISqlField)CreateSqlField <TLeft>(MetadataProvider.GetPropertyName(rightExpr), leftAlias);
return(leftExpr.Expression.Type == leftAlias.EntityType
? SqlFilter <TLeft> .From <object>(SqlField.From(typeof(TLeft), typeof(int),
leftAlias, MetadataProvider.GetPropertyName(leftExpr))).EqualTo(rightField)
: (ISqlFilter)SqlFilter <TJoin> .From <object>(SqlField.From(typeof(TJoin), typeof(int),
joinAlias, MetadataProvider.GetPropertyName(leftExpr))).EqualTo(rightField));
}
ISqlSelect ISqlSelect.AddFields <TEntity>(SqlAlias <TEntity> alias, params Expression <Func <TEntity, object> >[] fields) => AddFields(fields);
ISqlSelect ISqlSelect.OrderBy <TEntity>(SqlAlias <TEntity> alias, params Expression <Func <TEntity, object> >[] fields) => OrderBy(fields);
public SqlSelect<T> RightJoin<TJoin>(ISqlFilter condition, SqlAlias<TJoin> joinAlias = null)
{
if (condition == null) throw new ArgumentNullException(nameof(condition));
return CreateSqlSelect(Join(JoinType.Right, condition, joinAlias));
}
public SqlJoin(JoinType joinType, ISqlFilter joinCondition, SqlAlias <TJoin> joinAlias)
{
JoinType = joinType;
JoinCondition = joinCondition ?? throw new ArgumentNullException(nameof(joinCondition));
JoinAlias = joinAlias ?? throw new ArgumentNullException(nameof(joinAlias));
}
