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

50.0

/src/FluentCommand/Query/InsertBuilder.cs

using FluentCommand.Query.Generators;

namespace FluentCommand.Query;

/// <summary>
/// Insert query statement builder
/// </summary>
public class InsertBuilder : InsertBuilder<InsertBuilder>
{
    /// <summary>
    /// Initializes a new instance of the <see cref="InsertBuilder"/> class.
    /// </summary>
    /// <param name="queryGenerator">The query generator.</param>
    /// <param name="parameters">The parameters.</param>
    public InsertBuilder(
        IQueryGenerator queryGenerator,
        List<QueryParameter> parameters)
        : base(queryGenerator, parameters)
    { }
}

/// <summary>
/// Insert query statement builder
/// </summary>
/// <typeparam name="TBuilder">The type of the builder.</typeparam>
public abstract class InsertBuilder<TBuilder> : StatementBuilder<TBuilder>
    where TBuilder : InsertBuilder<TBuilder>
{
    /// <summary>
    /// Initializes a new instance of the <see cref="InsertBuilder{TBuilder}"/> class.
    /// </summary>
    /// <param name="queryGenerator">The query generator.</param>
    /// <param name="parameters">The query parameters.</param>
    protected InsertBuilder(
        IQueryGenerator queryGenerator,
        List<QueryParameter> parameters)
        : base(queryGenerator, parameters)
    {
    }

    /// <summary>
    /// Gets the column expressions.
    /// </summary>
    /// <value>
    /// The column expressions.
    /// </value>
    protected HashSet<ColumnExpression> ColumnExpressions { get; } = new();

    /// <summary>
    /// Gets the output expressions.
    /// </summary>
    /// <value>
    /// The output expressions.
    /// </value>
    protected HashSet<ColumnExpression> OutputExpressions { get; } = new();

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

    /// <summary>
    /// Gets the table expression.
    /// </summary>
    /// <value>
    /// The table expression.
    /// </value>
    protected TableExpression TableExpression { get; private set; }


    /// <summary>
    /// Set the target table to insert into.
    /// </summary>
    /// <param name="tableName">Name of the table.</param>
    /// <param name="tableSchema">The table schema.</param>
    /// <param name="tableAlias">The table alias.</param>
    /// <returns>
    /// The same builder so that multiple calls can be chained.
    /// </returns>
    public TBuilder Into(
        string tableName,
        string tableSchema = null,
        string tableAlias = null)
    {
        TableExpression = new TableExpression(tableName, tableSchema, tableAlias);

        return (TBuilder)this;
    }

    /// <summary>
    /// Adds a value with specified column name and value.
    /// </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>
    public TBuilder Value<TValue>(
        string columnName,
        TValue parameterValue)
    {
        return Value(columnName, parameterValue, typeof(TValue));
    }

    /// <summary>
    /// Adds a value with specified column name and value.
    /// </summary>
    /// <param name="columnName">Name of the column.</param>
    /// <param name="parameterValue">The parameter value.</param>
    /// <param name="parameterType">Type of the parameter.</param>
    /// <returns>
    /// The same builder so that multiple calls can be chained.
    /// </returns>
    public TBuilder Value(
        string columnName,
        object parameterValue,
        Type parameterType)
    {
        if (string.IsNullOrWhiteSpace(columnName))
            throw new ArgumentException($"'{nameof(columnName)}' cannot be null or empty.", nameof(columnName));

        if (parameterType is null)
            throw new ArgumentNullException(nameof(parameterType));

        var paramterName = NextParameter();

        var columnExpression = new ColumnExpression(columnName);

        ColumnExpressions.Add(columnExpression);
        ValueExpressions.Add(paramterName);

        Parameters.Add(new QueryParameter(paramterName, parameterValue, parameterType));

        return (TBuilder)this;
    }

    /// <summary>
    /// Conditionally adds a value with specified column name and value.
    /// </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="condition">The condition.</param>
    /// <returns>
    /// The same builder so that multiple calls can be chained.
    /// </returns>
    public TBuilder ValueIf<TValue>(
        string columnName,
        TValue parameterValue,
        Func<string, TValue, bool> condition)
    {
        if (condition != null && !condition(columnName, parameterValue))
            return (TBuilder)this;

        return Value(columnName, parameterValue);
    }


    /// <summary>
    /// Add an output clause for the specified column names.
    /// </summary>
    /// <param name="columnNames">The column names.</param>
    /// <param name="tableAlias">The table alias.</param>
    /// <returns>
    /// The same builder so that multiple calls can be chained.
    /// </returns>
    public TBuilder Output(
        IEnumerable<string> columnNames,
        string tableAlias = "INSERTED")
    {
        if (columnNames is null)
            throw new ArgumentNullException(nameof(columnNames));

        foreach (var column in columnNames)
            Output(column, tableAlias);

        return (TBuilder)this;
    }

    /// <summary>
    /// Add an output clause for the specified column name.
    /// </summary>
    /// <param name="columnName">Name of the column.</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 TBuilder Output(
        string columnName,
        string tableAlias = "INSERTED",
        string columnAlias = null)
    {
        var outputClause = new ColumnExpression(columnName, tableAlias, columnAlias);

        OutputExpressions.Add(outputClause);

        return (TBuilder)this;
    }

    /// <summary>
    /// Conditionally add an output clause for the specified column name.
    /// </summary>
    /// <param name="columnName">Name of the column.</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 TBuilder OutputIf(
        string columnName,
        string tableAlias = "INSERTED",
        string columnAlias = null,
        Func<string, bool> condition = null)
    {
        if (condition != null && !condition(columnName))
            return (TBuilder)this;

        return Output(columnName, tableAlias, columnAlias);
    }


    /// <inheritdoc />
    public override QueryStatement BuildStatement()
    {
        var insertStatement = new InsertStatement(
            TableExpression,
            ColumnExpressions,
            OutputExpressions,
            ValueExpressions,
            CommentExpressions);

        var statement = QueryGenerator.BuildInsert(insertStatement);

        return new QueryStatement(statement, Parameters);
    }
}

1	using FluentCommand.Query.Generators;
2
3	namespace FluentCommand.Query;
4
5	/// <summary>
6	/// Insert query statement builder
7	/// </summary>
8	public class InsertBuilder : InsertBuilder<InsertBuilder>
9	{
10	/// <summary>
11	/// Initializes a new instance of the <see cref="InsertBuilder"/> class.
12	/// </summary>
13	/// <param name="queryGenerator">The query generator.</param>
14	/// <param name="parameters">The parameters.</param>
15	public InsertBuilder(
16	IQueryGenerator queryGenerator,
17	List<QueryParameter> parameters)
18	: base(queryGenerator, parameters)	×
19	{ }	×
20	}
21
22	/// <summary>
23	/// Insert query statement builder
24	/// </summary>
25	/// <typeparam name="TBuilder">The type of the builder.</typeparam>
26	public abstract class InsertBuilder<TBuilder> : StatementBuilder<TBuilder>
27	where TBuilder : InsertBuilder<TBuilder>
28	{
29	/// <summary>
30	/// Initializes a new instance of the <see cref="InsertBuilder{TBuilder}"/> class.
31	/// </summary>
32	/// <param name="queryGenerator">The query generator.</param>
33	/// <param name="parameters">The query parameters.</param>
34	protected InsertBuilder(
35	IQueryGenerator queryGenerator,
36	List<QueryParameter> parameters)
37	: base(queryGenerator, parameters)	11✔
38	{
39	}	11✔
40
41	/// <summary>
42	/// Gets the column expressions.
43	/// </summary>
44	/// <value>
45	/// The column expressions.
46	/// </value>
47	protected HashSet<ColumnExpression> ColumnExpressions { get; } = new();	11✔
48
49	/// <summary>
50	/// Gets the output expressions.
51	/// </summary>
52	/// <value>
53	/// The output expressions.
54	/// </value>
55	protected HashSet<ColumnExpression> OutputExpressions { get; } = new();	11✔
56
57	/// <summary>
58	/// Gets the value expressions.
59	/// </summary>
60	/// <value>
61	/// The value expressions.
62	/// </value>
63	protected HashSet<string> ValueExpressions { get; } = new();	11✔
64
65	/// <summary>
66	/// Gets the table expression.
67	/// </summary>
68	/// <value>
69	/// The table expression.
70	/// </value>
71	protected TableExpression TableExpression { get; private set; }
72
73
74	/// <summary>
75	/// Set the target table to insert into.
76	/// </summary>
77	/// <param name="tableName">Name of the table.</param>
78	/// <param name="tableSchema">The table schema.</param>
79	/// <param name="tableAlias">The table alias.</param>
80	/// <returns>
81	/// The same builder so that multiple calls can be chained.
82	/// </returns>
83	public TBuilder Into(
84	string tableName,
85	string tableSchema = null,
86	string tableAlias = null)
87	{
88	TableExpression = new TableExpression(tableName, tableSchema, tableAlias);	11✔
89
90	return (TBuilder)this;	11✔
91	}
92
93	/// <summary>
94	/// Adds a value with specified column name and value.
95	/// </summary>
96	/// <typeparam name="TValue">The type of the value.</typeparam>
97	/// <param name="columnName">Name of the column.</param>
98	/// <param name="parameterValue">The parameter value.</param>
99	public TBuilder Value<TValue>(
100	string columnName,
101	TValue parameterValue)
102	{
103	return Value(columnName, parameterValue, typeof(TValue));	20✔
104	}
105
106	/// <summary>
107	/// Adds a value with specified column name and value.
108	/// </summary>
109	/// <param name="columnName">Name of the column.</param>
110	/// <param name="parameterValue">The parameter value.</param>
111	/// <param name="parameterType">Type of the parameter.</param>
112	/// <returns>
113	/// The same builder so that multiple calls can be chained.
114	/// </returns>
115	public TBuilder Value(
116	string columnName,
117	object parameterValue,
118	Type parameterType)
119	{
120	if (string.IsNullOrWhiteSpace(columnName))	146!
121	throw new ArgumentException($"'{nameof(columnName)}' cannot be null or empty.", nameof(columnName));	×
122
123	if (parameterType is null)	146!
124	throw new ArgumentNullException(nameof(parameterType));	×
125
126	var paramterName = NextParameter();	146✔
127
128	var columnExpression = new ColumnExpression(columnName);	146✔
129
130	ColumnExpressions.Add(columnExpression);	146✔
131	ValueExpressions.Add(paramterName);	146✔
132
133	Parameters.Add(new QueryParameter(paramterName, parameterValue, parameterType));	146✔
134
135	return (TBuilder)this;	146✔
136	}
137
138	/// <summary>
139	/// Conditionally adds a value with specified column name and value.
140	/// </summary>
141	/// <typeparam name="TValue">The type of the value.</typeparam>
142	/// <param name="columnName">Name of the column.</param>
143	/// <param name="parameterValue">The parameter value.</param>
144	/// <param name="condition">The condition.</param>
145	/// <returns>
146	/// The same builder so that multiple calls can be chained.
147	/// </returns>
148	public TBuilder ValueIf<TValue>(
149	string columnName,
150	TValue parameterValue,
151	Func<string, TValue, bool> condition)
152	{
153	if (condition != null && !condition(columnName, parameterValue))	×
154	return (TBuilder)this;	×
155
156	return Value(columnName, parameterValue);	×
157	}
158
159
160	/// <summary>
161	/// Add an output clause for the specified column names.
162	/// </summary>
163	/// <param name="columnNames">The column names.</param>
164	/// <param name="tableAlias">The table alias.</param>
165	/// <returns>
166	/// The same builder so that multiple calls can be chained.
167	/// </returns>
168	public TBuilder Output(
169	IEnumerable<string> columnNames,
170	string tableAlias = "INSERTED")
171	{
172	if (columnNames is null)	×
173	throw new ArgumentNullException(nameof(columnNames));	×
174
175	foreach (var column in columnNames)	×
176	Output(column, tableAlias);	×
177
178	return (TBuilder)this;	×
179	}
180
181	/// <summary>
182	/// Add an output clause for the specified column name.
183	/// </summary>
184	/// <param name="columnName">Name of the column.</param>
185	/// <param name="tableAlias">The table alias.</param>
186	/// <param name="columnAlias">The column alias.</param>
187	/// <returns>
188	/// The same builder so that multiple calls can be chained.
189	/// </returns>
190	public TBuilder Output(
191	string columnName,
192	string tableAlias = "INSERTED",
193	string columnAlias = null)
194	{
195	var outputClause = new ColumnExpression(columnName, tableAlias, columnAlias);	11✔
196
197	OutputExpressions.Add(outputClause);	11✔
198
199	return (TBuilder)this;	11✔
200	}
201
202	/// <summary>
203	/// Conditionally add an output clause for the specified column name.
204	/// </summary>
205	/// <param name="columnName">Name of the column.</param>
206	/// <param name="tableAlias">The table alias.</param>
207	/// <param name="columnAlias">The column alias.</param>
208	/// <param name="condition">The condition.</param>
209	/// <returns>
210	/// The same builder so that multiple calls can be chained.
211	/// </returns>
212	public TBuilder OutputIf(
213	string columnName,
214	string tableAlias = "INSERTED",
215	string columnAlias = null,
216	Func<string, bool> condition = null)
217	{
218	if (condition != null && !condition(columnName))	×
219	return (TBuilder)this;	×
220
221	return Output(columnName, tableAlias, columnAlias);	×
222	}
223
224
225	/// <inheritdoc />
226	public override QueryStatement BuildStatement()
227	{
228	var insertStatement = new InsertStatement(	11✔
229	TableExpression,	11✔
230	ColumnExpressions,	11✔
231	OutputExpressions,	11✔
232	ValueExpressions,	11✔
233	CommentExpressions);	11✔
234
235	var statement = QueryGenerator.BuildInsert(insertStatement);	11✔
236
237	return new QueryStatement(statement, Parameters);	11✔
238	}
239	}

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