Create FindAll method

2026-07-15 14:59:32 +00:00 · 2025-05-13 17:05:13 +02:00
parent 5bc6c9ae7d
commit 749c77b6df
10 changed files with 85 additions and 3 deletions
@@ -16,6 +16,7 @@ public sealed class ColumnNameAttributeGenerator : IIncrementalGenerator
    {
        var builder = SyntaxBuilder.CreateCompilationUnit()
            .WithNamespace(SyntaxBuilder.CreateNamespace(Constants.Namespace)
+            .WithUsing(Constants.UsingSystem)
                .WithClass(SyntaxBuilder.CreateClass(Constants.ColumnNameAttributeName)
                    .WithBaseClass(nameof(Attribute))
                    .WithModifiers($"{Constants.Public} {Constants.Sealed}")
@@ -21,6 +21,8 @@ public static class Constants
    public const string DbCommandType = "DbCommand";
    public const string FuncType = "Func";
    public const string NullableObject = "object?";
+    public const string IAsyncEnumerableType = "IAsyncEnumerable";
+    public const string EnumeratorCancellationAttribute = "EnumeratorCancellation";

    public const string PrimaryKey = "PRIMARY KEY";
    public const string ForeignKey = "FOREIGN KEY";
@@ -32,7 +34,12 @@ public static class Constants

    public const string Namespace = "Squealify";

+    public const string UsingSystem = "System";
    public const string UsingSystemDataCommon = "System.Data.Common";
+    public const string UsingSystemRuntimeCompilerServices = "System.Runtime.CompilerServices";
+    public const string UsingSystemCollectionsGeneric = "System.Collections.Generic";
+    public const string UsingSystemThreadingTasks = "System.Threading.Tasks";
+    public const string UsingSystemThreading = "System.Threading";

    public const string CancellationTokenArgument = "cancellationToken";

@@ -93,4 +100,5 @@ public static class Constants
    public const string UpdateMethodName = "Update";
    public const string DeleteMethodName = "Delete";
    public const string FindMethodName = "Find";
+    public const string FindAllMethodName = "FindAll";
 }
@@ -16,6 +16,7 @@ public sealed class ForeignKeyAttributeGenerator : IIncrementalGenerator
    {
        var builder = SyntaxBuilder.CreateCompilationUnit()
            .WithNamespace(SyntaxBuilder.CreateNamespace(Constants.Namespace)
+            .WithUsing(Constants.UsingSystem)
                .WithClass(SyntaxBuilder.CreateClass(Constants.ForeignKeyAttributeName)
                    .WithBaseClass(nameof(Attribute))
                    .WithModifiers($"{Constants.Public} {Constants.Sealed}")
@@ -16,6 +16,7 @@ public sealed class PrimaryKeyAttributeGenerator : IIncrementalGenerator
    {
        var builder = SyntaxBuilder.CreateCompilationUnit()
            .WithNamespace(SyntaxBuilder.CreateNamespace(Constants.Namespace)
+            .WithUsing(Constants.UsingSystem)
                .WithClass(SyntaxBuilder.CreateClass(Constants.PrimaryKeyAttributeName)
                    .WithBaseClass(nameof(Attribute))
                    .WithModifiers($"{Constants.Public} {Constants.Sealed}")
@@ -2,7 +2,7 @@

  <PropertyGroup>
    <TargetFramework>netstandard2.0</TargetFramework>
-    <Version>0.8.1</Version>
+    <Version>0.8.2</Version>
    <LangVersion>latest</LangVersion>
    <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
    <Authors>Alexandru Macocian</Authors>
@@ -197,6 +197,65 @@ command.CommandText = @""{placeHolder}"";
        return new MethodWithSqlStatement(methodBuilder, placeHolder, sql.ToString());
    }

+    public static MethodWithSqlStatement CreateFindAllStatement(TableContext context)
+    {
+        var placeHolder = $"FindAll{context.DboType}";
+        var sql = new StringBuilder();
+        sql.AppendLine()
+            .AppendLine($"\t\t\tSELECT * FROM {context.TableName};");
+
+        var bodyBuilder = new StringBuilder(@$"
+using var command = this.{Constants.DbConnectionPropertyName}.CreateCommand();
+command.CommandText = @""{placeHolder}"";
+");
+
+        if (!DataTypeMappings.DataTypeToString.TryGetValue(context.PrimaryKey.Type, out var convertedType))
+        {
+            throw new InvalidOperationException($"Unable to find conversion for {context.PrimaryKey.Type}");
+        }
+
+        bodyBuilder.AppendLine($"using var reader = await command.ExecuteReaderAsync({Constants.CancellationTokenArgument});");
+        bodyBuilder.AppendLine($"while (await reader.ReadAsync({Constants.CancellationTokenArgument}))");
+        bodyBuilder.AppendLine("{");
+        bodyBuilder.AppendLine($"yield return new {context.DboType}");
+        bodyBuilder.AppendLine("{");
+        foreach ((var index, var fieldContext) in context.Fields.Select((f, i) => (i, f)))
+        {
+            if (!DataTypeMappings.DataTypeToString.TryGetValue(fieldContext.Type, out var convertedFieldType))
+            {
+                continue;
+            }
+
+            (_, var convertFromName) = SyntaxParsers.GetConversionNames(fieldContext.PropertyType, convertedFieldType);
+
+            var fieldValueProvider = fieldContext.RequiresConversion
+                ? $"this.{convertFromName}({GetReaderMethod("reader", fieldContext)}({index}))"
+                : $"{GetReaderMethod("reader", fieldContext)}({index})";
+
+            var nullCheckGuardedProvider = fieldContext.IsNullable
+                ? $"await reader.IsDBNullAsync({index}, {Constants.CancellationTokenArgument}) ? default : {fieldValueProvider}"
+                : fieldValueProvider;
+
+            bodyBuilder.Append($"{fieldContext.PropertyName} = {nullCheckGuardedProvider}");
+            if (index < context.Fields.Length - 1)
+            {
+                bodyBuilder.AppendLine(",");
+            }
+        }
+        bodyBuilder
+            .AppendLine()
+            .AppendLine("};")
+            .AppendLine("}");
+
+        var methodBuilder = SyntaxBuilder.CreateMethod($"{Constants.IAsyncEnumerableType}<{context.DboType}>", Constants.FindAllMethodName)
+            .WithModifiers($"{Constants.Public} {Constants.Async}")
+            .WithParameter(context.PrimaryKey.PropertyType, Constants.PrimaryKeyArgumentName)
+            .WithParameter($"[{Constants.EnumeratorCancellationAttribute}] {Constants.CancellationTokenType}", Constants.CancellationTokenArgument)
+            .WithBody(bodyBuilder.ToString());
+
+        return new MethodWithSqlStatement(methodBuilder, placeHolder, sql.ToString());
+    }
+
    private static string GenerateFullBody(string placeHolder, TableContext context)
    {
        var bodyBuilder = new StringBuilder(@$"
@@ -16,6 +16,7 @@ public sealed class TableAttributeGenerator : IIncrementalGenerator
    {
        var builder = SyntaxBuilder.CreateCompilationUnit()
            .WithNamespace(SyntaxBuilder.CreateNamespace(Constants.Namespace)
+            .WithUsing(Constants.UsingSystem)
                .WithClass(SyntaxBuilder.CreateClass(Constants.TableAttributeName)
                    .WithBaseClass(nameof(Attribute))
                    .WithModifiers($"{Constants.Public} {Constants.Sealed}")
@@ -66,7 +66,12 @@ public sealed class TableContextGenerator : IIncrementalGenerator
        var contextClassName = $"{classDeclarationSyntax.Identifier.ValueText}TableContextBase";
        var usingsSet = new HashSet<string>
        {
-            Constants.UsingSystemDataCommon
+            Constants.UsingSystem,
+            Constants.UsingSystemDataCommon,
+            Constants.UsingSystemRuntimeCompilerServices,
+            Constants.UsingSystemCollectionsGeneric,
+            Constants.UsingSystemThreadingTasks,
+            Constants.UsingSystemThreading
        };

        // Add the namespace of the class declaration (if any)
@@ -122,6 +127,7 @@ public sealed class TableContextGenerator : IIncrementalGenerator
        var updateMethod = BasicQueryMethodGenerator.CreateUpdateStatement(ctx);
        var deleteMethod = BasicQueryMethodGenerator.CreateDeleteStatement(ctx);
        var findMethod = BasicQueryMethodGenerator.CreateFindStatement(ctx);
+        var findAllMethod = BasicQueryMethodGenerator.CreateFindAllStatement(ctx);
        classBuilder
            .WithMethod(createMethod.MethodBuilder)
            .WithMethod(createIfNotExistsMethod.MethodBuilder)
@@ -130,6 +136,7 @@ public sealed class TableContextGenerator : IIncrementalGenerator
            .WithMethod(updateMethod.MethodBuilder)
            .WithMethod(deleteMethod.MethodBuilder)
            .WithMethod(findMethod.MethodBuilder)
+            .WithMethod(findAllMethod.MethodBuilder)
            .WithMethod(CreateParameterMethodGenerator.CreateParameterMethod());

        // Generate conversion properties
@@ -155,7 +162,8 @@ public sealed class TableContextGenerator : IIncrementalGenerator
            .Replace(upsertMethod.Placeholder, upsertMethod.CommandText)
            .Replace(updateMethod.Placeholder, updateMethod.CommandText)
            .Replace(deleteMethod.Placeholder, deleteMethod.CommandText)
-            .Replace(findMethod.Placeholder, findMethod.CommandText);
+            .Replace(findMethod.Placeholder, findMethod.CommandText)
+            .Replace(findAllMethod.Placeholder, findAllMethod.CommandText);

        sourceProductionContext.AddSource($"{contextClassName}.g.cs", source);
    }
@@ -16,6 +16,7 @@ public sealed class UniqueAttributeGenerator : IIncrementalGenerator
    {
        var columnUniqueBuilder = SyntaxBuilder.CreateCompilationUnit()
            .WithNamespace(SyntaxBuilder.CreateNamespace(Constants.Namespace)
+            .WithUsing(Constants.UsingSystem)
                .WithClass(SyntaxBuilder.CreateClass(Constants.ColumnUniqueAttributeName)
                    .WithBaseClass(nameof(Attribute))
                    .WithModifiers($"{Constants.Public} {Constants.Sealed}")
@@ -30,6 +31,7 @@ public sealed class UniqueAttributeGenerator : IIncrementalGenerator

        var tableUniqueBuilder = SyntaxBuilder.CreateCompilationUnit()
            .WithNamespace(SyntaxBuilder.CreateNamespace(Constants.Namespace)
+            .WithUsing(Constants.UsingSystem)
                .WithClass(SyntaxBuilder.CreateClass(Constants.TableUniqueAttributeName)
                    .WithBaseClass(nameof(Attribute))
                    .WithModifiers($"{Constants.Public} {Constants.Sealed}")
@@ -16,6 +16,7 @@ public sealed class VarcharAttributeGenerator : IIncrementalGenerator
    {
        var builder = SyntaxBuilder.CreateCompilationUnit()
            .WithNamespace(SyntaxBuilder.CreateNamespace(Constants.Namespace)
+            .WithUsing(Constants.UsingSystem)
                .WithClass(SyntaxBuilder.CreateClass(Constants.VarcharAttributeName)
                    .WithBaseClass(nameof(Attribute))
                    .WithModifiers($"{Constants.Public} {Constants.Sealed}")