softstonedevelop / gedaq Goto Github PK

When calling methods, it is not clear what the parameters are if the parameters are unnamed, for example, positional parameters in PostgreSQL. There are also cases when we do not want the name of the parameter passed to the method to be different from the name of the parameter in the command.

Therefore, you need to add a new optional parameter to the attribute - "methodParametrName"

PostgreSQL: Array tests

#17

DbConnection - DbBatchCommand: Apply new parameter factory

If and when it will be available.
dotnet/runtime#82326

See: Gedaq.DbConnection.GeneratorsBatch.DbBatchCommand.cs and Gedaq.DbConnection.Helpers.DbGeneratorHelper.cs

Binary export tests generator

#17

Create native nuget for libpg_query

https://github.com/pganalyze/libpg_query

AsPartInterface

Add info about generated methods as part of the interface.
For example, this can be useful if we want to separate commands and queries:

public class Person
{
    public int Id { get; set; }

    public string Name { get; set; }
}

publlic partial interface IPersonRepository : ICommandPersonRepository, IQueryPersonRepository
{
}

publlic partial interface ICommandPersonRepository
{
}

publlic partial interface IQueryPersonRepository
{
}

public partial class PersonRepository : IPersonRepository
{
[Query(
            @"
SELECT 
    p.id,
    p.name
FROM person p
",
            "GetAllPerson",
            typeof(Person),
            MethodType.Async,
            QueryType.Read,
            asPartInterface: typeof(IQueryPersonRepository)
            )]
    private GetAllPersonConfig()
    {
    }

[Query(
            @"
INSERT INTO person(
    id
)
VALUES (
    $1
)
",
            "AddPerson",
            typeof(Person),
            MethodType.Async,
            QueryType.NonQuery,
            asPartInterface: typeof(ICommandPersonRepository)
            ),
    Parametr(typeof(int), position: 1, methodParametrName: "id")
    ]
    private GetAllPersonConfig()
    {
    }
}

void SomewhereInCode(
    ICommandPersonRepository commands, 
    IQueryPersonRepository queries
)
{
    //commands.AddPersonAsync(...
    //queries.GetAllPersonAsync(...
}

Bash queries tests

#17

Explicit cast parameters

It's mostly useful for enums. When in the code it is Enum and in the database it is short for example.

Now:

        [Query(@"
UPDATE public.table_with_enum
SET
    status = $1
WHERE
    id = $2
;
",
            "SetStatus",
            methodType: MethodType.Async,
            sourceType: Gedaq.Npgsql.Enums.SourceType.Connection,
            queryType: QueryType.NonQuery,
            accessModifier: AccessModifier.Public
            ),
            Parametr(typeof(short), position: 1, methodParametrName: "status"),
            Parametr(typeof(long), position: 2, methodParametrName: "id")
            ]
        private void ConfigSetStatus()
        {
        }

        public SomeMethod()
        {
            await SetStatus(connection: connection, status: (short)CurrentStatus.New, id: 1);
        }

Excpect:

        [Query(@"
UPDATE public.table_with_enum
SET
    status = $1
WHERE
    id = $2
;
",
            "SetStatus",
            methodType: MethodType.Async,
            sourceType: Gedaq.Npgsql.Enums.SourceType.Connection,
            queryType: QueryType.NonQuery,
            accessModifier: AccessModifier.Public
            ),
            Parametr(typeof(short), position: 1, methodParametrName: "status", methodParametrType: typeof(CurrentStatus)),
            Parametr(typeof(long), position: 2, methodParametrName: "id")
            ]
        private void ConfigSetStatus()
        {
        }

        public SomeMethod()
        {
            await SetStatus(connection: connection, status: CurrentStatus.New, id: 1);
        }

Add methodParameterType optional parameter.

Remove duplicate syntax

Instead of:

[Query(
            @"
SELECT 
    p.id,
    p.firstname,
~StartInner::Identification:id~
    i.id,
~StartInner::Country:id~
    c.id,
    c.name,
~EndInner::Country~
    i.typename,
~EndInner::Identification~
    p.middlename,
    p.lastname
FROM dbconnectionperson p
LEFT JOIN dbconnectionidentification i ON i.id = p.identification_id
LEFT JOIN dbconnectioncountry c ON c.id = i.country_id
WHERE p.id != {1} AND p.id != {0}
ORDER BY p.id ASC
",
            "NpgsqlToClass2",
            typeof(Person),
            Gedaq.Common.Enums.MethodType.Async | Gedaq.Common.Enums.MethodType.Sync
            )]
        [QueryFormat("NpgsqlToClass2", 1, "condition")]
        [QueryFormat("NpgsqlToClass2", 0)]
public void Method()
{
//...
}

write like this:

[Query(
            @"
SELECT 
    p.id,
    p.firstname,
~StartInner::Identification:id~
    i.id,
~StartInner::Country:id~
    c.id,
    c.name,
~EndInner::Country~
    i.typename,
~EndInner::Identification~
    p.middlename,
    p.lastname
FROM dbconnectionperson p
LEFT JOIN dbconnectionidentification i ON i.id = p.identification_id
LEFT JOIN dbconnectioncountry c ON c.id = i.country_id
WHERE p.id != {1} AND p.id != {0}
ORDER BY p.id ASC
",
            "NpgsqlToClass2",
            typeof(Person),
            Gedaq.Common.Enums.MethodType.Async | Gedaq.Common.Enums.MethodType.Sync
            ), 
QueryFormat(1, "condition"), 
QueryFormat(0)
]
public void Method()
{
//...
}

Everything in the same group belongs to the request. The same goes for batch requests.
Eliminates method name(NpgsqlToClass2) duplication.

Ensure better uniqueness of generated filenames

In now generator combine method name and provider name for output filename. This is not enough unique names because method name can be duplicate between classes.

Write a test generator

In order to be sure that all providers work, you need to check the generation on all supported types of providers: both for DbConnection and for specific attributes and specific providers.

And these are essentially the same tests with slight differences. When choosing between "trying to wrap it all in inheritance or composition" or "write a unit test generator" I choose the latter.

PostgreSQL: support T[] parametrs and columns mapping in query

Implement `IIncrementalGenerator` instead of `ISourceGenerator`

https://github.com/dotnet/roslyn/blob/main/docs/features/incremental-generators.md

Replace PostgreSQL parser to libpg_query .net parser

Use SourceProductionContext.CancellationToken

If generation was cancelled. This will improve generator performance.

Support RETURNING

https://www.postgresql.org/docs/current/dml-returning.html

On the Gedaq side, we need to recognize "returning" and issue an appropriate mapping.

Write MsSQL tests

#17

Support for basic functionality for MySqlConnector

Batch, Query, Parametrs

Support Fromat for Query

Not all queries can be parameterized. For example, in Postgresql the query "create database" does not support parameterization.

CREATE DATABASE MyDbName TEMPLATE template0 CONNECTION LIMIT = -1;

Need add new feature:

[Query(@"
CREATE DATABASE {0} TEMPLATE template0 CONNECTION LIMIT = -1;
",
            "CreateDatabase",
            methodType: Gedaq.Common.Enums.MethodType.Sync,
            sourceType: Gedaq.Npgsql.Enums.SourceType.Connection,
            queryType: Gedaq.Common.Enums.QueryType.NonQuery
            )]
        [QueryFormat(position: 0)]
private void Method(DbConnection connection)
{
    connection.CreateDatabase("MyDbName");
}

Support Oracle.ManagedDataAccess.Core

When there will be a request from users

Add the "transaction" parameter to commands and queries

Because only in postgresql this is not required (the transaction is opened in connection and not set in command), but in other databases it is necessary.

Improve the readability of generated code

Format tests generator

#17

Support for any order of nested entities for Npgsql.BinaryExport

Scalar with nullable types throw generator exception

Create wrapper in two versions .net standart 2.0 for generator and .net 7 for another cases

Replace "yield return" with a custom enumerator

After receiving the first element from the enumeration, we know exactly how many elements there will be. Therefore, we can use this for methods like ToList().

Also, "yield return" has some overhead.
Compare the refactoring result with the original in a performance test.

PostgreSQL: List tests

#17

Replace PostgreSQL parser to libpg_query wrapper

This is start for create nuget(https://digitalhouseblog.wordpress.com/2019/08/22/how-to-make-a-nuget-package-for-c/).
This change improve nuget experience. Same parser like in postgre server. This means we can get return aliases in all cases(return, subquery, func).

softstonedevelop / gedaq Goto Github PK

gedaq's People

Contributors

Watchers

gedaq's Issues

Recommend Projects

Recommend Topics

Recommend Org

Jobs