Updated exception texts, methods descriptions, consolidated params' names and minor code tidying

snalesso · snalesso · commit 503ca6fc3669 · 2020-09-19T19:59:23.000+02:00
diff --git a/QueryBuilder.Tests/GeneralTests.cs b/QueryBuilder.Tests/GeneralTests.cs
@@ -291,7 +291,7 @@ public void CompilerSpecificLimit()
             var engines = new[] { EngineCodes.SqlServer, EngineCodes.MySql, EngineCodes.PostgreSql };
             var c = Compilers.Compile(engines, query);
 
-            Assert.Equal(2, query.GetComponents("limit").Count());
+            Assert.Equal(2, query.GetComponents("limit").Count);
             Assert.Equal("SELECT TOP (5) * FROM [mytable]", c[EngineCodes.SqlServer].ToString());
             Assert.Equal("SELECT * FROM \"mytable\" LIMIT 10", c[EngineCodes.PostgreSql].ToString());
             Assert.Equal("SELECT * FROM `mytable`", c[EngineCodes.MySql].ToString());
@@ -319,7 +319,7 @@ public void CompilerSpecificOffset()
             var engines = new[] { EngineCodes.SqlServer, EngineCodes.MySql, EngineCodes.PostgreSql };
             var c = Compilers.Compile(engines, query);
 
-            Assert.Equal(2, query.GetComponents("offset").Count());
+            Assert.Equal(2, query.GetComponents("offset").Count);
             Assert.Equal("SELECT * FROM `mytable` LIMIT 18446744073709551615 OFFSET 5", c[EngineCodes.MySql].ToString());
             Assert.Equal("SELECT * FROM \"mytable\" OFFSET 10", c[EngineCodes.PostgreSql].ToString());
             Assert.Equal("SELECT * FROM [mytable]", c[EngineCodes.SqlServer].ToString());
diff --git a/QueryBuilder.Tests/InfrastructureTests.cs b/QueryBuilder.Tests/InfrastructureTests.cs
@@ -47,7 +47,7 @@ public void ShouldThrowIfInvalidEngineCode()
         [Fact]
         public void ShouldThrowIfAnyEngineCodesAreInvalid()
         {
-            var codes = new[] {EngineCodes.SqlServer, "123", EngineCodes.MySql, "abc"};
+            var codes = new[] { EngineCodes.SqlServer, "123", EngineCodes.MySql, "abc" };
             Assert.Throws<InvalidOperationException>(() => Compilers.Compile(codes, new Query()));
         }
     }
diff --git a/QueryBuilder/Base.Where.cs b/QueryBuilder/Base.Where.cs
@@ -526,7 +526,7 @@ public Q WhereExists(Query query)
         {
             if (!query.HasComponent("from"))
             {
-                throw new ArgumentException("'FromClause' cannot be empty if used inside a 'WhereExists' condition");
+                throw new ArgumentException($"'{nameof(FromClause)}' cannot be empty if used inside a '{nameof(WhereExists)}' condition");
             }
 
             // remove unneeded components
@@ -573,8 +573,6 @@ public Q OrWhereNotExists(Func<Query, Query> callback)
             return Or().Not().WhereExists(callback);
         }
 
-
-
         #region date
         public Q WhereDatePart(string part, string column, string op, object value)
         {
@@ -691,6 +689,5 @@ public Q OrWhereNotTime(string column, object value)
         }
 
         #endregion
-
     }
 }
diff --git a/QueryBuilder/BaseQuery.cs b/QueryBuilder/BaseQuery.cs
@@ -45,7 +45,7 @@ public Q SetParent(AbstractQuery parent)
         {
             if (this == parent)
             {
-                throw new ArgumentException("Cannot set the same query as a parent of itself");
+                throw new ArgumentException($"Cannot set the same {nameof(AbstractQuery)} as a parent of itself");
             }
 
             this.Parent = parent;
diff --git a/QueryBuilder/Clauses/ConditionClause.cs b/QueryBuilder/Clauses/ConditionClause.cs
@@ -48,7 +48,7 @@ public string EscapeCharacter
                 if (string.IsNullOrWhiteSpace(value))
                     value = null;
                 else if (value.Length > 1)
-                    throw new ArgumentOutOfRangeException("The EscapeCharacter can only contain a single character!");
+                    throw new ArgumentOutOfRangeException($"The {nameof(EscapeCharacter)} can only contain a single character!");
                 escapeCharacter = value;
             }
         }
diff --git a/QueryBuilder/ColumnAttribute.cs b/QueryBuilder/ColumnAttribute.cs
@@ -12,15 +12,13 @@ public ColumnAttribute(string name)
         {
             if (string.IsNullOrEmpty(name))
             {
-                throw new ArgumentNullException("Name parameter is required");
+                throw new ArgumentNullException(nameof(name));
             }
 
             Name = name;
         }
-
     }
 
-
     /// <summary>
     /// This class is used as metadata on a property to determine if it is a primary key
     /// </summary>
diff --git a/QueryBuilder/Compilers/ConditionsCompilerProvider.cs b/QueryBuilder/Compilers/ConditionsCompilerProvider.cs
@@ -40,7 +40,7 @@ private MethodInfo FindMethodInfo(Type clauseType, string methodName)
 
             if (methodInfo == null)
             {
-                throw new Exception($"Failed to locate a compiler for {methodName}.");
+                throw new Exception($"Failed to locate a compiler for '{methodName}'.");
             }
 
             if (clauseType.IsConstructedGenericType && methodInfo.GetGenericArguments().Any())
diff --git a/QueryBuilder/Compilers/SqliteCompiler.cs b/QueryBuilder/Compilers/SqliteCompiler.cs
@@ -43,13 +43,13 @@ protected override string CompileBasicDateCondition(SqlResult ctx, BasicDateCond
             var value = Parameter(ctx, condition.Value);
 
             var formatMap = new Dictionary<string, string> {
-                {"date", "%Y-%m-%d"},
-                {"time", "%H:%M:%S"},
-                {"year", "%Y"},
-                {"month", "%m"},
-                {"day", "%d"},
-                {"hour", "%H"},
-                {"minute", "%M"},
+                { "date", "%Y-%m-%d" },
+                { "time", "%H:%M:%S" },
+                { "year", "%Y" },
+                { "month", "%m" },
+                { "day", "%d" },
+                { "hour", "%H" },
+                { "minute", "%M" },
             };
 
             if (!formatMap.ContainsKey(condition.Part))
@@ -66,6 +66,5 @@ protected override string CompileBasicDateCondition(SqlResult ctx, BasicDateCond
 
             return sql;
         }
-
     }
 }
diff --git a/QueryBuilder/Query.Having.cs b/QueryBuilder/Query.Having.cs
@@ -488,7 +488,7 @@ public Query HavingExists(Query query)
         {
             if (!query.HasComponent("from"))
             {
-                throw new ArgumentException("'FromClause' cannot be empty if used inside a 'HavingExists' condition");
+                throw new ArgumentException($"{nameof(FromClause)} cannot be empty if used inside a {nameof(HavingExists)} condition");
             }
 
             // simplify the query as much as possible
diff --git a/QueryBuilder/Query.Insert.cs b/QueryBuilder/Query.Insert.cs
@@ -9,9 +9,9 @@ public partial class Query
     {
         public Query AsInsert(object data, bool returnId = false)
         {
-            var dictionary = BuildKeyValuePairsFromObject(data);
+            var propertiesKeyValues = BuildKeyValuePairsFromObject(data);
 
-            return AsInsert(dictionary, returnId);
+            return AsInsert(propertiesKeyValues, returnId);
         }
 
         public Query AsInsert(IEnumerable<string> columns, IEnumerable<object> values)
@@ -21,12 +21,12 @@ public Query AsInsert(IEnumerable<string> columns, IEnumerable<object> values)
 
             if ((columnsList?.Count ?? 0) == 0 || (valuesList?.Count ?? 0) == 0)
             {
-                throw new InvalidOperationException("Columns and Values cannot be null or empty");
+                throw new InvalidOperationException($"{nameof(columns)} and {nameof(values)} cannot be null or empty");
             }
 
             if (columnsList.Count != valuesList.Count)
             {
-                throw new InvalidOperationException("Columns count should be equal to Values count");
+                throw new InvalidOperationException($"{nameof(columns)} and {nameof(values)} cannot be null or empty");
             }
 
             Method = "insert";
@@ -40,19 +40,19 @@ public Query AsInsert(IEnumerable<string> columns, IEnumerable<object> values)
             return this;
         }
 
-        public Query AsInsert(IEnumerable<KeyValuePair<string, object>> data, bool returnId = false)
+        public Query AsInsert(IEnumerable<KeyValuePair<string, object>> values, bool returnId = false)
         {
-            if (data == null || data.Any() == false)
+            if (values == null || values.Any() == false)
             {
-                throw new InvalidOperationException("Values dictionary cannot be null or empty");
+                throw new InvalidOperationException($"{values} argument cannot be null or empty");
             }
 
             Method = "insert";
 
             ClearComponent("insert").AddComponent("insert", new InsertClause
             {
-                Columns = data.Select(x=>x.Key).ToList(),
-                Values = data.Select(x => x.Value).ToList(),
+                Columns = values.Select(x=>x.Key).ToList(),
+                Values = values.Select(x => x.Value).ToList(),
                 ReturnId = returnId,
             });
 
@@ -63,16 +63,16 @@ public Query AsInsert(IEnumerable<KeyValuePair<string, object>> data, bool retur
         /// Produces insert multi records
         /// </summary>
         /// <param name="columns"></param>
-        /// <param name="valuesCollection"></param>
+        /// <param name="rowsValues"></param>
         /// <returns></returns>
-        public Query AsInsert(IEnumerable<string> columns, IEnumerable<IEnumerable<object>> valuesCollection)
+        public Query AsInsert(IEnumerable<string> columns, IEnumerable<IEnumerable<object>> rowsValues)
         {
             var columnsList = columns?.ToList();
-            var valuesCollectionList = valuesCollection?.ToList();
+            var valuesCollectionList = rowsValues?.ToList();
 
             if ((columnsList?.Count ?? 0) == 0 || (valuesCollectionList?.Count ?? 0) == 0)
             {
-                throw new InvalidOperationException("Columns and valuesCollection cannot be null or empty");
+                throw new InvalidOperationException($"{nameof(columns)} and {nameof(rowsValues)} cannot be null or empty");
             }
 
             Method = "insert";
@@ -84,7 +84,7 @@ public Query AsInsert(IEnumerable<string> columns, IEnumerable<IEnumerable<objec
                 var valuesList = values.ToList();
                 if (columnsList.Count != valuesList.Count)
                 {
-                    throw new InvalidOperationException("Columns count should be equal to each Values count");
+                    throw new InvalidOperationException($"{nameof(columns)} count should be equal to each {nameof(rowsValues)} entry count");
                 }
 
                 AddComponent("insert", new InsertClause
@@ -115,6 +115,5 @@ public Query AsInsert(IEnumerable<string> columns, Query query)
 
             return this;
         }
-
     }
 }
diff --git a/QueryBuilder/Query.Update.cs b/QueryBuilder/Query.Update.cs
@@ -5,10 +5,8 @@
 
 namespace SqlKata
 {
-
     public partial class Query
     {
-
         public Query AsUpdate(object data)
         {
             var dictionary = BuildKeyValuePairsFromObject(data, considerKeys: true);
@@ -18,15 +16,14 @@ public Query AsUpdate(object data)
 
         public Query AsUpdate(IEnumerable<string> columns, IEnumerable<object> values)
         {
-
-            if ((columns?.Count() ?? 0) == 0 || (values?.Count() ?? 0) == 0)
+            if ((columns?.Any() ?? false) == false || (values?.Any() ?? false) == false)
             {
-                throw new InvalidOperationException("Columns and Values cannot be null or empty");
+                throw new InvalidOperationException($"{columns} and {values} cannot be null or empty");
             }
 
             if (columns.Count() != values.Count())
             {
-                throw new InvalidOperationException("Columns count should be equal to Values count");
+                throw new InvalidOperationException($"{columns} count should be equal to {values} count");
             }
 
             Method = "update";
@@ -40,24 +37,22 @@ public Query AsUpdate(IEnumerable<string> columns, IEnumerable<object> values)
             return this;
         }
 
-        public Query AsUpdate(IEnumerable<KeyValuePair<string, object>> data)
+        public Query AsUpdate(IEnumerable<KeyValuePair<string, object>> values)
         {
-
-            if (data == null || data.Any() == false)
+            if (values == null || values.Any() == false)
             {
-                throw new InvalidOperationException("Values dictionary cannot be null or empty");
+                throw new InvalidOperationException($"{values} cannot be null or empty");
             }
 
             Method = "update";
 
             ClearComponent("update").AddComponent("update", new InsertClause
             {
-                Columns = data.Select(x => x.Key).ToList(),
-                Values = data.Select(x => x.Value).ToList(),
+                Columns = values.Select(x => x.Key).ToList(),
+                Values = values.Select(x => x.Value).ToList(),
             });
 
             return this;
         }
-
     }
 }
diff --git a/QueryBuilder/Query.cs b/QueryBuilder/Query.cs
@@ -24,7 +24,6 @@ public Query(string table, string comment = null) : base()
             Comment(comment);
         }
 
-
         public bool HasOffset(string engineCode = null) => GetOffset(engineCode) > 0;
 
         public bool HasLimit(string engineCode = null) => GetLimit(engineCode) > 0;
@@ -345,17 +344,16 @@ public object FindVariable(string variable)
         }
 
         /// <summary>
-        /// Build a dictionary from plain object, intended to be used with Insert and Update queries
+        /// Gather a list of key-values representing the properties of the object and their values.
         /// </summary>
-        /// <param name="data">the plain C# object</param>
+        /// <param name="data">The plain C# object</param>
         /// <param name="considerKeys">
         /// When true it will search for properties with the [Key] attribute
-        /// and add it automatically to the Where clause
+        /// and will add it automatically to the Where clause
         /// </param>
         /// <returns></returns>
         private IEnumerable<KeyValuePair<string, object>> BuildKeyValuePairsFromObject(object data, bool considerKeys = false)
         {
-
             var dictionary = new Dictionary<string, object>();
             var props = data.GetType().GetRuntimeProperties();
 
@@ -381,11 +379,9 @@ private IEnumerable<KeyValuePair<string, object>> BuildKeyValuePairsFromObject(o
                         this.Where(name, value);
                     }
                 }
-
             }
 
             return dictionary;
         }
-
     }
 }
diff --git a/QueryBuilder/SqlResult.cs b/QueryBuilder/SqlResult.cs
@@ -34,7 +34,7 @@ public override string ToString()
                 if (i >= deepParameters.Count)
                 {
                     throw new Exception(
-                        $"Failed to retrieve a binding at the index {i}, the total bindings count is {Bindings.Count}");
+                        $"Failed to retrieve a binding at index {i}, the total bindings count is {Bindings.Count}");
                 }
 
                 var value = deepParameters[i];
@@ -44,7 +44,6 @@ public override string ToString()
 
         private string ChangeToSqlValue(object value)
         {
-
             if (value == null)
             {
                 return "NULL";
@@ -83,8 +82,5 @@ private string ChangeToSqlValue(object value)
             // fallback to string
             return "'" + value.ToString() + "'";
         }
-
-
-
     }
 }
diff --git a/SqlKata.Execution/Query.Extensions.cs b/SqlKata.Execution/Query.Extensions.cs
@@ -324,10 +324,15 @@ internal static XQuery CastToXQuery(Query query, string method = null)
             {
                 if (method == null)
                 {
-                    throw new InvalidOperationException($"Execution methods can only be used with `XQuery` instances, consider using the `QueryFactory.Query()` to create executable queries, check https://sqlkata.com/docs/execution/setup#xquery-class for more info");
+                    throw new InvalidOperationException(
+                        $"Execution methods can only be used with `{nameof(XQuery)}` instances, " +
+                        $"consider using the `{nameof(QueryFactory)}.{nameof(QueryFactory.Query)}()` to create executable queries, " +
+                        $"check https://sqlkata.com/docs/execution/setup#xquery-class for more info");
                 }
 
-                throw new InvalidOperationException($"The method ${method} can only be used with `XQuery` instances, consider using the `QueryFactory.Query()` to create executable queries, check https://sqlkata.com/docs/execution/setup#xquery-class for more info");
+                throw new InvalidOperationException($"The method '{method}()' can only be used with `{nameof(XQuery)}` instances, " +
+                    $"consider using the `{nameof(QueryFactory)}.{nameof(QueryFactory.Query)}()` to create executable queries, " +
+                    $"check https://sqlkata.com/docs/execution/setup#xquery-class for more info");
             }
 
             return xQuery;
@@ -346,6 +351,5 @@ internal static QueryFactory CreateQueryFactory(Query query)
         {
             return CreateQueryFactory(CastToXQuery(query));
         }
-
     }
 }
diff --git a/SqlKata.Execution/QueryFactory.cs b/SqlKata.Execution/QueryFactory.cs

Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ public void ShouldThrowIfInvalidEngineCode()`
`47`	`47`	`[Fact]`
`48`	`48`	`public void ShouldThrowIfAnyEngineCodesAreInvalid()`
`49`	`49`	`{`
`50`		`- var codes = new[] {EngineCodes.SqlServer, "123", EngineCodes.MySql, "abc"};`
	`50`	`+ var codes = new[] { EngineCodes.SqlServer, "123", EngineCodes.MySql, "abc" };`
`51`	`51`	`Assert.Throws<InvalidOperationException>(() => Compilers.Compile(codes, new Query()));`
`52`	`52`	`}`
`53`	`53`	`}`
Original file line number	Diff line number	Diff line change
`@@ -526,7 +526,7 @@ public Q WhereExists(Query query)`
`526`	`526`	`{`
`527`	`527`	`if (!query.HasComponent("from"))`
`528`	`528`	`{`
`529`		`- throw new ArgumentException("'FromClause' cannot be empty if used inside a 'WhereExists' condition");`
	`529`	`+ throw new ArgumentException($"'{nameof(FromClause)}' cannot be empty if used inside a '{nameof(WhereExists)}' condition");`
`530`	`530`	`}`
`531`	`531`
`532`	`532`	`// remove unneeded components`
`@@ -573,8 +573,6 @@ public Q OrWhereNotExists(Func<Query, Query> callback)`
`573`	`573`	`return Or().Not().WhereExists(callback);`
`574`	`574`	`}`
`575`	`575`
`576`		`-`
`577`		`-`
`578`	`576`	`#region date`
`579`	`577`	`public Q WhereDatePart(string part, string column, string op, object value)`
`580`	`578`	`{`
`@@ -691,6 +689,5 @@ public Q OrWhereNotTime(string column, object value)`
`691`	`689`	`}`
`692`	`690`
`693`	`691`	`#endregion`
`694`		`-`
`695`	`692`	`}`
`696`	`693`	`}`
Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ public Q SetParent(AbstractQuery parent)`
`45`	`45`	`{`
`46`	`46`	`if (this == parent)`
`47`	`47`	`{`
`48`		`- throw new ArgumentException("Cannot set the same query as a parent of itself");`
	`48`	`+ throw new ArgumentException($"Cannot set the same {nameof(AbstractQuery)} as a parent of itself");`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`this.Parent = parent;`
Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,7 @@ public string EscapeCharacter`
`48`	`48`	`if (string.IsNullOrWhiteSpace(value))`
`49`	`49`	`value = null;`
`50`	`50`	`else if (value.Length > 1)`
`51`		`- throw new ArgumentOutOfRangeException("The EscapeCharacter can only contain a single character!");`
	`51`	`+ throw new ArgumentOutOfRangeException($"The {nameof(EscapeCharacter)} can only contain a single character!");`
`52`	`52`	`escapeCharacter = value;`
`53`	`53`	`}`
`54`	`54`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,15 +12,13 @@ public ColumnAttribute(string name)`
`12`	`12`	`{`
`13`	`13`	`if (string.IsNullOrEmpty(name))`
`14`	`14`	`{`
`15`		`- throw new ArgumentNullException("Name parameter is required");`
	`15`	`+ throw new ArgumentNullException(nameof(name));`
`16`	`16`	`}`
`17`	`17`
`18`	`18`	`Name = name;`
`19`	`19`	`}`
`20`		`-`
`21`	`20`	`}`
`22`	`21`
`23`		`-`
`24`	`22`	`/// <summary>`
`25`	`23`	`/// This class is used as metadata on a property to determine if it is a primary key`
`26`	`24`	`/// </summary>`
Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ private MethodInfo FindMethodInfo(Type clauseType, string methodName)`
`40`	`40`
`41`	`41`	`if (methodInfo == null)`
`42`	`42`	`{`
`43`		`- throw new Exception($"Failed to locate a compiler for {methodName}.");`
	`43`	`+ throw new Exception($"Failed to locate a compiler for '{methodName}'.");`
`44`	`44`	`}`
`45`	`45`
`46`	`46`	`if (clauseType.IsConstructedGenericType && methodInfo.GetGenericArguments().Any())`
Original file line number	Diff line number	Diff line change
`@@ -488,7 +488,7 @@ public Query HavingExists(Query query)`
`488`	`488`	`{`
`489`	`489`	`if (!query.HasComponent("from"))`
`490`	`490`	`{`
`491`		`- throw new ArgumentException("'FromClause' cannot be empty if used inside a 'HavingExists' condition");`
	`491`	`+ throw new ArgumentException($"{nameof(FromClause)} cannot be empty if used inside a {nameof(HavingExists)} condition");`
`492`	`492`	`}`
`493`	`493`
`494`	`494`	`// simplify the query as much as possible`
Original file line number	Diff line number	Diff line change
`@@ -9,9 +9,9 @@ public partial class Query`
`9`	`9`	`{`
`10`	`10`	`public Query AsInsert(object data, bool returnId = false)`
`11`	`11`	`{`
`12`		`- var dictionary = BuildKeyValuePairsFromObject(data);`
	`12`	`+ var propertiesKeyValues = BuildKeyValuePairsFromObject(data);`
`13`	`13`
`14`		`- return AsInsert(dictionary, returnId);`
	`14`	`+ return AsInsert(propertiesKeyValues, returnId);`
`15`	`15`	`}`
`16`	`16`
`17`	`17`	`public Query AsInsert(IEnumerable<string> columns, IEnumerable<object> values)`
`@@ -21,12 +21,12 @@ public Query AsInsert(IEnumerable<string> columns, IEnumerable<object> values)`
`21`	`21`
`22`	`22`	`if ((columnsList?.Count ?? 0) == 0 \|\| (valuesList?.Count ?? 0) == 0)`
`23`	`23`	`{`
`24`		`- throw new InvalidOperationException("Columns and Values cannot be null or empty");`
	`24`	`+ throw new InvalidOperationException($"{nameof(columns)} and {nameof(values)} cannot be null or empty");`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`if (columnsList.Count != valuesList.Count)`
`28`	`28`	`{`
`29`		`- throw new InvalidOperationException("Columns count should be equal to Values count");`
	`29`	`+ throw new InvalidOperationException($"{nameof(columns)} and {nameof(values)} cannot be null or empty");`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`Method = "insert";`
`@@ -40,19 +40,19 @@ public Query AsInsert(IEnumerable<string> columns, IEnumerable<object> values)`
`40`	`40`	`return this;`
`41`	`41`	`}`
`42`	`42`
`43`		`- public Query AsInsert(IEnumerable<KeyValuePair<string, object>> data, bool returnId = false)`
	`43`	`+ public Query AsInsert(IEnumerable<KeyValuePair<string, object>> values, bool returnId = false)`
`44`	`44`	`{`
`45`		`- if (data == null \|\| data.Any() == false)`
	`45`	`+ if (values == null \|\| values.Any() == false)`
`46`	`46`	`{`
`47`		`- throw new InvalidOperationException("Values dictionary cannot be null or empty");`
	`47`	`+ throw new InvalidOperationException($"{values} argument cannot be null or empty");`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`Method = "insert";`
`51`	`51`
`52`	`52`	`ClearComponent("insert").AddComponent("insert", new InsertClause`
`53`	`53`	`{`
`54`		`- Columns = data.Select(x=>x.Key).ToList(),`
`55`		`- Values = data.Select(x => x.Value).ToList(),`
	`54`	`+ Columns = values.Select(x=>x.Key).ToList(),`
	`55`	`+ Values = values.Select(x => x.Value).ToList(),`
`56`	`56`	`ReturnId = returnId,`
`57`	`57`	`});`
`58`	`58`
`@@ -63,16 +63,16 @@ public Query AsInsert(IEnumerable<KeyValuePair<string, object>> data, bool retur`
`63`	`63`	`/// Produces insert multi records`
`64`	`64`	`/// </summary>`
`65`	`65`	`/// <param name="columns"></param>`
`66`		`- /// <param name="valuesCollection"></param>`
	`66`	`+ /// <param name="rowsValues"></param>`
`67`	`67`	`/// <returns></returns>`
`68`		`- public Query AsInsert(IEnumerable<string> columns, IEnumerable<IEnumerable<object>> valuesCollection)`
	`68`	`+ public Query AsInsert(IEnumerable<string> columns, IEnumerable<IEnumerable<object>> rowsValues)`
`69`	`69`	`{`
`70`	`70`	`var columnsList = columns?.ToList();`
`71`		`- var valuesCollectionList = valuesCollection?.ToList();`
	`71`	`+ var valuesCollectionList = rowsValues?.ToList();`
`72`	`72`
`73`	`73`	`if ((columnsList?.Count ?? 0) == 0 \|\| (valuesCollectionList?.Count ?? 0) == 0)`
`74`	`74`	`{`
`75`		`- throw new InvalidOperationException("Columns and valuesCollection cannot be null or empty");`
	`75`	`+ throw new InvalidOperationException($"{nameof(columns)} and {nameof(rowsValues)} cannot be null or empty");`
`76`	`76`	`}`
`77`	`77`
`78`	`78`	`Method = "insert";`
`@@ -84,7 +84,7 @@ public Query AsInsert(IEnumerable<string> columns, IEnumerable<IEnumerable<objec`
`84`	`84`	`var valuesList = values.ToList();`
`85`	`85`	`if (columnsList.Count != valuesList.Count)`
`86`	`86`	`{`
`87`		`- throw new InvalidOperationException("Columns count should be equal to each Values count");`
	`87`	`+ throw new InvalidOperationException($"{nameof(columns)} count should be equal to each {nameof(rowsValues)} entry count");`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`AddComponent("insert", new InsertClause`
`@@ -115,6 +115,5 @@ public Query AsInsert(IEnumerable<string> columns, Query query)`
`115`	`115`
`116`	`116`	`return this;`
`117`	`117`	`}`
`118`		`-`
`119`	`118`	`}`
`120`	`119`	`}`