Refactor the query syntax using an interface and classes defined in terms of clauses.

bordoley · bordoley · commit 2ee58da9cca8 · 2015-03-23T16:27:18.000-07:00
diff --git a/SQLitePCL.pretty.Orm/Interfaces.cs b/SQLitePCL.pretty.Orm/Interfaces.cs
@@ -84,5 +84,10 @@ public IReadOnlyDictionary<string, IndexInfo> Indexes
             }
         }
     }
+
+    public interface ISqlQuery
+    {
+        string ToSql();
+    }
 }
 
diff --git a/SQLitePCL.pretty.Orm/SQLitePCL.pretty.Orm.csproj b/SQLitePCL.pretty.Orm/SQLitePCL.pretty.Orm.csproj
@@ -148,10 +148,11 @@
     <Compile Include="TableMapping.Delete.cs" />
     <Compile Include="TableMapping.InsertOrReplace.cs" />
     <Compile Include="ForeignKeyConstraint.cs" />
-    <Compile Include="QueryBuilder.cs" />
-    <Compile Include="QueryBuilder.Limit.cs" />
-    <Compile Include="QueryBuilder.OrderBy.cs" />
-    <Compile Include="QueryBuilder.Where.cs" />
+    <Compile Include="SqlQuery.cs" />
+    <Compile Include="SqlQuery.Limit.cs" />
+    <Compile Include="SqlQuery.OrderBy.cs" />
+    <Compile Include="SqlQuery.Where.cs" />
+    <Compile Include="SqlQuery.Select.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildExtensionsPath32)\Microsoft\Portable\$(TargetFrameworkVersion)\Microsoft.Portable.CSharp.targets" />
   <ItemGroup>
diff --git a/SQLitePCL.pretty.Orm/SqlQuery.Limit.cs b/SQLitePCL.pretty.Orm/SqlQuery.Limit.cs
@@ -5,9 +5,9 @@
 
 namespace SQLitePCL.pretty.Orm
 {
-    public static partial class QueryBuilder
+    public static partial class SqlQuery
     {
-        public sealed class LimitQuery
+        public sealed class LimitClause : ISqlQuery
         {
             private readonly string table;
             private readonly string selection;
@@ -16,7 +16,7 @@ public sealed class LimitQuery
             private readonly Nullable<int> limit;
             private readonly Nullable<int> offset;
 
-            internal LimitQuery(string table, string selection, Expression where, IReadOnlyList<Tuple<string, bool>> ordering, Nullable<int> limit, Nullable<int> offset)
+            internal LimitClause(string table, string selection, Expression where, IReadOnlyList<Tuple<string, bool>> ordering, Nullable<int> limit, Nullable<int> offset)
             {
                 this.table = table;
                 this.selection = selection;
@@ -31,24 +31,29 @@ internal LimitQuery(string table, string selection, Expression where, IReadOnlyL
             /// </summary>
             /// <param name="n">The number of elements to return.</param>
             /// <returns>A new <see cref="SQLitePCL.pretty.Orm.TableQuery&lt;T&gt;"/>.</returns>
-            public LimitQuery Take(int n)
+            public LimitClause Take(int n)
             {
-                return new LimitQuery(table, selection, where, ordering, n, offset);
+                return new LimitClause(table, selection, where, ordering, n, offset);
             }
 
             /// <summary>
             /// Returns a <see cref="TableQuery&lt;T&gt;"/> that skips a specified number of elements in the result set and then returns the remaining elements.
             /// </summary>
             /// <param name="n">The number of elements to skip before returning the remaining elements.</param>
             /// <returns>A new <see cref="SQLitePCL.pretty.Orm.TableQuery&lt;T&gt;"/>.</returns>
-            public LimitQuery Skip(int n)
+            public LimitClause Skip(int n)
             {
-                return new LimitQuery(table, selection, where, ordering, limit, n);
+                return new LimitClause(table, selection, where, ordering, limit, n);
             }
 
             public override string ToString()
             {
-                return QueryBuilder.ToString(selection, table, where, ordering, limit, offset); 
+                return SqlQuery.ToString(selection, table, where, ordering, limit, offset); 
+            }
+
+            public string ToSql()
+            {
+                return this.ToString();
             }
         }
     }
diff --git a/SQLitePCL.pretty.Orm/SqlQuery.OrderBy.cs b/SQLitePCL.pretty.Orm/SqlQuery.OrderBy.cs
@@ -7,29 +7,29 @@
 
 namespace SQLitePCL.pretty.Orm
 {
-    public static partial class QueryBuilder
+    public static partial class SqlQuery
     {
-        public sealed class OrderByQuery<T>
+        public sealed class OrderByClause<T> : ISqlQuery
         {
             private readonly string table;
             private readonly string selection;
             private readonly Expression where;
             private readonly IReadOnlyList<Tuple<string, bool>> ordering;
 
-            internal OrderByQuery(string table, string selection, Expression where, IReadOnlyList<Tuple<string, bool>> ordering)
+            internal OrderByClause(string table, string selection, Expression where, IReadOnlyList<Tuple<string, bool>> ordering)
             {
                 this.table = table;
                 this.selection = selection;
                 this.where = where;
                 this.ordering = ordering;
             }
 
-            public OrderByQuery<T> ThenBy<TValue>(Expression<Func<T, TValue>> orderExpr)
+            public OrderByClause<T> ThenBy<TValue>(Expression<Func<T, TValue>> orderExpr)
             {
                 return AddOrderBy(orderExpr, true);
             }
 
-            public OrderByQuery<T> ThenByDescending<TValue>(Expression<Func<T, TValue>> orderExpr)
+            public OrderByClause<T> ThenByDescending<TValue>(Expression<Func<T, TValue>> orderExpr)
             {
                 return AddOrderBy(orderExpr, false);
             }
@@ -39,19 +39,19 @@ public OrderByQuery<T> ThenByDescending<TValue>(Expression<Func<T, TValue>> orde
             /// </summary>
             /// <param name="n">The number of elements to return.</param>
             /// <returns>A new <see cref="SQLitePCL.pretty.Orm.TableQuery&lt;T&gt;"/>.</returns>
-            public LimitQuery Take(int n)
+            public LimitClause Take(int n)
             {
-                return new LimitQuery(table, selection, where, this.ordering, n, null);
+                return new LimitClause(table, selection, where, this.ordering, n, null);
             }
 
             /// <summary>
             /// Returns a <see cref="TableQuery&lt;T&gt;"/> that skips a specified number of elements in the result set and then returns the remaining elements.
             /// </summary>
             /// <param name="n">The number of elements to skip before returning the remaining elements.</param>
             /// <returns>A new <see cref="SQLitePCL.pretty.Orm.TableQuery&lt;T&gt;"/>.</returns>
-            public LimitQuery Skip(int n)
+            public LimitClause Skip(int n)
             {
-                return new LimitQuery(table, selection, where, this.ordering, null, n);
+                return new LimitClause(table, selection, where, this.ordering, null, n);
             }
 
             /// <summary>
@@ -60,21 +60,26 @@ public LimitQuery Skip(int n)
             /// <returns>The <see cref="SQLitePCL.pretty.Orm.TableQuery&lt;T&gt;"/>.</returns>
             /// <param name="index">Index.</param>
             /// <returns>A new <see cref="SQLitePCL.pretty.Orm.TableQuery&lt;T&gt;"/>.</returns>
-            public string ElementAt(int index)
+            public LimitClause ElementAt(int index)
             {
-                return Skip(index).Take(1).ToString();
+                return Skip(index).Take(1);
             }
 
-            private OrderByQuery<T> AddOrderBy<TValue>(Expression<Func<T, TValue>> orderExpr, bool asc)
+            private OrderByClause<T> AddOrderBy<TValue>(Expression<Func<T, TValue>> orderExpr, bool asc)
             {  
                 var orderBy = new List<Tuple<string, bool>>(ordering);
                 orderBy.Add(orderExpr.CompileOrderByExpression(asc));
-                return new OrderByQuery<T>(table, selection, where, orderBy);
+                return new OrderByClause<T>(table, selection, where, orderBy);
             }
 
             public override string ToString()
             {
-                return QueryBuilder.ToString(selection, table, where, ordering, null, null); 
+                return SqlQuery.ToString(selection, table, where, ordering, null, null); 
+            }
+
+            public string ToSql()
+            {
+                return this.ToString();
             }
         }
     }
diff --git a/SQLitePCL.pretty.Orm/SqlQuery.Select.cs b/SQLitePCL.pretty.Orm/SqlQuery.Select.cs
@@ -0,0 +1,29 @@
+﻿using System;
+using System.Linq;
+namespace SQLitePCL.pretty.Orm
+{
+    public static partial class SqlQuery
+    {
+        public sealed class SelectClause<T>
+        {
+            private readonly string from;
+
+            internal SelectClause(string from)
+            {
+                this.from = from;
+            }
+
+            public WhereClause<T> Select()
+            {
+                return new WhereClause<T>(this.from, "*", null);
+            }
+
+            public WhereClause<T> Count()
+            {
+                return new WhereClause<T>(this.from, "COUNT(*)", null);
+            }
+        }
+    }
+}
+
+
diff --git a/SQLitePCL.pretty.Orm/SqlQuery.Where.cs b/SQLitePCL.pretty.Orm/SqlQuery.Where.cs
@@ -5,97 +5,98 @@
 
 namespace SQLitePCL.pretty.Orm
 {
-    public static partial class QueryBuilder
+    public static partial class SqlQuery
     {
-        public sealed class WhereQuery<T>
+        public sealed class WhereClause<T> : ISqlQuery
         {
-            private const string selection = "*";
             private readonly string table;
+            private readonly string selection;
             private readonly Expression where;
 
-            internal WhereQuery(string table, Expression where)
+            internal WhereClause(string table, string selection, Expression where)
             {
                 this.table = table;
+                this.selection = selection;
                 this.where = where;
             }
 
-            public OrderByQuery<T> OrderBy<TValue>(Expression<Func<T, TValue>> orderExpr)
+            public OrderByClause<T> OrderBy<TValue>(Expression<Func<T, TValue>> orderExpr)
             {
                 return CreateOrderBy(orderExpr, true);
             }
 
-            public OrderByQuery<T> OrderByDescending<TValue>(Expression<Func<T, TValue>> orderExpr)
+            public OrderByClause<T> OrderByDescending<TValue>(Expression<Func<T, TValue>> orderExpr)
             {
                 return CreateOrderBy(orderExpr, false);
             }
 
-            private OrderByQuery<T> CreateOrderBy<TValue>(Expression<Func<T, TValue>> orderExpr, bool asc)
+            private OrderByClause<T> CreateOrderBy<TValue>(Expression<Func<T, TValue>> orderExpr, bool asc)
             {  
                 var orderBy = new List<Tuple<string, bool>>();
                 orderBy.Add(orderExpr.CompileOrderByExpression(asc));
-                return new OrderByQuery<T>(table, selection, where, orderBy);
+                return new OrderByClause<T>(table, selection, where, orderBy);
             }
 
-            public WhereQuery<T> Where<U,V,W,X,Y,Z>(Expression<Func<T,U,V,W,X,Y,Z,bool>> predExpr)
+            public WhereClause<T> Where<U,V,W,X,Y,Z>(Expression<Func<T,U,V,W,X,Y,Z,bool>> predExpr)
             {
                 return this.Where((LambdaExpression) predExpr);
             }
 
-            public WhereQuery<T> Where<U,V,W,X,Y>(Expression<Func<T,U,V,W,X,Y,bool>> predExpr)
+            public WhereClause<T> Where<U,V,W,X,Y>(Expression<Func<T,U,V,W,X,Y,bool>> predExpr)
             {
                 return this.Where((LambdaExpression) predExpr);
             }
 
-            public WhereQuery<T> Where<U,V,W,X>(Expression<Func<T,U,V,W,X,bool>> predExpr)
+            public WhereClause<T> Where<U,V,W,X>(Expression<Func<T,U,V,W,X,bool>> predExpr)
             {
                 return this.Where((LambdaExpression) predExpr);
             }
 
-            public WhereQuery<T> Where<U,V,W>(Expression<Func<T,U,V,W,bool>> predExpr)
+            public WhereClause<T> Where<U,V,W>(Expression<Func<T,U,V,W,bool>> predExpr)
             {
                 return this.Where((LambdaExpression) predExpr);
             }
 
-            public WhereQuery<T> Where<U,V>(Expression<Func<T,U,V,bool>> predExpr)
+            public WhereClause<T> Where<U,V>(Expression<Func<T,U,V,bool>> predExpr)
             {
                 return this.Where((LambdaExpression) predExpr);
             }
 
-            public WhereQuery<T> Where<U>(Expression<Func<T,U,bool>> predExpr)
+            public WhereClause<T> Where<U>(Expression<Func<T,U,bool>> predExpr)
             {
                 return this.Where((LambdaExpression) predExpr);
             }
 
-            public WhereQuery<T> Where(Expression<Func<T, bool>> predExpr)
+            public WhereClause<T> Where(Expression<Func<T, bool>> predExpr)
             {
                 return this.Where((LambdaExpression) predExpr);
             }
 
-            private WhereQuery<T> Where(LambdaExpression lambda)
+            private WhereClause<T> Where(LambdaExpression lambda)
             {
                 var pred = lambda.Body;
                 var where = this.where == null ? pred : Expression.AndAlso(this.where, pred);
-                return new WhereQuery<T>(table, where);
+                return new WhereClause<T>(table, selection, where);
             }
 
             /// <summary>
             /// Returns a <see cref="TableQuery&lt;T&gt;"/> that limits the result set to a specified number of contiguous elements.
             /// </summary>
             /// <param name="n">The number of elements to return.</param>
             /// <returns>A new <see cref="SQLitePCL.pretty.Orm.TableQuery&lt;T&gt;"/>.</returns>
-            public LimitQuery Take(int n)
+            public LimitClause Take(int n)
             {
-                return new LimitQuery(table, selection, where, new List<Tuple<string, bool>>(), n, null);
+                return new LimitClause(table, selection, where, new List<Tuple<string, bool>>(), n, null);
             }
 
             /// <summary>
             /// Returns a <see cref="TableQuery&lt;T&gt;"/> that skips a specified number of elements in the result set and then returns the remaining elements.
             /// </summary>
             /// <param name="n">The number of elements to skip before returning the remaining elements.</param>
             /// <returns>A new <see cref="SQLitePCL.pretty.Orm.TableQuery&lt;T&gt;"/>.</returns>
-            public LimitQuery Skip(int n)
+            public LimitClause Skip(int n)
             {
-                return new LimitQuery(table, selection, where, new List<Tuple<string, bool>>(), null, n);
+                return new LimitClause(table, selection, where, new List<Tuple<string, bool>>(), null, n);
             }
 
             /// <summary>
@@ -104,14 +105,19 @@ public LimitQuery Skip(int n)
             /// <returns>The <see cref="SQLitePCL.pretty.Orm.TableQuery&lt;T&gt;"/>.</returns>
             /// <param name="index">Index.</param>
             /// <returns>A new <see cref="SQLitePCL.pretty.Orm.TableQuery&lt;T&gt;"/>.</returns>
-            public string ElementAt(int index)
+            public LimitClause ElementAt(int index)
             {
-                return Skip(index).Take(1).ToString();
+                return Skip(index).Take(1);
             }
 
             public override string ToString()
             {
-                return QueryBuilder.ToString(selection, table, where, Enumerable.Empty<Tuple<string, bool>>(), null, null); 
+                return SqlQuery.ToString(selection, table, where, Enumerable.Empty<Tuple<string, bool>>(), null, null); 
+            }
+
+            public string ToSql()
+            {
+                return this.ToString();
             }
         }
     }
diff --git a/SQLitePCL.pretty.Orm/SqlQuery.cs b/SQLitePCL.pretty.Orm/SqlQuery.cs
diff --git a/SQLitePCL.pretty.tests/OrmTests/QueryTests.cs b/SQLitePCL.pretty.tests/OrmTests/QueryTests.cs
diff --git a/SQLitePCL.pretty.tests/SQLitePCL.pretty.tests.x86.csproj b/SQLitePCL.pretty.tests/SQLitePCL.pretty.tests.x86.csproj

Original file line number	Diff line number	Diff line change
`@@ -84,5 +84,10 @@ public IReadOnlyDictionary<string, IndexInfo> Indexes`
`84`	`84`	`}`
`85`	`85`	`}`
`86`	`86`	`}`
	`87`	`+`
	`88`	`+ public interface ISqlQuery`
	`89`	`+ {`
	`90`	`+ string ToSql();`
	`91`	`+ }`
`87`	`92`	`}`
`88`	`93`
Original file line number	Diff line number	Diff line change
`@@ -5,9 +5,9 @@`
`5`	`5`
`6`	`6`	`namespace SQLitePCL.pretty.Orm`
`7`	`7`	`{`
`8`		`- public static partial class QueryBuilder`
	`8`	`+ public static partial class SqlQuery`
`9`	`9`	`{`
`10`		`- public sealed class LimitQuery`
	`10`	`+ public sealed class LimitClause : ISqlQuery`
`11`	`11`	`{`
`12`	`12`	`private readonly string table;`
`13`	`13`	`private readonly string selection;`
`@@ -16,7 +16,7 @@ public sealed class LimitQuery`
`16`	`16`	`private readonly Nullable<int> limit;`
`17`	`17`	`private readonly Nullable<int> offset;`
`18`	`18`
`19`		`- internal LimitQuery(string table, string selection, Expression where, IReadOnlyList<Tuple<string, bool>> ordering, Nullable<int> limit, Nullable<int> offset)`
	`19`	`+ internal LimitClause(string table, string selection, Expression where, IReadOnlyList<Tuple<string, bool>> ordering, Nullable<int> limit, Nullable<int> offset)`
`20`	`20`	`{`
`21`	`21`	`this.table = table;`
`22`	`22`	`this.selection = selection;`
`@@ -31,24 +31,29 @@ internal LimitQuery(string table, string selection, Expression where, IReadOnlyL`
`31`	`31`	`/// </summary>`
`32`	`32`	`/// <param name="n">The number of elements to return.</param>`
`33`	`33`	`/// <returns>A new <see cref="SQLitePCL.pretty.Orm.TableQuery<T>"/>.</returns>`
`34`		`- public LimitQuery Take(int n)`
	`34`	`+ public LimitClause Take(int n)`
`35`	`35`	`{`
`36`		`- return new LimitQuery(table, selection, where, ordering, n, offset);`
	`36`	`+ return new LimitClause(table, selection, where, ordering, n, offset);`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`/// <summary>`
`40`	`40`	`/// Returns a <see cref="TableQuery<T>"/> that skips a specified number of elements in the result set and then returns the remaining elements.`
`41`	`41`	`/// </summary>`
`42`	`42`	`/// <param name="n">The number of elements to skip before returning the remaining elements.</param>`
`43`	`43`	`/// <returns>A new <see cref="SQLitePCL.pretty.Orm.TableQuery<T>"/>.</returns>`
`44`		`- public LimitQuery Skip(int n)`
	`44`	`+ public LimitClause Skip(int n)`
`45`	`45`	`{`
`46`		`- return new LimitQuery(table, selection, where, ordering, limit, n);`
	`46`	`+ return new LimitClause(table, selection, where, ordering, limit, n);`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`public override string ToString()`
`50`	`50`	`{`
`51`		`- return QueryBuilder.ToString(selection, table, where, ordering, limit, offset);`
	`51`	`+ return SqlQuery.ToString(selection, table, where, ordering, limit, offset);`
	`52`	`+ }`
	`53`	`+`
	`54`	`+ public string ToSql()`
	`55`	`+ {`
	`56`	`+ return this.ToString();`
`52`	`57`	`}`
`53`	`58`	`}`
`54`	`59`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,29 +7,29 @@`
`7`	`7`
`8`	`8`	`namespace SQLitePCL.pretty.Orm`
`9`	`9`	`{`
`10`		`- public static partial class QueryBuilder`
	`10`	`+ public static partial class SqlQuery`
`11`	`11`	`{`
`12`		`- public sealed class OrderByQuery<T>`
	`12`	`+ public sealed class OrderByClause<T> : ISqlQuery`
`13`	`13`	`{`
`14`	`14`	`private readonly string table;`
`15`	`15`	`private readonly string selection;`
`16`	`16`	`private readonly Expression where;`
`17`	`17`	`private readonly IReadOnlyList<Tuple<string, bool>> ordering;`
`18`	`18`
`19`		`- internal OrderByQuery(string table, string selection, Expression where, IReadOnlyList<Tuple<string, bool>> ordering)`
	`19`	`+ internal OrderByClause(string table, string selection, Expression where, IReadOnlyList<Tuple<string, bool>> ordering)`
`20`	`20`	`{`
`21`	`21`	`this.table = table;`
`22`	`22`	`this.selection = selection;`
`23`	`23`	`this.where = where;`
`24`	`24`	`this.ordering = ordering;`
`25`	`25`	`}`
`26`	`26`
`27`		`- public OrderByQuery<T> ThenBy<TValue>(Expression<Func<T, TValue>> orderExpr)`
	`27`	`+ public OrderByClause<T> ThenBy<TValue>(Expression<Func<T, TValue>> orderExpr)`
`28`	`28`	`{`
`29`	`29`	`return AddOrderBy(orderExpr, true);`
`30`	`30`	`}`
`31`	`31`
`32`		`- public OrderByQuery<T> ThenByDescending<TValue>(Expression<Func<T, TValue>> orderExpr)`
	`32`	`+ public OrderByClause<T> ThenByDescending<TValue>(Expression<Func<T, TValue>> orderExpr)`
`33`	`33`	`{`
`34`	`34`	`return AddOrderBy(orderExpr, false);`
`35`	`35`	`}`
`@@ -39,19 +39,19 @@ public OrderByQuery<T> ThenByDescending<TValue>(Expression<Func<T, TValue>> orde`
`39`	`39`	`/// </summary>`
`40`	`40`	`/// <param name="n">The number of elements to return.</param>`
`41`	`41`	`/// <returns>A new <see cref="SQLitePCL.pretty.Orm.TableQuery<T>"/>.</returns>`
`42`		`- public LimitQuery Take(int n)`
	`42`	`+ public LimitClause Take(int n)`
`43`	`43`	`{`
`44`		`- return new LimitQuery(table, selection, where, this.ordering, n, null);`
	`44`	`+ return new LimitClause(table, selection, where, this.ordering, n, null);`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`/// <summary>`
`48`	`48`	`/// Returns a <see cref="TableQuery<T>"/> that skips a specified number of elements in the result set and then returns the remaining elements.`
`49`	`49`	`/// </summary>`
`50`	`50`	`/// <param name="n">The number of elements to skip before returning the remaining elements.</param>`
`51`	`51`	`/// <returns>A new <see cref="SQLitePCL.pretty.Orm.TableQuery<T>"/>.</returns>`
`52`		`- public LimitQuery Skip(int n)`
	`52`	`+ public LimitClause Skip(int n)`
`53`	`53`	`{`
`54`		`- return new LimitQuery(table, selection, where, this.ordering, null, n);`
	`54`	`+ return new LimitClause(table, selection, where, this.ordering, null, n);`
`55`	`55`	`}`
`56`	`56`
`57`	`57`	`/// <summary>`
`@@ -60,21 +60,26 @@ public LimitQuery Skip(int n)`
`60`	`60`	`/// <returns>The <see cref="SQLitePCL.pretty.Orm.TableQuery<T>"/>.</returns>`
`61`	`61`	`/// <param name="index">Index.</param>`
`62`	`62`	`/// <returns>A new <see cref="SQLitePCL.pretty.Orm.TableQuery<T>"/>.</returns>`
`63`		`- public string ElementAt(int index)`
	`63`	`+ public LimitClause ElementAt(int index)`
`64`	`64`	`{`
`65`		`- return Skip(index).Take(1).ToString();`
	`65`	`+ return Skip(index).Take(1);`
`66`	`66`	`}`
`67`	`67`
`68`		`- private OrderByQuery<T> AddOrderBy<TValue>(Expression<Func<T, TValue>> orderExpr, bool asc)`
	`68`	`+ private OrderByClause<T> AddOrderBy<TValue>(Expression<Func<T, TValue>> orderExpr, bool asc)`
`69`	`69`	`{`
`70`	`70`	`var orderBy = new List<Tuple<string, bool>>(ordering);`
`71`	`71`	`orderBy.Add(orderExpr.CompileOrderByExpression(asc));`
`72`		`- return new OrderByQuery<T>(table, selection, where, orderBy);`
	`72`	`+ return new OrderByClause<T>(table, selection, where, orderBy);`
`73`	`73`	`}`
`74`	`74`
`75`	`75`	`public override string ToString()`
`76`	`76`	`{`
`77`		`- return QueryBuilder.ToString(selection, table, where, ordering, null, null);`
	`77`	`+ return SqlQuery.ToString(selection, table, where, ordering, null, null);`
	`78`	`+ }`
	`79`	`+`
	`80`	`+ public string ToSql()`
	`81`	`+ {`
	`82`	`+ return this.ToString();`
`78`	`83`	`}`
`79`	`84`	`}`
`80`	`85`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,97 +5,98 @@`
`5`	`5`
`6`	`6`	`namespace SQLitePCL.pretty.Orm`
`7`	`7`	`{`
`8`		`- public static partial class QueryBuilder`
	`8`	`+ public static partial class SqlQuery`
`9`	`9`	`{`
`10`		`- public sealed class WhereQuery<T>`
	`10`	`+ public sealed class WhereClause<T> : ISqlQuery`
`11`	`11`	`{`
`12`		`- private const string selection = "*";`
`13`	`12`	`private readonly string table;`
	`13`	`+ private readonly string selection;`
`14`	`14`	`private readonly Expression where;`
`15`	`15`
`16`		`- internal WhereQuery(string table, Expression where)`
	`16`	`+ internal WhereClause(string table, string selection, Expression where)`
`17`	`17`	`{`
`18`	`18`	`this.table = table;`
	`19`	`+ this.selection = selection;`
`19`	`20`	`this.where = where;`
`20`	`21`	`}`
`21`	`22`
`22`		`- public OrderByQuery<T> OrderBy<TValue>(Expression<Func<T, TValue>> orderExpr)`
	`23`	`+ public OrderByClause<T> OrderBy<TValue>(Expression<Func<T, TValue>> orderExpr)`
`23`	`24`	`{`
`24`	`25`	`return CreateOrderBy(orderExpr, true);`
`25`	`26`	`}`
`26`	`27`
`27`		`- public OrderByQuery<T> OrderByDescending<TValue>(Expression<Func<T, TValue>> orderExpr)`
	`28`	`+ public OrderByClause<T> OrderByDescending<TValue>(Expression<Func<T, TValue>> orderExpr)`
`28`	`29`	`{`
`29`	`30`	`return CreateOrderBy(orderExpr, false);`
`30`	`31`	`}`
`31`	`32`
`32`		`- private OrderByQuery<T> CreateOrderBy<TValue>(Expression<Func<T, TValue>> orderExpr, bool asc)`
	`33`	`+ private OrderByClause<T> CreateOrderBy<TValue>(Expression<Func<T, TValue>> orderExpr, bool asc)`
`33`	`34`	`{`
`34`	`35`	`var orderBy = new List<Tuple<string, bool>>();`
`35`	`36`	`orderBy.Add(orderExpr.CompileOrderByExpression(asc));`
`36`		`- return new OrderByQuery<T>(table, selection, where, orderBy);`
	`37`	`+ return new OrderByClause<T>(table, selection, where, orderBy);`
`37`	`38`	`}`
`38`	`39`
`39`		`- public WhereQuery<T> Where<U,V,W,X,Y,Z>(Expression<Func<T,U,V,W,X,Y,Z,bool>> predExpr)`
	`40`	`+ public WhereClause<T> Where<U,V,W,X,Y,Z>(Expression<Func<T,U,V,W,X,Y,Z,bool>> predExpr)`
`40`	`41`	`{`
`41`	`42`	`return this.Where((LambdaExpression) predExpr);`
`42`	`43`	`}`
`43`	`44`
`44`		`- public WhereQuery<T> Where<U,V,W,X,Y>(Expression<Func<T,U,V,W,X,Y,bool>> predExpr)`
	`45`	`+ public WhereClause<T> Where<U,V,W,X,Y>(Expression<Func<T,U,V,W,X,Y,bool>> predExpr)`
`45`	`46`	`{`
`46`	`47`	`return this.Where((LambdaExpression) predExpr);`
`47`	`48`	`}`
`48`	`49`
`49`		`- public WhereQuery<T> Where<U,V,W,X>(Expression<Func<T,U,V,W,X,bool>> predExpr)`
	`50`	`+ public WhereClause<T> Where<U,V,W,X>(Expression<Func<T,U,V,W,X,bool>> predExpr)`
`50`	`51`	`{`
`51`	`52`	`return this.Where((LambdaExpression) predExpr);`
`52`	`53`	`}`
`53`	`54`
`54`		`- public WhereQuery<T> Where<U,V,W>(Expression<Func<T,U,V,W,bool>> predExpr)`
	`55`	`+ public WhereClause<T> Where<U,V,W>(Expression<Func<T,U,V,W,bool>> predExpr)`
`55`	`56`	`{`
`56`	`57`	`return this.Where((LambdaExpression) predExpr);`
`57`	`58`	`}`
`58`	`59`
`59`		`- public WhereQuery<T> Where<U,V>(Expression<Func<T,U,V,bool>> predExpr)`
	`60`	`+ public WhereClause<T> Where<U,V>(Expression<Func<T,U,V,bool>> predExpr)`
`60`	`61`	`{`
`61`	`62`	`return this.Where((LambdaExpression) predExpr);`
`62`	`63`	`}`
`63`	`64`
`64`		`- public WhereQuery<T> Where<U>(Expression<Func<T,U,bool>> predExpr)`
	`65`	`+ public WhereClause<T> Where<U>(Expression<Func<T,U,bool>> predExpr)`
`65`	`66`	`{`
`66`	`67`	`return this.Where((LambdaExpression) predExpr);`
`67`	`68`	`}`
`68`	`69`
`69`		`- public WhereQuery<T> Where(Expression<Func<T, bool>> predExpr)`
	`70`	`+ public WhereClause<T> Where(Expression<Func<T, bool>> predExpr)`
`70`	`71`	`{`
`71`	`72`	`return this.Where((LambdaExpression) predExpr);`
`72`	`73`	`}`
`73`	`74`
`74`		`- private WhereQuery<T> Where(LambdaExpression lambda)`
	`75`	`+ private WhereClause<T> Where(LambdaExpression lambda)`
`75`	`76`	`{`
`76`	`77`	`var pred = lambda.Body;`
`77`	`78`	`var where = this.where == null ? pred : Expression.AndAlso(this.where, pred);`
`78`		`- return new WhereQuery<T>(table, where);`
	`79`	`+ return new WhereClause<T>(table, selection, where);`
`79`	`80`	`}`
`80`	`81`
`81`	`82`	`/// <summary>`
`82`	`83`	`/// Returns a <see cref="TableQuery<T>"/> that limits the result set to a specified number of contiguous elements.`
`83`	`84`	`/// </summary>`
`84`	`85`	`/// <param name="n">The number of elements to return.</param>`
`85`	`86`	`/// <returns>A new <see cref="SQLitePCL.pretty.Orm.TableQuery<T>"/>.</returns>`
`86`		`- public LimitQuery Take(int n)`
	`87`	`+ public LimitClause Take(int n)`
`87`	`88`	`{`
`88`		`- return new LimitQuery(table, selection, where, new List<Tuple<string, bool>>(), n, null);`
	`89`	`+ return new LimitClause(table, selection, where, new List<Tuple<string, bool>>(), n, null);`
`89`	`90`	`}`
`90`	`91`
`91`	`92`	`/// <summary>`
`92`	`93`	`/// Returns a <see cref="TableQuery<T>"/> that skips a specified number of elements in the result set and then returns the remaining elements.`
`93`	`94`	`/// </summary>`
`94`	`95`	`/// <param name="n">The number of elements to skip before returning the remaining elements.</param>`
`95`	`96`	`/// <returns>A new <see cref="SQLitePCL.pretty.Orm.TableQuery<T>"/>.</returns>`
`96`		`- public LimitQuery Skip(int n)`
	`97`	`+ public LimitClause Skip(int n)`
`97`	`98`	`{`
`98`		`- return new LimitQuery(table, selection, where, new List<Tuple<string, bool>>(), null, n);`
	`99`	`+ return new LimitClause(table, selection, where, new List<Tuple<string, bool>>(), null, n);`
`99`	`100`	`}`
`100`	`101`
`101`	`102`	`/// <summary>`
`@@ -104,14 +105,19 @@ public LimitQuery Skip(int n)`
`104`	`105`	`/// <returns>The <see cref="SQLitePCL.pretty.Orm.TableQuery<T>"/>.</returns>`
`105`	`106`	`/// <param name="index">Index.</param>`
`106`	`107`	`/// <returns>A new <see cref="SQLitePCL.pretty.Orm.TableQuery<T>"/>.</returns>`
`107`		`- public string ElementAt(int index)`
	`108`	`+ public LimitClause ElementAt(int index)`
`108`	`109`	`{`
`109`		`- return Skip(index).Take(1).ToString();`
	`110`	`+ return Skip(index).Take(1);`
`110`	`111`	`}`
`111`	`112`
`112`	`113`	`public override string ToString()`
`113`	`114`	`{`
`114`		`- return QueryBuilder.ToString(selection, table, where, Enumerable.Empty<Tuple<string, bool>>(), null, null);`
	`115`	`+ return SqlQuery.ToString(selection, table, where, Enumerable.Empty<Tuple<string, bool>>(), null, null);`
	`116`	`+ }`
	`117`	`+`
	`118`	`+ public string ToSql()`
	`119`	`+ {`
	`120`	`+ return this.ToString();`
`115`	`121`	`}`
`116`	`122`	`}`
`117`	`123`	`}`