Merge branch 'sqlkata:master' into master

Author: mnsrulz

QueryBuilder.Tests/ExecutionTests.cs

@@ -14,5 +14,14 @@ public void ShouldThrowException()
                 new Query("Books").Get();
             });
         }
+
+        [Fact]
+        public void TimeoutShouldBeCarriedToNewCreatedFactory()
+        {
+            var db = new QueryFactory();
+            db.QueryTimeout = 4000;
+            var newFactory = QueryExtensions.CreateQueryFactory(db.Query());
+            Assert.Equal(db.QueryTimeout, newFactory.QueryTimeout);
+        }
     }
 }

QueryBuilder.Tests/Infrastructure/TestCompilersContainer.cs

@@ -21,6 +21,9 @@ private static class Messages
             [EngineCodes.PostgreSql] = new PostgresCompiler(),
             [EngineCodes.Sqlite] = new SqliteCompiler(),
             [EngineCodes.SqlServer] = new SqlServerCompiler()
+            {
+                UseLegacyPagination = true
+            }
         };
 
         public IEnumerable<string> KnownEngineCodes

QueryBuilder.Tests/SelectTests.cs

@@ -714,6 +714,17 @@ public void MultipleOrHaving()
             Assert.Equal("SELECT * FROM [Table1] HAVING [Column1] > 1 OR [Column2] = 1", c[EngineCodes.SqlServer]);
         }
 
+        [Fact]
+        public void ShouldUseILikeOnPostgresWhenNonCaseSensitive()
+        {
+            var q = new Query("Table1")
+                .WhereLike("Column1", "%Upper Word%", false);
+            var c = Compile(q);
+
+            Assert.Equal(@"SELECT * FROM [Table1] WHERE LOWER([Column1]) like '%upper word%'", c[EngineCodes.SqlServer]);
+            Assert.Equal("SELECT * FROM \"Table1\" WHERE \"Column1\" ilike '%Upper Word%'", c[EngineCodes.PostgreSql]);
+        }
+
         [Fact]
         public void EscapedWhereLike()
         {

QueryBuilder/Compilers/PostgresCompiler.cs

@@ -1,3 +1,6 @@
+using System;
+using System.Linq;
+
 namespace SqlKata.Compilers
 {
     public class PostgresCompiler : Compiler
@@ -9,6 +12,60 @@ public PostgresCompiler()
 
         public override string EngineCode { get; } = EngineCodes.PostgreSql;
 
+
+        protected override string CompileBasicStringCondition(SqlResult ctx, BasicStringCondition x)
+        {
+
+            var column = Wrap(x.Column);
+
+            var value = Resolve(ctx, x.Value) as string;
+
+            if (value == null)
+            {
+                throw new ArgumentException("Expecting a non nullable string");
+            }
+
+            var method = x.Operator;
+
+            if (new[] { "starts", "ends", "contains", "like", "ilike" }.Contains(x.Operator))
+            {
+                method = x.CaseSensitive ? "LIKE" : "ILIKE";
+
+                switch (x.Operator)
+                {
+                    case "starts":
+                        value = $"{value}%";
+                        break;
+                    case "ends":
+                        value = $"%{value}";
+                        break;
+                    case "contains":
+                        value = $"%{value}%";
+                        break;
+                }
+            }
+
+            string sql;
+
+            if (x.Value is UnsafeLiteral)
+            {
+                sql = $"{column} {checkOperator(method)} {value}";
+            }
+            else
+            {
+                sql = $"{column} {checkOperator(method)} {Parameter(ctx, value)}";
+            }
+
+            if (!string.IsNullOrEmpty(x.EscapeCharacter))
+            {
+                sql = $"{sql} ESCAPE '{x.EscapeCharacter}'";
+            }
+
+            return x.IsNot ? $"NOT ({sql})" : sql;
+
+        }
+
+
         protected override string CompileBasicDateCondition(SqlResult ctx, BasicDateCondition condition)
         {
             var column = Wrap(condition.Column);

QueryBuilder/Compilers/SqlServerCompiler.cs

@@ -12,7 +12,7 @@ public SqlServerCompiler()
         }
 
         public override string EngineCode { get; } = EngineCodes.SqlServer;
-        public bool UseLegacyPagination { get; set; } = true;
+        public bool UseLegacyPagination { get; set; } = false;
 
         protected override SqlResult CompileSelectQuery(Query query)
         {

QueryBuilder/SqlResult.cs

@@ -81,7 +81,7 @@ private string ChangeToSqlValue(object value)
             }
 
             // fallback to string
-            return "'" + value.ToString() + "'";
+            return "'" + value.ToString().Replace("'","''") + "'";
         }
     }
 }

SqlKata.Execution/Properties/AssemblyInfo.cs

@@ -0,0 +1,3 @@
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("QueryBuilder.Tests")]

SqlKata.Execution/Query.Extensions.cs

@@ -366,7 +366,7 @@ internal static XQuery CastToXQuery(Query query, string method = null)
 
         internal static QueryFactory CreateQueryFactory(XQuery xQuery)
         {
-            var factory = new QueryFactory(xQuery.Connection, xQuery.Compiler);
+            var factory = new QueryFactory(xQuery.Connection, xQuery.Compiler, xQuery.QueryFactory.QueryTimeout);
 
             factory.Logger = xQuery.Logger;
 

SqlKata.Execution/QueryFactory.cs

@@ -749,8 +749,8 @@ private static IEnumerable<T> handleIncludes<T>(Query query, IEnumerable<T> resu
 
                 foreach (var item in dynamicResult)
                 {
-                    var foreignValue = item[include.ForeignKey].ToString();
-                    item[include.Name] = related.ContainsKey(foreignValue) ? related[foreignValue] : null;
+                    var foreignValue = item[include.ForeignKey]?.ToString();
+                    item[include.Name] = foreignValue != null && related.ContainsKey(foreignValue) ? related[foreignValue] : null;
                 }
             }
 
@@ -843,8 +843,8 @@ private static async Task<IEnumerable<T>> handleIncludesAsync<T>(Query query, IE
 
                 foreach (var item in dynamicResult)
                 {
-                    var foreignValue = item[include.ForeignKey].ToString();
-                    item[include.Name] = related.ContainsKey(foreignValue) ? related[foreignValue] : null;
+                    var foreignValue = item[include.ForeignKey]?.ToString();
+                    item[include.Name] = foreignValue != null && related.ContainsKey(foreignValue) ? related[foreignValue] : null;
                 }
             }