Where is the official repository for this project?

[jzabroski]

Hi... @jmaguilar found this while discussing with Fable 5 how to approach this - it did not recommend this library, but it occurred to me to search Google for https://www.google.com/search?q=efcore+query+tagging+github - and boom, i found your repository.

However, there is a mismatch between the nuget.org version history and the history in this repo. Where is the official repository now?

Context: I am soon going to migrate off of EF6 to EFCore, and it would be great to add this functionality.

[jmaguilar]

Hi, @jzabroski ! First of all, you're in the right place :)

Just to clarify, version 1.2.1 of the package published on NuGet is aligned with the master branch in this repository.

On the other hand, the code for package version 1.3.0-preview1 corresponds to the predicate-expression branch, which I published quite some time ago to cover a specific use case, although I didn't receive feedback and therefore didn't promote it to a final version.

Hope this help!

[jzabroski]

Should it now target net8.0 as EF6 changed its support policy

[jzabroski]

1. I would be interested in taking over this repository from you. I'm a very responsible maintainer - I run FluentMigrator, which now has over 60M downloads worldwide, and previously also ran RazorLight templating library which had over 20M downloads worldwide before it became impossible to continue maintaining due to Microsoft locking down the Razor engine inside the AspNetCore FrameworkReference boundary.
2. OK, so, I think the current way you're doing TagWith is incorrect, as @d-a-s suggests in Why not use Expression.NotEqual in TagWith? #11. But his solution is not ideal, either.

However, to me, the right way is to use AsyncLocal and inject the tag at the start, so that it does not burden the cost-based optimizer with extra paths to evaluate. - The only upside I see to your approach even in 1.2.1 is that since the tag is embedded in the query, the SQL Server Query Store will not optimize it away. The ideal place to put a tag is directly inside the SELECT statement, as the Query Store will not elide it. The second best place is at the top of the statement, to provide

SELECT/*TagWith:Friends*/
  [Extent1].[OrderId]
FROM [dbo].[Order] AS [Extent1]

Implemented as:

DbInterception.Add(new QueryTagCommandInterceptor());

Usage:

public List<DailySalesByCustomer> GetDailySalesByCustomer(
    List<int> customerIds, DateTime maxOrderDate)
{
    //QueryTag disposable scoe creates a scope for the enclosing caller.
    using (QueryTag.Scope(nameof(GetDailySalesByCustomer)))
    {
        var customerIdQuery = Context.Customers
            .WhereBulkContains(customerIds)
            .Select(c => c.Id);

        var query = Context.Orders
            .Where(o => o.OrderDate <= maxOrderDate)
            .Where(o => customerIdQuery.Contains(o.CustomerId))
            .GroupBy(o => new { o.OrderDate, o.CustomerId })
            .Select(g => new DailySalesByCustomer
            {
                OrderDate = g.Key.OrderDate,
                CustomerId = g.Key.CustomerId,
                TotalSalesInUSD = g.Sum(o => o.Total ?? 0),
            });

        return query.ToList();   // <- executed inside the scope, so it gets tagged
    }
}

Executed SQL becomes:

-- GetDailySalesByCustomer
SELECT [GroupBy1].[K1] AS [OrderDate], [GroupBy1].[K2] AS [CustomerId], ...

Nested scopes emit one comment line per tag, outermost first (mirrors chained TagWith calls in EF Core):

using (QueryTag.Scope("NightlySalesRollupJob"))     // job-level tag
using (QueryTag.Scope(nameof(GetDailySalesByCustomer)))
{
    ...
}
// -- NightlySalesRollupJob
// -- GetDailySalesByCustomer
// SELECT ...

Backwards compatibility bridge to EF6.TagWith, with partial forward compatibility to EFCore, can be achieved by a TagWith helper method that wraps the queryable so that a scope is opened for the duration of enumeration. The drawback/disclaimer is that TagWith is best-effort: as a best practice, the caller must apply it LAST (it does not survive further composition). E

var rows = ctx.Orders
    .Where(o => ids.Contains(o.CustomerId))
    .TagWith("GetOrdersForCustomers")   // apply LAST
    .ToList();

Explicit scope blocks would allow arbitrary chaining, similar to EFCore where the tag is itself a node in the tree and survives composition naturally:

public List<DailySalesByCustomer> GetDailySalesByCustomer(
    List<int> customerIds, DateTime maxOrderDate)
{
    //QueryTag disposable scoe creates a scope for the enclosing caller.
    using (QueryTag.Scope(nameof(GetDailySalesByCustomer) + "_CustomerIds));
    var customerIdQuery = Context.Customers
            .WhereBulkContains(customerIds)
            .Select(c => c.Id);
    using (QueryTag.Scope(nameof(GetDailySalesByCustomer) + "_FinalQuery);
    var query = Context.Orders
            .Where(o => o.OrderDate <= maxOrderDate)
            .Where(o => customerIdQuery.Contains(o.CustomerId))
            .GroupBy(o => new { o.OrderDate, o.CustomerId })
            .Select(g => new DailySalesByCustomer
            {
                OrderDate = g.Key.OrderDate,
                CustomerId = g.Key.CustomerId,
                TotalSalesInUSD = g.Sum(o => o.Total ?? 0),
            });

    return query.ToList();   // <- executed inside both scopes, so it gets tagged twice
}