Merge pull request #2770 from ssougnez/temp-U4-11513

Added "Select" and "AndSelect" to "PetaPoco"

src/Umbraco.Core/Persistence/PetaPoco.cs

@@ -2494,9 +2494,9 @@ namespace Umbraco.Core.Persistence
 			// Now do rhs
 			if (_rhs != null)
 				_rhs.Build(sb, args, this);
-		}
+        }
 
-		public Sql Where(string sql, params object[] args)
+        public Sql Where(string sql, params object[] args)
 		{
 			return Append(new Sql("WHERE (" + sql + ")", args));
 		}
@@ -2509,9 +2509,14 @@ namespace Umbraco.Core.Persistence
 		public Sql Select(params object[] columns)
 		{
 			return Append(new Sql("SELECT " + String.Join(", ", (from x in columns select x.ToString()).ToArray())));
-		}
+        }
 
-		public Sql From(params object[] tables)
+        public Sql AndSelect(params object[] columns)
+        {
+            return Append(new Sql(", " + String.Join(", ", (from x in columns select x.ToString()).ToArray())));
+        }
+
+        public Sql From(params object[] tables)
 		{
 			return Append(new Sql("FROM " + String.Join(", ", (from x in tables select x.ToString()).ToArray())));
 		}

src/Umbraco.Core/Persistence/PetaPocoSqlExtensions.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections;
-using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
@@ -15,6 +14,32 @@ namespace Umbraco.Core.Persistence
     /// </summary>
     public static class PetaPocoSqlExtensions
     {
+        /// <summary>
+        /// Defines the column to select in the generated SQL query
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="sql">Sql object</param>
+        /// <param name="sqlSyntax">Sql syntax</param>
+        /// <param name="fields">Columns to select</param>
+        /// <returns></returns>
+        public static Sql Select<T>(this Sql sql, ISqlSyntaxProvider sqlSyntax, params Expression<Func<T, object>>[] fields)
+        {
+            return sql.Select(GetFieldNames(sqlSyntax, fields));
+        }
+        
+        /// <summary>
+        /// Adds another set of field to select. This method must be used with "Select" when fecthing fields from different tables.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="sql">Sql object</param>
+        /// <param name="sqlSyntax">Sql syntax</param>
+        /// <param name="fields">Additional columns to select</param>
+        /// <returns></returns>
+        public static Sql AndSelect<T>(this Sql sql, ISqlSyntaxProvider sqlSyntax, params Expression<Func<T, object>>[] fields)
+        {
+            return sql.AndSelect(GetFieldNames(sqlSyntax, fields));
+        }
+
         [Obsolete("Use the overload specifying ISqlSyntaxProvider instead")]
         public static Sql From<T>(this Sql sql)
         {
@@ -55,6 +80,16 @@ namespace Umbraco.Core.Persistence
             return sqlSyntax.GetQuotedTableName(tableName) + "." + sqlSyntax.GetQuotedColumnName(fieldName);
         }
 
+        private static string[] GetFieldNames<T>(ISqlSyntaxProvider sqlSyntax, params Expression<Func<T, object>>[] fields)
+        {
+            if (fields.Length == 0)
+            {
+                return new[] { string.Format("{0}.*", sqlSyntax.GetQuotedTableName(typeof(T).GetTableName())) };
+            }
+
+            return fields.Select(field => GetFieldName(field, sqlSyntax)).ToArray();
+        }
+
         [Obsolete("Use the overload specifying ISqlSyntaxProvider instead")]
         public static Sql WhereIn<T>(this Sql sql, Expression<Func<T, object>> fieldSelector, IEnumerable values)
         {
@@ -240,4 +275,4 @@ namespace Umbraco.Core.Persistence
             return attr == null || string.IsNullOrWhiteSpace(attr.Name) ? column.Name : attr.Name;
         }
     }
-}
+}

src/Umbraco.Tests/Persistence/Querying/PetaPocoSqlTests.cs

@@ -1,38 +1,40 @@
-using System;
+using NUnit.Framework;
 using System.Diagnostics;
 using System.Linq;
-using NUnit.Framework;
-using Umbraco.Core.Models;
-using Umbraco.Core.Models.Membership;
 using Umbraco.Core.Models.Rdbms;
 using Umbraco.Core.Persistence;
-using Umbraco.Core.Persistence.Repositories;
-using Umbraco.Tests.TestHelpers;
 using Umbraco.Core.Persistence.Querying;
+using Umbraco.Core.Persistence.SqlSyntax;
+using Umbraco.Tests.TestHelpers;
 
 namespace Umbraco.Tests.Persistence.Querying
 {
     [TestFixture]
     public class PetaPocoSqlTests : BaseUsingSqlCeSyntax
     {
+        private readonly ISqlSyntaxProvider sqlSyntax = new SqlCeSyntaxProvider();
         //x => 
 
         [Test]
         public void Where_Clause_With_Starts_With_Additional_Parameters()
         {
             var content = new NodeDto() { NodeId = 123, Path = "-1,123" };
-            var sql = new Sql("SELECT *").From<NodeDto>().Where<NodeDto>(x => x.Path.SqlStartsWith(content.Path, TextColumnType.NVarchar));
+            var sql = new Sql("SELECT *")
+                .From<NodeDto>(sqlSyntax)
+                .Where<NodeDto>(x => x.Path.SqlStartsWith(content.Path, TextColumnType.NVarchar), sqlSyntax);
 
             Assert.AreEqual("SELECT * FROM [umbracoNode] WHERE (upper([umbracoNode].[path]) LIKE upper(@0))", sql.SQL.Replace("\n", " "));
             Assert.AreEqual(1, sql.Arguments.Length);
-            Assert.AreEqual(content.Path + "%", sql.Arguments[0]);        
+            Assert.AreEqual(content.Path + "%", sql.Arguments[0]);
         }
 
         [Test]
         public void Where_Clause_With_Starts_With_By_Variable()
         {
-            var content = new NodeDto() {NodeId = 123, Path = "-1,123"};
+            var content = new NodeDto() { NodeId = 123, Path = "-1,123" };
-            var sql = new Sql("SELECT *").From<NodeDto>().Where<NodeDto>(x => x.Path.StartsWith(content.Path) && x.NodeId != content.NodeId);
+            var sql = new Sql("SELECT *")
+                .From<NodeDto>(sqlSyntax)
+                .Where<NodeDto>(x => x.Path.StartsWith(content.Path) && x.NodeId != content.NodeId, sqlSyntax);
 
             Assert.AreEqual("SELECT * FROM [umbracoNode] WHERE ((upper([umbracoNode].[path]) LIKE upper(@0) AND ([umbracoNode].[id] <> @1)))", sql.SQL.Replace("\n", " "));
             Assert.AreEqual(2, sql.Arguments.Length);
@@ -44,7 +46,9 @@ namespace Umbraco.Tests.Persistence.Querying
         public void Where_Clause_With_Not_Starts_With()
         {
             var level = 1;
-            var sql = new Sql("SELECT *").From<NodeDto>().Where<NodeDto>(x => x.Level == level && !x.Path.StartsWith("-20"));
+            var sql = new Sql("SELECT *")
+                .From<NodeDto>(sqlSyntax)
+                .Where<NodeDto>(x => x.Level == level && !x.Path.StartsWith("-20"), sqlSyntax);
 
             Assert.AreEqual("SELECT * FROM [umbracoNode] WHERE ((([umbracoNode].[level] = @0) AND NOT (upper([umbracoNode].[path]) LIKE upper(@1))))", sql.SQL.Replace("\n", " "));
             Assert.AreEqual(2, sql.Arguments.Length);
@@ -56,7 +60,9 @@ namespace Umbraco.Tests.Persistence.Querying
         public void Where_Clause_With_EqualsFalse_Starts_With()
         {
             var level = 1;
-            var sql = new Sql("SELECT *").From<NodeDto>().Where<NodeDto>(x => x.Level == level && x.Path.StartsWith("-20") == false);
+            var sql = new Sql("SELECT *")
+                .From<NodeDto>(sqlSyntax)
+                .Where<NodeDto>(x => x.Level == level && x.Path.StartsWith("-20") == false, sqlSyntax);
 
             Assert.AreEqual("SELECT * FROM [umbracoNode] WHERE ((([umbracoNode].[level] = @0) AND NOT (upper([umbracoNode].[path]) LIKE upper(@1))))", sql.SQL.Replace("\n", " "));
             Assert.AreEqual(2, sql.Arguments.Length);
@@ -67,7 +73,9 @@ namespace Umbraco.Tests.Persistence.Querying
         [Test]
         public void Where_Clause_With_Equals_Clause()
         {
-            var sql = new Sql("SELECT *").From<NodeDto>().Where<NodeDto>(x => x.Text.Equals("Hello@world.com"));
+            var sql = new Sql("SELECT *")
+                .From<NodeDto>(sqlSyntax)
+                .Where<NodeDto>(x => x.Text.Equals("Hello@world.com"), sqlSyntax);
 
             Assert.AreEqual("SELECT * FROM [umbracoNode] WHERE (upper([umbracoNode].[text]) = upper(@0))", sql.SQL.Replace("\n", " "));
             Assert.AreEqual(1, sql.Arguments.Length);
@@ -77,7 +85,9 @@ namespace Umbraco.Tests.Persistence.Querying
         [Test]
         public void Where_Clause_With_False_Boolean()
         {
-            var sql = new Sql("SELECT *").From<NodeDto>().Where<NodeDto>(x => !x.Trashed);
+            var sql = new Sql("SELECT *")
+                .From<NodeDto>(sqlSyntax)
+                .Where<NodeDto>(x => !x.Trashed, sqlSyntax);
 
             Assert.AreEqual("SELECT * FROM [umbracoNode] WHERE (NOT ([umbracoNode].[trashed] = @0))", sql.SQL.Replace("\n", " "));
             Assert.AreEqual(1, sql.Arguments.Length);
@@ -87,7 +97,9 @@ namespace Umbraco.Tests.Persistence.Querying
         [Test]
         public void Where_Clause_With_EqualsFalse_Boolean()
         {
-            var sql = new Sql("SELECT *").From<NodeDto>().Where<NodeDto>(x => x.Trashed == false);
+            var sql = new Sql("SELECT *")
+                .From<NodeDto>(sqlSyntax)
+                .Where<NodeDto>(x => x.Trashed == false, sqlSyntax);
 
             Assert.AreEqual("SELECT * FROM [umbracoNode] WHERE (NOT ([umbracoNode].[trashed] = @0))", sql.SQL.Replace("\n", " "));
             Assert.AreEqual(1, sql.Arguments.Length);
@@ -97,7 +109,9 @@ namespace Umbraco.Tests.Persistence.Querying
         [Test]
         public void Where_Clause_With_Boolean()
         {
-            var sql = new Sql("SELECT *").From<NodeDto>().Where<NodeDto>(x => x.Trashed);
+            var sql = new Sql("SELECT *")
+                .From<NodeDto>(sqlSyntax)
+                .Where<NodeDto>(x => x.Trashed, sqlSyntax);
 
             Assert.AreEqual("SELECT * FROM [umbracoNode] WHERE ([umbracoNode].[trashed] = @0)", sql.SQL.Replace("\n", " "));
             Assert.AreEqual(1, sql.Arguments.Length);
@@ -107,7 +121,9 @@ namespace Umbraco.Tests.Persistence.Querying
         [Test]
         public void Where_Clause_With_ToUpper()
         {
-            var sql = new Sql("SELECT *").From<NodeDto>().Where<NodeDto>(x => x.Text.ToUpper() == "hello".ToUpper());
+            var sql = new Sql("SELECT *")
+                .From<NodeDto>(sqlSyntax)
+                .Where<NodeDto>(x => x.Text.ToUpper() == "hello".ToUpper(), sqlSyntax);
 
             Assert.AreEqual("SELECT * FROM [umbracoNode] WHERE ((upper([umbracoNode].[text]) = upper(@0)))", sql.SQL.Replace("\n", " "));
             Assert.AreEqual(1, sql.Arguments.Length);
@@ -117,7 +133,9 @@ namespace Umbraco.Tests.Persistence.Querying
         [Test]
         public void Where_Clause_With_ToString()
         {
-            var sql = new Sql("SELECT *").From<NodeDto>().Where<NodeDto>(x => x.Text == 1.ToString());
+            var sql = new Sql("SELECT *")
+                .From<NodeDto>(sqlSyntax)
+                .Where<NodeDto>(x => x.Text == 1.ToString(), sqlSyntax);
 
             Assert.AreEqual("SELECT * FROM [umbracoNode] WHERE (([umbracoNode].[text] = @0))", sql.SQL.Replace("\n", " "));
             Assert.AreEqual(1, sql.Arguments.Length);
@@ -127,7 +145,9 @@ namespace Umbraco.Tests.Persistence.Querying
         [Test]
         public void Where_Clause_With_Wildcard()
         {
-            var sql = new Sql("SELECT *").From<NodeDto>().Where<NodeDto>(x => x.Text.StartsWith("D"));
+            var sql = new Sql("SELECT *")
+                .From<NodeDto>(sqlSyntax)
+                .Where<NodeDto>(x => x.Text.StartsWith("D"), sqlSyntax);
 
             Assert.AreEqual("SELECT * FROM [umbracoNode] WHERE (upper([umbracoNode].[text]) LIKE upper(@0))", sql.SQL.Replace("\n", " "));
             Assert.AreEqual(1, sql.Arguments.Length);
@@ -137,7 +157,9 @@ namespace Umbraco.Tests.Persistence.Querying
         [Test]
         public void Where_Clause_Single_Constant()
         {
-            var sql = new Sql("SELECT *").From<NodeDto>().Where<NodeDto>(x => x.NodeId == 2);
+            var sql = new Sql("SELECT *")
+                .From<NodeDto>(sqlSyntax)
+                .Where<NodeDto>(x => x.NodeId == 2, sqlSyntax);
 
             Assert.AreEqual("SELECT * FROM [umbracoNode] WHERE (([umbracoNode].[id] = @0))", sql.SQL.Replace("\n", " "));
             Assert.AreEqual(1, sql.Arguments.Length);
@@ -147,7 +169,9 @@ namespace Umbraco.Tests.Persistence.Querying
         [Test]
         public void Where_Clause_And_Constant()
         {
-            var sql = new Sql("SELECT *").From<NodeDto>().Where<NodeDto>(x => x.NodeId != 2 && x.NodeId != 3);
+            var sql = new Sql("SELECT *")
+                .From<NodeDto>(sqlSyntax)
+                .Where<NodeDto>(x => x.NodeId != 2 && x.NodeId != 3, sqlSyntax);
 
             Assert.AreEqual("SELECT * FROM [umbracoNode] WHERE ((([umbracoNode].[id] <> @0) AND ([umbracoNode].[id] <> @1)))", sql.SQL.Replace("\n", " "));
             Assert.AreEqual(2, sql.Arguments.Length);
@@ -158,7 +182,9 @@ namespace Umbraco.Tests.Persistence.Querying
         [Test]
         public void Where_Clause_Or_Constant()
         {
-            var sql = new Sql("SELECT *").From<NodeDto>().Where<NodeDto>(x => x.Text == "hello" || x.NodeId == 3);
+            var sql = new Sql("SELECT *")
+                .From<NodeDto>(sqlSyntax)
+                .Where<NodeDto>(x => x.Text == "hello" || x.NodeId == 3, sqlSyntax);
 
             Assert.AreEqual("SELECT * FROM [umbracoNode] WHERE ((([umbracoNode].[text] = @0) OR ([umbracoNode].[id] = @1)))", sql.SQL.Replace("\n", " "));
             Assert.AreEqual(2, sql.Arguments.Length);
@@ -173,7 +199,7 @@ namespace Umbraco.Tests.Persistence.Querying
             expected.Select("*").From("[cmsContent]");
 
             var sql = new Sql();
-            sql.Select("*").From<ContentDto>();
+            sql.Select("*").From<ContentDto>(sqlSyntax);
 
             Assert.That(sql.SQL, Is.EqualTo(expected.SQL));
 
@@ -190,9 +216,9 @@ namespace Umbraco.Tests.Persistence.Querying
                 .On("[cmsDocument].[versionId] = [cmsContentVersion].[VersionId]");
 
             var sql = new Sql();
-            sql.Select("*").From<DocumentDto>()
+            sql.Select("*").From<DocumentDto>(sqlSyntax)
-                .InnerJoin<ContentVersionDto>()
+                .InnerJoin<ContentVersionDto>(sqlSyntax)
-                .On<DocumentDto, ContentVersionDto>(left => left.VersionId, right => right.VersionId);
+                .On<DocumentDto, ContentVersionDto>(sqlSyntax, left => left.VersionId, right => right.VersionId);
 
             Assert.That(sql.SQL, Is.EqualTo(expected.SQL));
 
@@ -206,7 +232,7 @@ namespace Umbraco.Tests.Persistence.Querying
             expected.Select("*").From("[cmsContent]").OrderBy("([cmsContent].[contentType])");
 
             var sql = new Sql();
-            sql.Select("*").From<ContentDto>().OrderBy<ContentDto>(x => x.ContentTypeId);
+            sql.Select("*").From<ContentDto>(sqlSyntax).OrderBy<ContentDto>(x => x.ContentTypeId, sqlSyntax);
 
             Assert.That(sql.SQL, Is.EqualTo(expected.SQL));
 
@@ -220,7 +246,7 @@ namespace Umbraco.Tests.Persistence.Querying
             expected.Select("*").From("[cmsContent]").GroupBy("[contentType]");
 
             var sql = new Sql();
-            sql.Select("*").From<ContentDto>().GroupBy<ContentDto>(x => x.ContentTypeId);
+            sql.Select("*").From<ContentDto>(sqlSyntax).GroupBy<ContentDto>(x => x.ContentTypeId, sqlSyntax);
 
             Assert.That(sql.SQL, Is.EqualTo(expected.SQL));
 
@@ -234,7 +260,7 @@ namespace Umbraco.Tests.Persistence.Querying
             expected.Select("*").From("[cmsContent]").Where("([cmsContent].[nodeId] = @0)", 1045);
 
             var sql = new Sql();
-            sql.Select("*").From<ContentDto>().Where<ContentDto>(x => x.NodeId == 1045);
+            sql.Select("*").From<ContentDto>(sqlSyntax).Where<ContentDto>(x => x.NodeId == 1045, sqlSyntax);
 
             Assert.That(sql.SQL, Is.EqualTo(expected.SQL));
 
@@ -252,13 +278,82 @@ namespace Umbraco.Tests.Persistence.Querying
 
             var sql = new Sql();
             sql.Select("*")
-                .From<ContentDto>()
+                .From<ContentDto>(sqlSyntax)
-                .Where<ContentDto>(x => x.NodeId == 1045)
+                .Where<ContentDto>(x => x.NodeId == 1045, sqlSyntax)
-                .Where<ContentDto>(x => x.ContentTypeId == 1050);
+                .Where<ContentDto>(x => x.ContentTypeId == 1050, sqlSyntax);
+
+            Assert.That(sql.SQL, Is.EqualTo(expected.SQL));
+
+            Debug.Print(sql.SQL);
+        }
+
+        [Test]
+        public void Can_Use_Select_With_Star_And_Predicate()
+        {
+            var expected = new Sql();
+            expected.Select("[cmsContent].*")
+                .From("[cmsContent]");
+
+            var sql = new Sql();
+            sql.Select<ContentDto>(sqlSyntax)
+                .From<ContentDto>(sqlSyntax);
+
+            Assert.That(sql.SQL, Is.EqualTo(expected.SQL));
+
+            Debug.Print(sql.SQL);
+        }
+
+        [Test]
+        public void Can_Use_Select_With_One_Column_And_Predicate()
+        {
+            var expected = new Sql();
+            expected.Select("[cmsContent].[nodeId]")
+                .From("[cmsContent]");
+
+            var sql = new Sql();
+            sql.Select<ContentDto>(sqlSyntax, c => c.NodeId)
+                .From<ContentDto>(sqlSyntax);
+
+            Assert.That(sql.SQL, Is.EqualTo(expected.SQL));
+
+            Debug.Print(sql.SQL);
+        }
+
+        [Test]
+        public void Can_Use_Select_With_Multiple_Column_And_Predicate()
+        {
+            var expected = new Sql();
+            expected.Select("[cmsContent].[nodeId]", "[cmsContent].[contentType]", "[cmsContent].[pk]")
+                .From("[cmsContent]");
+
+            var sql = new Sql();
+            sql.Select<ContentDto>(sqlSyntax, c => c.NodeId, c => c.ContentTypeId, c => c.PrimaryKey)
+                .From<ContentDto>(sqlSyntax);
+
+            Assert.That(sql.SQL, Is.EqualTo(expected.SQL));
+
+            Debug.Print(sql.SQL);
+        }
+
+        [Test]
+        public void Can_InnerJoin_With_Select_And_AndSelect()
+        {
+            var expected = new Sql();
+            expected.Select("[cmsDocument].[nodeId], [cmsDocument].[published]\n, [cmsContentVersion].[id]")
+                .From("[cmsDocument]")
+                .InnerJoin("[cmsContentVersion]")
+                .On("[cmsDocument].[versionId] = [cmsContentVersion].[VersionId]");
+
+            var sql = new Sql();
+            sql.Select<DocumentDto>(sqlSyntax, d => d.NodeId, d => d.Published)
+                .AndSelect<ContentVersionDto>(sqlSyntax, cv => cv.Id)
+                .From<DocumentDto>(sqlSyntax)
+                .InnerJoin<ContentVersionDto>(sqlSyntax)
+                .On<DocumentDto, ContentVersionDto>(sqlSyntax, left => left.VersionId, right => right.VersionId);
 
             Assert.That(sql.SQL, Is.EqualTo(expected.SQL));
 
             Debug.Print(sql.SQL);
         }
     }
-}
+}