Removed block for query on hierarchical CTE tables.

Author: glecchi

Lib/CSQLQueryExpress/Compiler/SQLQueryCompiler.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
 using System.Text;
@@ -36,6 +37,9 @@ public static SQLQueryCompiled Compile(ISQLQuery query,
             ISQLQueryParametersBuilder parameterBuilder,
             ISQLQueryTableNameResolver tableNameResolver)
         {
+            parameterBuilder.Initialize();
+            tableNameResolver.Initialize();
+
             var translatedQuery = CompileQuery(query, parameterBuilder, tableNameResolver);
 
             return new SQLQueryCompiled(translatedQuery, new ReadOnlyCollection<SQLQueryParameter>(parameterBuilder.Parameters.Select(p => p.Value).ToList()));
@@ -46,10 +50,7 @@ internal static string CompileQuery(
             ISQLQueryParametersBuilder parameterBuilder,
             ISQLQueryTableNameResolver tableNameResolver)
         {
-            parameterBuilder.Initialize();
-            tableNameResolver.Initialize();
-
-            var cteList = query.Where(f => f.FragmentType == SQLQueryFragmentType.SelectCte).ToList();
+            var cteList = query.GetHierachicalSelectCte();
             if (cteList.Count > 1 && cteList.Select(t => t.GetType().GenericTypeArguments[0]).Distinct().Count() != cteList.Count)
             {
                 throw new NotSupportedException("Multiple declaration of CTE TABLEs for the same Entity is not supported.");
@@ -59,15 +60,22 @@ internal static string CompileQuery(
 
             var translatedQueryBuilder = new StringBuilder();
 
+            var cteFragmentsTranslated = new List<ISQLQueryFragment>();
+
             if (cteList.Count > 0)
             {
                 var idx = cteList.Count - 1;
                 foreach (var cte in cteList)
                 {
-                    var withTableFragments = (ISQLQuery)cte;
+                    var withTableFragments = cte;
 
                     foreach (var fragment in withTableFragments)
                     {
+                        if (cteFragmentsTranslated.Contains(fragment))
+                        {
+                            continue;
+                        }
+
                         if (translatedQueryBuilder.Length == 0)
                         {
                             translatedQueryBuilder.Append("WITH ");
@@ -78,6 +86,8 @@ internal static string CompileQuery(
                         }
 
                         translatedQueryBuilder.Append(fragment.Translate(queryExpressionTranslator));
+
+                        cteFragmentsTranslated.Add(fragment);
                     }
 
                     if (idx-- > 0)
@@ -91,7 +101,7 @@ internal static string CompileQuery(
                 }
             }
 
-            var allFragments = query.Where(f => cteList.Count == 0 || !cteList.Contains(f));
+            var allFragments = query.Where(f => cteFragmentsTranslated.Count == 0 || !cteFragmentsTranslated.Contains(f));
 
             foreach (var fragment in allFragments)
             {

Lib/CSQLQueryExpress/Compiler/SQLQueryUtils.cs

@@ -31,6 +31,34 @@ public static bool IsHierarchicalSelectFromCte(this ISQLQuery query)
             return false;
         }
 
+        public static IList<ISQLQuery> GetHierachicalSelectCte(this ISQLQuery query)
+        {
+            var selectCteList = new List<ISQLQuery>();
+
+            ExtractHierachicalSelectCte(query, selectCteList);
+
+            return selectCteList;
+        }
+
+        private static void ExtractHierachicalSelectCte(ISQLQuery query, IList<ISQLQuery> selectCteList)
+        {
+            foreach (var fragment in query)
+            {
+                if (fragment.FragmentType == SQLQueryFragmentType.FromBySelect ||
+                    fragment.FragmentType == SQLQueryFragmentType.JoinBySelect)
+                {
+                    var hSelect = ((ISQLQueryFragmentFromSelect)fragment).FromSelect;
+
+                    ExtractHierachicalSelectCte(hSelect, selectCteList);
+
+                    if (hSelect.FragmentType == SQLQueryFragmentType.SelectCte)
+                    {
+                        selectCteList.Add(hSelect);
+                    }
+                }
+            }
+        }
+
         public static T[] Merge<T>(this T first, T second, params T[] others)
         {
             var list = new List<T>

Lib/CSQLQueryExpress/Fragments/SQLQueryFrom.cs

@@ -18,11 +18,6 @@ internal SQLQueryFrom(IList<ISQLQueryFragment> fragments, SQLQuerySelect<T> sele
         {
             _fragments = fragments;
 
-            if (select != null && select.IsHierarchicalSelectFromCte())
-            {
-                throw new NotSupportedException("Hierachical select queries from CTE TABLE is not supported.");
-            }
-
             _select = select;
 
             if (_select != null && _select.FragmentType == SQLQueryFragmentType.SelectCte)

Lib/CSQLQueryExpress/Fragments/SQLQueryJoin.cs

@@ -41,11 +41,6 @@ internal SQLQueryJoin(IList<ISQLQueryFragment> fragments, SQLQueryJoinType joinT
             _type = type;
             _select = select;
 
-            if (select != null && select.IsHierarchicalSelectFromCte())
-            {
-                throw new NotSupportedException("Hierachical select queries from CTE TABLE is not supported.");
-            }
-
             if ((_joinType == SQLQueryJoinType.CrossApply || _joinType == SQLQueryJoinType.OuterApply) && 
                 (_select == null || _select.FragmentType == SQLQueryFragmentType.SelectCte))
             {

Lib/CSQLQueryExpress/Fragments/SQLQuerySelect.cs

@@ -214,11 +214,6 @@ public SQLQueryInto<T> Into()
 
         public SQLQuerySelect<T> ToCteTable()
         {
-            if (_fragments.Any(f => f.FragmentType == SQLQueryFragmentType.SelectCte))
-            {
-                throw new NotSupportedException("CTE TABLE declaration FROM CTE TABLE is not supported.");
-            }
-
             _useCte = true;
             return this;
         }

Tests/CSQLQueryExpress.Tests/CSQLQueryExpress.Tests.csproj

@@ -78,6 +78,9 @@
     <None Update="UnitTests\JoinStatements\TestInnerJoin.txt">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
     </None>
+    <None Update="UnitTests\SelectStatements\TestStatement11.txt">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
     <None Update="UnitTests\SelectStatements\TestStatement2.txt">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
     </None>

Tests/CSQLQueryExpress.Tests/UnitTests/QuerySelectUnitTest.cs

@@ -328,6 +328,39 @@ public void TestStatement10()
             Assert.DoesNotThrow(() => queryCommand.ToList());
         }
 
+        [Test]
+        public void TestStatement11()
+        {
+            var queryCategoriesCte = new SQLQuery()
+                .From<dbo.Categories>()
+                .Select(c => c.All())
+                .ToCteTable();
+
+            var queryProductsCte = new SQLQuery()
+                .From<dbo.Products>()
+                .InnerJoin(queryCategoriesCte, (p, c) => p.CategoryID == c.CategoryID)
+                .Where((p, c) => p.SupplierID.IsNotNull())
+                .Select((p, c) => p.All())
+                .ToCteTable();
+
+            var query = new SQLQuery()
+                .From<dbo.Suppliers>()
+                .InnerJoin(queryProductsCte, (s, p) => s.SupplierID == p.SupplierID)
+                .Select((s, p) => s.All());
+
+            var compiledQuery = query.Compile();
+
+            Assert.That(compiledQuery.Parameters.Count, Is.EqualTo(0));
+
+            var statement = GetSQLStatement();
+
+            Assert.That(compiledQuery.Statement, Is.EqualTo(statement));
+
+            var queryCommand = new SQLQueryCommandReader(ConnectionString, compiledQuery);
+
+            Assert.DoesNotThrow(() => queryCommand.ToList());
+        }
+
         private string GetSQLStatement([CallerMemberName] string memeberName = null)
         {
             var statement = File.ReadAllText($@"UnitTests\SelectStatements\{memeberName}.txt");