Merge remote-tracking branch 'sqlkata/master' into feature/compiler-performance

# Conflicts:
#	QueryBuilder.Tests/Infrastructure/TestCompilersContainer.cs

Author: mabramczyk

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/SelectTests.cs

@@ -814,5 +814,40 @@ public void EscapeClauseThrowsForMultipleCharacters()
                     .HavingContains("Column1", @"TestString\%", false, @"\aa");
             });
         }
+
+
+        [Fact]
+        public void BasicSelectRaw_WithNoTable()
+        {
+            var q = new Query().SelectRaw("somefunction() as c1");                
+
+            var c = Compilers.CompileFor(EngineCodes.SqlServer, q);
+            Assert.Equal("SELECT somefunction() as c1", c.ToString());
+        }
+
+        [Fact]
+        public void BasicSelect_WithNoTable()
+        {
+            var q = new Query().Select("c1");
+            var c = Compilers.CompileFor(EngineCodes.SqlServer, q);
+            Assert.Equal("SELECT [c1]", c.ToString());
+        }
+
+        [Fact]
+        public void BasicSelect_WithNoTableAndWhereClause()
+        {
+            var q = new Query().Select("c1").Where("p", 1);
+            var c = Compilers.CompileFor(EngineCodes.SqlServer, q);
+            Assert.Equal("SELECT [c1] WHERE [p] = 1", c.ToString());
+        }
+
+        [Fact]
+        public void BasicSelect_WithNoTableWhereRawClause()
+        {
+            var q = new Query().Select("c1").WhereRaw("1 = 1");
+            var c = Compilers.CompileFor(EngineCodes.SqlServer, q);
+            Assert.Equal("SELECT [c1] WHERE 1 = 1", c.ToString());
+        }
+        
     }
 }

QueryBuilder/Base.Where.cs

@@ -381,7 +381,7 @@ public Q OrWhereNotBetween<T>(string column, T lower, T higher)
         public Q WhereIn<T>(string column, IEnumerable<T> values)
         {
 
-            // If the developer has passed a string most probably he wants List<string>
+            // If the developer has passed a string they most likely want a List<string>
             // since string is considered as List<char>
             if (values is string)
             {

QueryBuilder/Compilers/Compiler.cs

@@ -649,14 +649,14 @@ public virtual string CompileTableExpression(SqlResult ctx, AbstractFrom from)
 
         public virtual string CompileFrom(SqlResult ctx)
         {
-            if (!ctx.Query.HasComponent("from", EngineCode))
+            if (ctx.Query.HasComponent("from", EngineCode))
             {
-                throw new InvalidOperationException("No table is set");
-            }
+                var from = ctx.Query.GetOneComponent<AbstractFrom>("from", EngineCode);
 
-            var from = ctx.Query.GetOneComponent<AbstractFrom>("from", EngineCode);
+                return "FROM " + CompileTableExpression(ctx, from);
+            }
 
-            return "FROM " + CompileTableExpression(ctx, from);
+            return string.Empty;
         }
 
         public virtual string CompileJoins(SqlResult ctx)
@@ -689,7 +689,7 @@ public virtual string CompileJoin(SqlResult ctx, Join join, bool isNested = fals
 
         public virtual string CompileWheres(SqlResult ctx)
         {
-            if (!ctx.Query.HasComponent("from", EngineCode) || !ctx.Query.HasComponent("where", EngineCode))
+            if (!ctx.Query.HasComponent("where", EngineCode))
             {
                 return null;
             }

QueryBuilder/Query.Having.cs

@@ -360,7 +360,7 @@ public Query OrHavingNotBetween<T>(string column, T lower, T higher)
 
         public Query HavingIn<T>(string column, IEnumerable<T> values)
         {
-            // If the developer has passed a string most probably he wants List<string>
+            // If the developer has passed a string they most likely want a List<string>
             // since string is considered as List<char>
             if (values is string)
             {

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;
                 }
             }