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

29.41

/src/FluentCommand/Query/WhereBuilder.cs

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

namespace FluentCommand.Query;

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

    /// <inheritdoc />
    public override QueryStatement BuildStatement()
    {
        var statement = QueryGenerator.BuildWhere(
            whereExpressions: WhereExpressions
        );

        return new QueryStatement(statement, Parameters);
    }
}

/// <summary>
/// Where clause builder
/// </summary>
/// <typeparam name="TBuilder">The type of the builder.</typeparam>
public abstract class WhereBuilder<TBuilder> : StatementBuilder<TBuilder>
    where TBuilder : WhereBuilder<TBuilder>

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

    /// <summary>
    /// Gets the where expressions.
    /// </summary>
    /// <value>
    /// The where expressions.
    /// </value>
    protected HashSet<WhereExpression> WhereExpressions { get; } = new();

    /// <summary>
    /// Gets the logical operator.
    /// </summary>
    /// <value>
    /// The logical operator.
    /// </value>
    protected LogicalOperators LogicalOperator { get; }

    /// <summary>
    /// Create a where clause with the specified column, value and operator
    /// </summary>
    /// <typeparam name="TValue">The type of the value.</typeparam>
    /// <param name="columnName">Name of the column.</param>
    /// <param name="parameterValue">The parameter value.</param>
    /// <param name="filterOperator">The filter operator.</param>
    /// <returns>
    /// The same builder so that multiple calls can be chained.
    /// </returns>
    public TBuilder Where<TValue>(
       string columnName,
       TValue parameterValue,
       FilterOperators filterOperator = FilterOperators.Equal)
    {
        return Where(columnName, parameterValue, null, filterOperator);
    }

    /// <summary>
    /// Create a where clause with the specified column, value, operator and table alias
    /// </summary>
    /// <typeparam name="TValue">The type of the value.</typeparam>
    /// <param name="columnName">Name of the column.</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 TBuilder Where<TValue>(
        string columnName,
        TValue parameterValue,
        string tableAlias,
        FilterOperators filterOperator = FilterOperators.Equal)
    {
        var parameterName = NextParameter();

        WhereExpressions.Add(new WhereExpression(columnName, parameterName, tableAlias, filterOperator));
        Parameters.Add(new QueryParameter(parameterName, parameterValue, typeof(TValue)));

        return (TBuilder)this;
    }


    /// <summary>
    /// Create a where in clause with the specified column, values and table alias
    /// </summary>
    /// <typeparam name="TValue">The type of the value.</typeparam>
    /// <param name="columnName">Name of the column.</param>
    /// <param name="parameterValues">The parameter values.</param>
    /// <param name="tableAlias">The table alias.</param>
    /// <returns>
    /// The same builder so that multiple calls can be chained.
    /// </returns>
    public TBuilder WhereIn<TValue>(
        string columnName,
        IEnumerable<TValue> parameterValues,
        string tableAlias = null)
    {
        var parameterNames = new List<string>();
        foreach (var parameterValue in parameterValues)
        {
            var parameterName = NextParameter();
            var parameter = new QueryParameter(parameterName, parameterValue, typeof(TValue));

            Parameters.Add(parameter);
            parameterNames.Add(parameterName);
        }

        var whereParameter = parameterNames.ToDelimitedString();

        WhereExpressions.Add(new WhereExpression(columnName, whereParameter, tableAlias, FilterOperators.In));

        return (TBuilder)this;
    }

    /// <summary>
    /// Conditionally create a where in clause with the specified column and values
    /// </summary>
    /// <typeparam name="TValue">The type of the value.</typeparam>
    /// <param name="columnName">Name of the column.</param>
    /// <param name="parameterValues">The parameter values.</param>
    /// <param name="condition">The condition.</param>
    /// <returns>
    /// The same builder so that multiple calls can be chained.
    /// </returns>
    public TBuilder WhereInIf<TValue>(
        string columnName,
        IEnumerable<TValue> parameterValues,
        Func<string, IEnumerable<TValue>, bool> condition = null)
    {
        if (condition != null && !condition(columnName, parameterValues))
            return (TBuilder)this;

        return WhereIn(columnName, parameterValues);
    }

    /// <summary>
    /// Conditionally create a where in clause with the specified column, values and table alias
    /// </summary>
    /// <typeparam name="TValue">The type of the value.</typeparam>
    /// <param name="columnName">Name of the column.</param>
    /// <param name="parameterValues">The parameter values.</param>
    /// <param name="tableAlias">The table alias.</param>
    /// <param name="condition">The condition.</param>
    /// <returns>
    /// The same builder so that multiple calls can be chained.
    /// </returns>
    public TBuilder WhereInIf<TValue>(
        string columnName,
        IEnumerable<TValue> parameterValues,
        string tableAlias,
        Func<string, IEnumerable<TValue>, bool> condition = null)
    {
        if (condition != null && !condition(columnName, parameterValues))
            return (TBuilder)this;

        return WhereIn(columnName, parameterValues, tableAlias);
    }

    /// <summary>
    /// Conditionally create a where clause with the specified column, value and operator
    /// </summary>
    /// <typeparam name="TValue">The type of the value.</typeparam>
    /// <param name="columnName">Name of the column.</param>
    /// <param name="parameterValue">The parameter value.</param>
    /// <param name="filterOperator">The filter operator.</param>
    /// <param name="condition">The condition.</param>
    /// <returns>
    /// The same builder so that multiple calls can be chained.
    /// </returns>
    public TBuilder WhereIf<TValue>(
        string columnName,
        TValue parameterValue,
        FilterOperators filterOperator = FilterOperators.Equal,
        Func<string, TValue, bool> condition = null)
    {
        return WhereIf(columnName, parameterValue, null, filterOperator, condition);
    }

    /// <summary>
    /// Conditionally create a where clause with the specified property, value, operator and table alias
    /// </summary>
    /// <typeparam name="TValue">The type of the value.</typeparam>
    /// <param name="columnName">Name of the column.</param>
    /// <param name="parameterValue">The parameter value.</param>
    /// <param name="tableAlias">The table alias.</param>
    /// <param name="filterOperator">The filter operator.</param>
    /// <param name="condition">The condition.</param>
    /// <returns>
    /// The same builder so that multiple calls can be chained.
    /// </returns>
    public TBuilder WhereIf<TValue>(
        string columnName,
        TValue parameterValue,
        string tableAlias,
        FilterOperators filterOperator = FilterOperators.Equal,
        Func<string, TValue, bool> condition = null)
    {
        if (condition != null && !condition(columnName, parameterValue))
            return (TBuilder)this;

        return Where(columnName, parameterValue, tableAlias, filterOperator);
    }

    /// <summary>
    /// Create a where clause with the specified raw query
    /// </summary>
    /// <param name="whereClause">The where clause.</param>
    /// <param name="parameters">The parameters.</param>
    /// <returns></returns>
    public TBuilder WhereRaw(
        string whereClause,
        IEnumerable<QueryParameter> parameters = null)
    {
        if (string.IsNullOrWhiteSpace(whereClause))
            throw new ArgumentException($"'{nameof(whereClause)}' cannot be null or empty.", nameof(whereClause));

        WhereExpressions.Add(new WhereExpression(whereClause, IsRaw: true));

        if (parameters != null)
            Parameters.AddRange(parameters);

        return (TBuilder)this;
    }

    /// <summary>
    /// Conditionally create a where clause with the specified raw query
    /// </summary>
    /// <param name="whereClause">The where clause.</param>
    /// <param name="parameters">The parameters.</param>
    /// <param name="condition">The condition.</param>
    /// <returns></returns>
    public TBuilder WhereRawIf(
        string whereClause,
        IEnumerable<QueryParameter> parameters = null,
        Func<string, IEnumerable<QueryParameter>, bool> condition = null)
    {
        if (condition != null && !condition(whereClause, parameters))
            return (TBuilder)this;

        return WhereRaw(whereClause, parameters);
    }

    /// <summary>
    /// Create a logical AND where clause group
    /// </summary>
    /// <param name="builder">The logical AND where clause builder.</param>
    /// <returns>
    /// The same builder so that multiple calls can be chained.
    /// </returns>
    public TBuilder WhereOr(Action<LogicalBuilder> builder)
    {
        var innerBuilder = new LogicalBuilder(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 (TBuilder)this;
    }

    /// <summary>
    /// Create a logical OR where clause group
    /// </summary>
    /// <param name="builder">The logical OR where clause builder.</param>
    /// <returns>
    /// The same builder so that multiple calls can be chained.
    /// </returns>
    public TBuilder WhereAnd(Action<LogicalBuilder> builder)
    {
        var innerBuilder = new LogicalBuilder(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 (TBuilder)this;
    }
}

1	using FluentCommand.Extensions;
2	using FluentCommand.Query.Generators;
3
4	namespace FluentCommand.Query;
5
6	/// <summary>
7	/// Where clause builder
8	/// </summary>
9	public class WhereBuilder : WhereBuilder<WhereBuilder>
10	{
11	/// <summary>
12	/// Initializes a new instance of the <see cref="WhereBuilder"/> class.
13	/// </summary>
14	/// <param name="queryGenerator">The query generator.</param>
15	/// <param name="parameters">The parameters.</param>
16	/// <param name="logicalOperator">The logical operator.</param>
17	public WhereBuilder(
18	IQueryGenerator queryGenerator,
19	List<QueryParameter> parameters,
20	LogicalOperators logicalOperator = LogicalOperators.And)
21	: base(queryGenerator, parameters, logicalOperator)	×
22	{
23	}	×
24
25	/// <inheritdoc />
26	public override QueryStatement BuildStatement()
27	{
28	var statement = QueryGenerator.BuildWhere(	×
29	whereExpressions: WhereExpressions	×
30	);	×
31
32	return new QueryStatement(statement, Parameters);	×
33	}
34	}
35
36	/// <summary>
37	/// Where clause builder
38	/// </summary>
39	/// <typeparam name="TBuilder">The type of the builder.</typeparam>
40	public abstract class WhereBuilder<TBuilder> : StatementBuilder<TBuilder>
41	where TBuilder : WhereBuilder<TBuilder>
42
43	{
44	/// <summary>
45	/// Initializes a new instance of the <see cref="WhereBuilder{TBuilder}"/> class.
46	/// </summary>
47	/// <param name="queryGenerator">The query generator.</param>
48	/// <param name="parameters">The query parameters.</param>
49	/// <param name="logicalOperator">The logical operator.</param>
50	protected WhereBuilder(IQueryGenerator queryGenerator, List<QueryParameter> parameters, LogicalOperators logicalOperator = LogicalOperators.And)
51	: base(queryGenerator, parameters)	66✔
52	{
53	LogicalOperator = logicalOperator;	66✔
54	}	66✔
55
56	/// <summary>
57	/// Gets the where expressions.
58	/// </summary>
59	/// <value>
60	/// The where expressions.
61	/// </value>
62	protected HashSet<WhereExpression> WhereExpressions { get; } = new();	66✔
63
64	/// <summary>
65	/// Gets the logical operator.
66	/// </summary>
67	/// <value>
68	/// The logical operator.
69	/// </value>
70	protected LogicalOperators LogicalOperator { get; }
71
72	/// <summary>
73	/// Create a where clause with the specified column, value and operator
74	/// </summary>
75	/// <typeparam name="TValue">The type of the value.</typeparam>
76	/// <param name="columnName">Name of the column.</param>
77	/// <param name="parameterValue">The parameter value.</param>
78	/// <param name="filterOperator">The filter operator.</param>
79	/// <returns>
80	/// The same builder so that multiple calls can be chained.
81	/// </returns>
82	public TBuilder Where<TValue>(
83	string columnName,
84	TValue parameterValue,
85	FilterOperators filterOperator = FilterOperators.Equal)
86	{
87	return Where(columnName, parameterValue, null, filterOperator);	2✔
88	}
89
90	/// <summary>
91	/// Create a where clause with the specified column, value, operator and table alias
92	/// </summary>
93	/// <typeparam name="TValue">The type of the value.</typeparam>
94	/// <param name="columnName">Name of the column.</param>
95	/// <param name="parameterValue">The parameter value.</param>
96	/// <param name="tableAlias">The table alias.</param>
97	/// <param name="filterOperator">The filter operator.</param>
98	/// <returns>
99	/// The same builder so that multiple calls can be chained.
100	/// </returns>
101	public TBuilder Where<TValue>(
102	string columnName,
103	TValue parameterValue,
104	string tableAlias,
105	FilterOperators filterOperator = FilterOperators.Equal)
106	{
107	var parameterName = NextParameter();	49✔
108
109	WhereExpressions.Add(new WhereExpression(columnName, parameterName, tableAlias, filterOperator));	49✔
110	Parameters.Add(new QueryParameter(parameterName, parameterValue, typeof(TValue)));	49✔
111
112	return (TBuilder)this;	49✔
113	}
114
115
116	/// <summary>
117	/// Create a where in clause with the specified column, values and table alias
118	/// </summary>
119	/// <typeparam name="TValue">The type of the value.</typeparam>
120	/// <param name="columnName">Name of the column.</param>
121	/// <param name="parameterValues">The parameter values.</param>
122	/// <param name="tableAlias">The table alias.</param>
123	/// <returns>
124	/// The same builder so that multiple calls can be chained.
125	/// </returns>
126	public TBuilder WhereIn<TValue>(
127	string columnName,
128	IEnumerable<TValue> parameterValues,
129	string tableAlias = null)
130	{
131	var parameterNames = new List<string>();	9✔
132	foreach (var parameterValue in parameterValues)	64✔
133	{
134	var parameterName = NextParameter();	23✔
135	var parameter = new QueryParameter(parameterName, parameterValue, typeof(TValue));	23✔
136
137	Parameters.Add(parameter);	23✔
138	parameterNames.Add(parameterName);	23✔
139	}
140
141	var whereParameter = parameterNames.ToDelimitedString();	9✔
142
143	WhereExpressions.Add(new WhereExpression(columnName, whereParameter, tableAlias, FilterOperators.In));	9✔
144
145	return (TBuilder)this;	9✔
146	}
147
148	/// <summary>
149	/// Conditionally create a where in clause with the specified column and values
150	/// </summary>
151	/// <typeparam name="TValue">The type of the value.</typeparam>
152	/// <param name="columnName">Name of the column.</param>
153	/// <param name="parameterValues">The parameter values.</param>
154	/// <param name="condition">The condition.</param>
155	/// <returns>
156	/// The same builder so that multiple calls can be chained.
157	/// </returns>
158	public TBuilder WhereInIf<TValue>(
159	string columnName,
160	IEnumerable<TValue> parameterValues,
161	Func<string, IEnumerable<TValue>, bool> condition = null)
162	{
163	if (condition != null && !condition(columnName, parameterValues))	1!
164	return (TBuilder)this;	×
165
166	return WhereIn(columnName, parameterValues);	1✔
167	}
168
169	/// <summary>
170	/// Conditionally create a where in clause with the specified column, values and table alias
171	/// </summary>
172	/// <typeparam name="TValue">The type of the value.</typeparam>
173	/// <param name="columnName">Name of the column.</param>
174	/// <param name="parameterValues">The parameter values.</param>
175	/// <param name="tableAlias">The table alias.</param>
176	/// <param name="condition">The condition.</param>
177	/// <returns>
178	/// The same builder so that multiple calls can be chained.
179	/// </returns>
180	public TBuilder WhereInIf<TValue>(
181	string columnName,
182	IEnumerable<TValue> parameterValues,
183	string tableAlias,
184	Func<string, IEnumerable<TValue>, bool> condition = null)
185	{
186	if (condition != null && !condition(columnName, parameterValues))	×
187	return (TBuilder)this;	×
188
189	return WhereIn(columnName, parameterValues, tableAlias);	×
190	}
191
192	/// <summary>
193	/// Conditionally create a where clause with the specified column, value and operator
194	/// </summary>
195	/// <typeparam name="TValue">The type of the value.</typeparam>
196	/// <param name="columnName">Name of the column.</param>
197	/// <param name="parameterValue">The parameter value.</param>
198	/// <param name="filterOperator">The filter operator.</param>
199	/// <param name="condition">The condition.</param>
200	/// <returns>
201	/// The same builder so that multiple calls can be chained.
202	/// </returns>
203	public TBuilder WhereIf<TValue>(
204	string columnName,
205	TValue parameterValue,
206	FilterOperators filterOperator = FilterOperators.Equal,
207	Func<string, TValue, bool> condition = null)
208	{
209	return WhereIf(columnName, parameterValue, null, filterOperator, condition);	×
210	}
211
212	/// <summary>
213	/// Conditionally create a where clause with the specified property, value, operator and table alias
214	/// </summary>
215	/// <typeparam name="TValue">The type of the value.</typeparam>
216	/// <param name="columnName">Name of the column.</param>
217	/// <param name="parameterValue">The parameter value.</param>
218	/// <param name="tableAlias">The table alias.</param>
219	/// <param name="filterOperator">The filter operator.</param>
220	/// <param name="condition">The condition.</param>
221	/// <returns>
222	/// The same builder so that multiple calls can be chained.
223	/// </returns>
224	public TBuilder WhereIf<TValue>(
225	string columnName,
226	TValue parameterValue,
227	string tableAlias,
228	FilterOperators filterOperator = FilterOperators.Equal,
229	Func<string, TValue, bool> condition = null)
230	{
231	if (condition != null && !condition(columnName, parameterValue))	×
232	return (TBuilder)this;	×
233
234	return Where(columnName, parameterValue, tableAlias, filterOperator);	×
235	}
236
237	/// <summary>
238	/// Create a where clause with the specified raw query
239	/// </summary>
240	/// <param name="whereClause">The where clause.</param>
241	/// <param name="parameters">The parameters.</param>
242	/// <returns></returns>
243	public TBuilder WhereRaw(
244	string whereClause,
245	IEnumerable<QueryParameter> parameters = null)
246	{
247	if (string.IsNullOrWhiteSpace(whereClause))	×
248	throw new ArgumentException($"'{nameof(whereClause)}' cannot be null or empty.", nameof(whereClause));	×
249
250	WhereExpressions.Add(new WhereExpression(whereClause, IsRaw: true));	×
251
252	if (parameters != null)	×
253	Parameters.AddRange(parameters);	×
254
255	return (TBuilder)this;	×
256	}
257
258	/// <summary>
259	/// Conditionally create a where clause with the specified raw query
260	/// </summary>
261	/// <param name="whereClause">The where clause.</param>
262	/// <param name="parameters">The parameters.</param>
263	/// <param name="condition">The condition.</param>
264	/// <returns></returns>
265	public TBuilder WhereRawIf(
266	string whereClause,
267	IEnumerable<QueryParameter> parameters = null,
268	Func<string, IEnumerable<QueryParameter>, bool> condition = null)
269	{
270	if (condition != null && !condition(whereClause, parameters))	×
271	return (TBuilder)this;	×
272
273	return WhereRaw(whereClause, parameters);	×
274	}
275
276	/// <summary>
277	/// Create a logical AND where clause group
278	/// </summary>
279	/// <param name="builder">The logical AND where clause builder.</param>
280	/// <returns>
281	/// The same builder so that multiple calls can be chained.
282	/// </returns>
283	public TBuilder WhereOr(Action<LogicalBuilder> builder)
284	{
285	var innerBuilder = new LogicalBuilder(QueryGenerator, Parameters, LogicalOperators.Or);	×
286	builder(innerBuilder);	×
287
288	var statement = innerBuilder.BuildStatement();	×
289
290	if (statement != null && statement.Statement.HasValue())	×
291	WhereExpressions.Add(new WhereExpression(statement.Statement, IsRaw: true));	×
292
293	return (TBuilder)this;	×
294	}
295
296	/// <summary>
297	/// Create a logical OR where clause group
298	/// </summary>
299	/// <param name="builder">The logical OR where clause builder.</param>
300	/// <returns>
301	/// The same builder so that multiple calls can be chained.
302	/// </returns>
303	public TBuilder WhereAnd(Action<LogicalBuilder> builder)
304	{
305	var innerBuilder = new LogicalBuilder(QueryGenerator, Parameters, LogicalOperators.And);	×
306
307	builder(innerBuilder);	×
308
309	var statement = innerBuilder.BuildStatement();	×
310
311	if (statement != null && statement.Statement.HasValue())	×
312	WhereExpressions.Add(new WhereExpression(statement.Statement, IsRaw: true));	×
313
314	return (TBuilder)this;	×
315	}
316	}

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