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)); }