6648415992

Committed 26 Oct 2023 01:49AM UTC coverage: 51.645% (+0.1%) from 51.515%

Build # 6648415992

Build Type

push

github

Committed by

pwelter34

Commit Message

Update InsertBuilder.cs

Run Details

981 of 2442 branches covered (0.0%)

Branch coverage included in aggregate %.

2896 of 5065 relevant lines covered (57.18%)

156.37 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

40.58

/src/FluentCommand/Query/DeleteEntityBuilder.cs

using System.Linq.Expressions;

using FluentCommand.Extensions;
using FluentCommand.Query.Generators;
using FluentCommand.Reflection;

namespace FluentCommand.Query;


/// <summary>
/// Delete query statement builder
/// </summary>
/// <typeparam name="TEntity">The type of the entity.</typeparam>
public class DeleteEntityBuilder<TEntity>
    : DeleteBuilder<DeleteEntityBuilder<TEntity>>, IWhereEntityBuilder<TEntity, DeleteEntityBuilder<TEntity>>
    where TEntity : class
{
    private static readonly TypeAccessor _typeAccessor = TypeAccessor.GetAccessor<TEntity>();

    /// <summary>
    /// Initializes a new instance of the <see cref="DeleteEntityBuilder{TEntity}"/> class.
    /// </summary>
    /// <param name="queryGenerator">The query generator.</param>
    /// <param name="parameters">The parameters.</param>
    /// <param name="logicalOperator">The logical operator.</param>
    public DeleteEntityBuilder(
        IQueryGenerator queryGenerator,
        List<QueryParameter> parameters,
        LogicalOperators logicalOperator = LogicalOperators.And)
        : base(queryGenerator, parameters, logicalOperator)
    {
    }


    /// <summary>
    /// Add an output clause for the specified property.
    /// </summary>
    /// <typeparam name="TValue">The type of the value.</typeparam>
    /// <param name="property">The property.</param>
    /// <param name="tableAlias">The table alias.</param>
    /// <param name="columnAlias">The column alias.</param>
    /// <returns>
    /// The same builder so that multiple calls can be chained.
    /// </returns>
    public DeleteEntityBuilder<TEntity> Output<TValue>(
        Expression<Func<TEntity, TValue>> property,
        string tableAlias = "DELETED",
        string columnAlias = null)
    {
        var propertyAccessor = _typeAccessor.FindProperty(property);
        return Output(propertyAccessor.Column, tableAlias, columnAlias);
    }

    /// <summary>
    /// Conditionally add an output clause for the specified property.
    /// </summary>
    /// <typeparam name="TValue">The type of the value.</typeparam>
    /// <param name="property">The property.</param>
    /// <param name="tableAlias">The table alias.</param>
    /// <param name="columnAlias">The column alias.</param>
    /// <param name="condition">The condition.</param>
    /// <returns>
    /// The same builder so that multiple calls can be chained.
    /// </returns>
    public DeleteEntityBuilder<TEntity> OutputIf<TValue>(
        Expression<Func<TEntity, TValue>> property,
        string tableAlias = "DELETED",
        string columnAlias = null,
        Func<string, bool> condition = null)
    {
        var propertyAccessor = _typeAccessor.FindProperty(property);
        return OutputIf(propertyAccessor.Column, tableAlias, columnAlias, condition);
    }

    /// <inheritdoc />
    public override DeleteEntityBuilder<TEntity> From(
        string tableName = null,
        string tableSchema = null,
        string tableAlias = null)
    {
        return base.From(
            tableName ?? _typeAccessor.TableName,
            tableSchema ?? _typeAccessor.TableSchema,
            tableAlias);
    }

    /// <summary>
    /// Add a join clause using the specified builder action
    /// </summary>
    /// <typeparam name="TRight">The right join entity</typeparam>
    /// <param name="builder">The join builder.</param>
    /// <returns>
    /// The same builder so that multiple calls can be chained.
    /// </returns>
    public DeleteEntityBuilder<TEntity> Join<TRight>(Action<JoinEntityBuilder<TEntity, TRight>> builder)
        where TRight : class
    {
        var innerBuilder = new JoinEntityBuilder<TEntity, TRight>(QueryGenerator, Parameters);
        builder(innerBuilder);

        JoinExpressions.Add(innerBuilder.BuildExpression());

        return this;
    }

    /// <summary>
    /// Add a join clause using the specified builder action
    /// </summary>
    /// <typeparam name="TLeft">The left join entity</typeparam>
    /// <typeparam name="TRight">The right join entity</typeparam>
    /// <param name="builder">The join builder.</param>
    /// <returns>
    /// The same builder so that multiple calls can be chained.
    /// </returns>
    public DeleteEntityBuilder<TEntity> Join<TLeft, TRight>(Action<JoinEntityBuilder<TLeft, TRight>> builder)
        where TLeft : class
        where TRight : class
    {
        var innerBuilder = new JoinEntityBuilder<TLeft, TRight>(QueryGenerator, Parameters);
        builder(innerBuilder);

        JoinExpressions.Add(innerBuilder.BuildExpression());

        return this;
    }


    /// <inheritdoc />
    public DeleteEntityBuilder<TEntity> Where<TValue>(
        Expression<Func<TEntity, TValue>> property,
        TValue parameterValue,
        FilterOperators filterOperator = FilterOperators.Equal)
    {
        return Where<TValue>(property, parameterValue, null, filterOperator);
    }

    /// <inheritdoc />
    public DeleteEntityBuilder<TEntity> Where<TValue>(
        Expression<Func<TEntity, TValue>> property,
        TValue parameterValue,
        string tableAlias,
        FilterOperators filterOperator = FilterOperators.Equal)
    {
        var propertyAccessor = _typeAccessor.FindProperty(property);

        return Where(propertyAccessor.Column, parameterValue, tableAlias, filterOperator);
    }

    /// <summary>
    /// Create a where clause with the specified property, value, operator and table alias
    /// </summary>
    /// <typeparam name="TModel">The type of the model</typeparam>
    /// <typeparam name="TValue">The type of the value.</typeparam>
    /// <param name="property">The property.</param>
    /// <param name="parameterValue">The parameter value.</param>
    /// <param name="tableAlias">The table alias.</param>
    /// <param name="filterOperator">The filter operator.</param>
    /// <returns>
    /// The same builder so that multiple calls can be chained.
    /// </returns>
    public DeleteEntityBuilder<TEntity> Where<TModel, TValue>(
        Expression<Func<TModel, TValue>> property,
        TValue parameterValue,
        string tableAlias,
        FilterOperators filterOperator = FilterOperators.Equal)
    {
        var typeAccessor = TypeAccessor.GetAccessor<TModel>();
        var propertyAccessor = typeAccessor.FindProperty(property);

        return Where(propertyAccessor.Column, parameterValue, tableAlias, filterOperator);
    }

    /// <inheritdoc />
    public DeleteEntityBuilder<TEntity> WhereIf<TValue>(
        Expression<Func<TEntity, TValue>> property,
        TValue parameterValue,
        FilterOperators filterOperator = FilterOperators.Equal,
        Func<string, TValue, bool> condition = null)
    {
        return WhereIf(property, parameterValue, null, filterOperator, condition);
    }

    /// <inheritdoc />
    public DeleteEntityBuilder<TEntity> WhereIf<TValue>(
        Expression<Func<TEntity, TValue>> property,
        TValue parameterValue,
        string tableAlias,
        FilterOperators filterOperator = FilterOperators.Equal,
        Func<string, TValue, bool> condition = null)
    {
        var propertyAccessor = _typeAccessor.FindProperty(property);

        return WhereIf(propertyAccessor.Column, parameterValue, tableAlias, filterOperator, condition);
    }

    /// <inheritdoc />
    public DeleteEntityBuilder<TEntity> WhereIn<TValue>(
        Expression<Func<TEntity, TValue>> property,
        IEnumerable<TValue> parameterValues,
        string tableAlias)
    {
        var propertyAccessor = _typeAccessor.FindProperty(property);

        return WhereIn(propertyAccessor?.Column, parameterValues, tableAlias);
    }

    /// <inheritdoc />
    public DeleteEntityBuilder<TEntity> WhereInIf<TValue>(
        Expression<Func<TEntity, TValue>> property,
        IEnumerable<TValue> parameterValues,
        Func<string, IEnumerable<TValue>, bool> condition = null)
    {
        var propertyAccessor = _typeAccessor.FindProperty(property);

        return WhereInIf(propertyAccessor?.Column, parameterValues, condition);
    }

    /// <inheritdoc />
    public DeleteEntityBuilder<TEntity> WhereInIf<TValue>(
        Expression<Func<TEntity, TValue>> property,
        IEnumerable<TValue> parameterValues,
        string tableAlias,
        Func<string, IEnumerable<TValue>, bool> condition = null)
    {
        var propertyAccessor = _typeAccessor.FindProperty(property);

        return WhereInIf(propertyAccessor?.Column, parameterValues, tableAlias, condition);
    }

    /// <inheritdoc />
    public DeleteEntityBuilder<TEntity> WhereOr(Action<LogicalEntityBuilder<TEntity>> builder)
    {
        var innerBuilder = new LogicalEntityBuilder<TEntity>(QueryGenerator, Parameters, LogicalOperators.Or);

        builder(innerBuilder);

        var statement = innerBuilder.BuildStatement();

        if (statement != null && statement.Statement.HasValue())
            WhereExpressions.Add(new WhereExpression(statement.Statement, IsRaw: true));

        return this;
    }

    /// <inheritdoc />
    public DeleteEntityBuilder<TEntity> WhereAnd(Action<LogicalEntityBuilder<TEntity>> builder)
    {
        var innerBuilder = new LogicalEntityBuilder<TEntity>(QueryGenerator, Parameters, LogicalOperators.And);

        builder(innerBuilder);

        var statement = innerBuilder.BuildStatement();

        if (statement != null && statement.Statement.HasValue())
            WhereExpressions.Add(new WhereExpression(statement.Statement, IsRaw: true));

        return this;
    }


    /// <inheritdoc />
    public override QueryStatement BuildStatement()
    {
        // add table and schema from attribute if not set
        if (TableExpression == null)
            Table(_typeAccessor.TableName, _typeAccessor.TableSchema);

        return base.BuildStatement();
    }
}

1	using System.Linq.Expressions;
2
3	using FluentCommand.Extensions;
4	using FluentCommand.Query.Generators;
5	using FluentCommand.Reflection;
6
7	namespace FluentCommand.Query;
8
9
10	/// <summary>
11	/// Delete query statement builder
12	/// </summary>
13	/// <typeparam name="TEntity">The type of the entity.</typeparam>
14	public class DeleteEntityBuilder<TEntity>
15	: DeleteBuilder<DeleteEntityBuilder<TEntity>>, IWhereEntityBuilder<TEntity, DeleteEntityBuilder<TEntity>>
16	where TEntity : class
17	{
18	private static readonly TypeAccessor _typeAccessor = TypeAccessor.GetAccessor<TEntity>();	5✔
19
20	/// <summary>
21	/// Initializes a new instance of the <see cref="DeleteEntityBuilder{TEntity}"/> class.
22	/// </summary>
23	/// <param name="queryGenerator">The query generator.</param>
24	/// <param name="parameters">The parameters.</param>
25	/// <param name="logicalOperator">The logical operator.</param>
26	public DeleteEntityBuilder(
27	IQueryGenerator queryGenerator,
28	List<QueryParameter> parameters,
29	LogicalOperators logicalOperator = LogicalOperators.And)
30	: base(queryGenerator, parameters, logicalOperator)	6✔
31	{
32	}	6✔
33
34
35	/// <summary>
36	/// Add an output clause for the specified property.
37	/// </summary>
38	/// <typeparam name="TValue">The type of the value.</typeparam>
39	/// <param name="property">The property.</param>
40	/// <param name="tableAlias">The table alias.</param>
41	/// <param name="columnAlias">The column alias.</param>
42	/// <returns>
43	/// The same builder so that multiple calls can be chained.
44	/// </returns>
45	public DeleteEntityBuilder<TEntity> Output<TValue>(
46	Expression<Func<TEntity, TValue>> property,
47	string tableAlias = "DELETED",
48	string columnAlias = null)
49	{
50	var propertyAccessor = _typeAccessor.FindProperty(property);	6✔
51	return Output(propertyAccessor.Column, tableAlias, columnAlias);	6✔
52	}
53
54	/// <summary>
55	/// Conditionally add an output clause for the specified property.
56	/// </summary>
57	/// <typeparam name="TValue">The type of the value.</typeparam>
58	/// <param name="property">The property.</param>
59	/// <param name="tableAlias">The table alias.</param>
60	/// <param name="columnAlias">The column alias.</param>
61	/// <param name="condition">The condition.</param>
62	/// <returns>
63	/// The same builder so that multiple calls can be chained.
64	/// </returns>
65	public DeleteEntityBuilder<TEntity> OutputIf<TValue>(
66	Expression<Func<TEntity, TValue>> property,
67	string tableAlias = "DELETED",
68	string columnAlias = null,
69	Func<string, bool> condition = null)
70	{
71	var propertyAccessor = _typeAccessor.FindProperty(property);	×
72	return OutputIf(propertyAccessor.Column, tableAlias, columnAlias, condition);	×
73	}
74
75	/// <inheritdoc />
76	public override DeleteEntityBuilder<TEntity> From(
77	string tableName = null,
78	string tableSchema = null,
79	string tableAlias = null)
80	{
81	return base.From(	1✔
82	tableName ?? _typeAccessor.TableName,	1✔
83	tableSchema ?? _typeAccessor.TableSchema,	1✔
84	tableAlias);	1✔
85	}
86
87	/// <summary>
88	/// Add a join clause using the specified builder action
89	/// </summary>
90	/// <typeparam name="TRight">The right join entity</typeparam>
91	/// <param name="builder">The join builder.</param>
92	/// <returns>
93	/// The same builder so that multiple calls can be chained.
94	/// </returns>
95	public DeleteEntityBuilder<TEntity> Join<TRight>(Action<JoinEntityBuilder<TEntity, TRight>> builder)
96	where TRight : class
97	{
98	var innerBuilder = new JoinEntityBuilder<TEntity, TRight>(QueryGenerator, Parameters);	1✔
99	builder(innerBuilder);	1✔
100
101	JoinExpressions.Add(innerBuilder.BuildExpression());	1✔
102
103	return this;	1✔
104	}
105
106	/// <summary>
107	/// Add a join clause using the specified builder action
108	/// </summary>
109	/// <typeparam name="TLeft">The left join entity</typeparam>
110	/// <typeparam name="TRight">The right join entity</typeparam>
111	/// <param name="builder">The join builder.</param>
112	/// <returns>
113	/// The same builder so that multiple calls can be chained.
114	/// </returns>
115	public DeleteEntityBuilder<TEntity> Join<TLeft, TRight>(Action<JoinEntityBuilder<TLeft, TRight>> builder)
116	where TLeft : class
117	where TRight : class
118	{
119	var innerBuilder = new JoinEntityBuilder<TLeft, TRight>(QueryGenerator, Parameters);	×
120	builder(innerBuilder);	×
121
122	JoinExpressions.Add(innerBuilder.BuildExpression());	×
123
124	return this;	×
125	}
126
127
128	/// <inheritdoc />
129	public DeleteEntityBuilder<TEntity> Where<TValue>(
130	Expression<Func<TEntity, TValue>> property,
131	TValue parameterValue,
132	FilterOperators filterOperator = FilterOperators.Equal)
133	{
134	return Where<TValue>(property, parameterValue, null, filterOperator);	5✔
135	}
136
137	/// <inheritdoc />
138	public DeleteEntityBuilder<TEntity> Where<TValue>(
139	Expression<Func<TEntity, TValue>> property,
140	TValue parameterValue,
141	string tableAlias,
142	FilterOperators filterOperator = FilterOperators.Equal)
143	{
144	var propertyAccessor = _typeAccessor.FindProperty(property);	5✔
145
146	return Where(propertyAccessor.Column, parameterValue, tableAlias, filterOperator);	5✔
147	}
148
149	/// <summary>
150	/// Create a where clause with the specified property, value, operator and table alias
151	/// </summary>
152	/// <typeparam name="TModel">The type of the model</typeparam>
153	/// <typeparam name="TValue">The type of the value.</typeparam>
154	/// <param name="property">The property.</param>
155	/// <param name="parameterValue">The parameter value.</param>
156	/// <param name="tableAlias">The table alias.</param>
157	/// <param name="filterOperator">The filter operator.</param>
158	/// <returns>
159	/// The same builder so that multiple calls can be chained.
160	/// </returns>
161	public DeleteEntityBuilder<TEntity> Where<TModel, TValue>(
162	Expression<Func<TModel, TValue>> property,
163	TValue parameterValue,
164	string tableAlias,
165	FilterOperators filterOperator = FilterOperators.Equal)
166	{
167	var typeAccessor = TypeAccessor.GetAccessor<TModel>();	1✔
168	var propertyAccessor = typeAccessor.FindProperty(property);	1✔
169
170	return Where(propertyAccessor.Column, parameterValue, tableAlias, filterOperator);	1✔
171	}
172
173	/// <inheritdoc />
174	public DeleteEntityBuilder<TEntity> WhereIf<TValue>(
175	Expression<Func<TEntity, TValue>> property,
176	TValue parameterValue,
177	FilterOperators filterOperator = FilterOperators.Equal,
178	Func<string, TValue, bool> condition = null)
179	{
180	return WhereIf(property, parameterValue, null, filterOperator, condition);	×
181	}
182
183	/// <inheritdoc />
184	public DeleteEntityBuilder<TEntity> WhereIf<TValue>(
185	Expression<Func<TEntity, TValue>> property,
186	TValue parameterValue,
187	string tableAlias,
188	FilterOperators filterOperator = FilterOperators.Equal,
189	Func<string, TValue, bool> condition = null)
190	{
191	var propertyAccessor = _typeAccessor.FindProperty(property);	×
192
193	return WhereIf(propertyAccessor.Column, parameterValue, tableAlias, filterOperator, condition);	×
194	}
195
196	/// <inheritdoc />
197	public DeleteEntityBuilder<TEntity> WhereIn<TValue>(
198	Expression<Func<TEntity, TValue>> property,
199	IEnumerable<TValue> parameterValues,
200	string tableAlias)
201	{
202	var propertyAccessor = _typeAccessor.FindProperty(property);	×
203
204	return WhereIn(propertyAccessor?.Column, parameterValues, tableAlias);	×
205	}
206
207	/// <inheritdoc />
208	public DeleteEntityBuilder<TEntity> WhereInIf<TValue>(
209	Expression<Func<TEntity, TValue>> property,
210	IEnumerable<TValue> parameterValues,
211	Func<string, IEnumerable<TValue>, bool> condition = null)
212	{
213	var propertyAccessor = _typeAccessor.FindProperty(property);	×
214
215	return WhereInIf(propertyAccessor?.Column, parameterValues, condition);	×
216	}
217
218	/// <inheritdoc />
219	public DeleteEntityBuilder<TEntity> WhereInIf<TValue>(
220	Expression<Func<TEntity, TValue>> property,
221	IEnumerable<TValue> parameterValues,
222	string tableAlias,
223	Func<string, IEnumerable<TValue>, bool> condition = null)
224	{
225	var propertyAccessor = _typeAccessor.FindProperty(property);	×
226
227	return WhereInIf(propertyAccessor?.Column, parameterValues, tableAlias, condition);	×
228	}
229
230	/// <inheritdoc />
231	public DeleteEntityBuilder<TEntity> WhereOr(Action<LogicalEntityBuilder<TEntity>> builder)
232	{
233	var innerBuilder = new LogicalEntityBuilder<TEntity>(QueryGenerator, Parameters, LogicalOperators.Or);	×
234
235	builder(innerBuilder);	×
236
237	var statement = innerBuilder.BuildStatement();	×
238
239	if (statement != null && statement.Statement.HasValue())	×
240	WhereExpressions.Add(new WhereExpression(statement.Statement, IsRaw: true));	×
241
242	return this;	×
243	}
244
245	/// <inheritdoc />
246	public DeleteEntityBuilder<TEntity> WhereAnd(Action<LogicalEntityBuilder<TEntity>> builder)
247	{
248	var innerBuilder = new LogicalEntityBuilder<TEntity>(QueryGenerator, Parameters, LogicalOperators.And);	×
249
250	builder(innerBuilder);	×
251
252	var statement = innerBuilder.BuildStatement();	×
253
254	if (statement != null && statement.Statement.HasValue())	×
255	WhereExpressions.Add(new WhereExpression(statement.Statement, IsRaw: true));	×
256
257	return this;	×
258	}
259
260
261	/// <inheritdoc />
262	public override QueryStatement BuildStatement()
263	{
264	// add table and schema from attribute if not set
265	if (TableExpression == null)	6✔
266	Table(_typeAccessor.TableName, _typeAccessor.TableSchema);	6✔
267
268	return base.BuildStatement();	6✔
269	}
270	}

loresoft / FluentCommand / 6648415992

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous