Version 6 migration Q&A #5023

I'm currently upgrading to 6x and I ran into an issue with the expression it => $"{it.Name ?? ""} {it.Street ?? ""} {it.City ?? ""} {it.Country ?? ""}", giving me the error:

LinqToDB.LinqToDBException : The LINQ expression could not be converted to SQL.
Expression:
string.Format(
    format: "{0} {1} {2} {3}",
    args: new object[]
    {
        i.Name,
        i.Street,
        i.City,
        i.Country
    })

This worked in 5.4.
Not a blocker though, as luckily it is easy for me to re-write into something that works:

it =>
    (it.Name ?? "") + " "
    + (it.Street ?? "") + " "
    + (it.City ?? "") + " "
    + (it.Country ?? "")

5 replies

sdanyliv Jul 22, 2025
Maintainer

Create an issue with small reproducible example. It works for me.

BenjaBobs Jul 22, 2025

Interesting, will do!

BenjaBobs Jul 22, 2025

So it turns out I was wrong about that the issue was, it was not the interpolation after all, but the fact that I used it inside an .All() predicate.
dotnet fiddle minimal repro

Code

using System;
using System.Linq;
using System.Threading.Tasks;
using LinqToDB;
using LinqToDB.Async;
using LinqToDB.Data;
using LinqToDB.Mapping;
using Microsoft.Data.Sqlite;

[Table(Name = "People")]
public sealed class Person
{
    [Column, PrimaryKey, Identity]
    public int Id { get; set; }

    [Column]
    public string? Name { get; set; }

    [Column]
    public string? Street { get; set; }

    [Column]
    public string? City { get; set; }

    [Column]
    public string? Country { get; set; }
}

public class Program
{
    public static async Task Main()
    {
        using var sqlite = new SqliteConnection("Data Source=:memory:");
        sqlite.Open();

        // Create a linq2db connection
        using var db = new DataConnection(
            new DataOptions()
                .UseDataProvider(LinqToDB.DataProvider.SQLite.SQLiteTools.GetDataProvider())
                .UseConnection(sqlite)
        );

        // Prepare table & data
        await db.CreateTableAsync<Person>();
        await db.InsertAsync(
            new Person
            {
                Name = "Alice",
                Street = "1 Main",
                City = "Copenhagen",
                Country = "DK",
            }
        );
        await db.InsertAsync(
            new Person
            {
                Name = null,
                Street = null,
                City = "Aarhus",
                Country = "DK",
            }
        );

        var searchWords = new string[] { "alice", "main" };

		// Works in 6.0
		var query1 = db.GetTable<Person>()
            .Where(it =>
                    $"{it.Name ?? ""} {it.Street ?? ""} {it.City ?? ""} {it.Country ?? ""}"
                        .ToLower()
                        .Contains(searchWords[0]) && $"{it.Name ?? ""} {it.Street ?? ""} {it.City ?? ""} {it.Country ?? ""}"
                        .ToLower()
                        .Contains(searchWords[1])
            )
			.ToArrayAsync();
		
	    var query2 = db.GetTable<Person>()
            .Where(it =>
                searchWords.All(word =>
                    ((it.Name ?? "") + " " +
					(it.Street ?? "") + " " +
					(it.City ?? "") + " " +
					(it.Country ?? ""))
                        .ToLower()
                        .Contains(word)
                )
            )
			.ToArrayAsync();
		
        // Query that worked in 5.4
        var query3 = db.GetTable<Person>()
            .Where(it =>
                searchWords.All(word =>
                    $"{it.Name ?? ""} {it.Street ?? ""} {it.City ?? ""} {it.Country ?? ""}"
                        .ToLower()
                        .Contains(word)
                )
            );

        // throws when evaluated
        var result = await query3.ToArrayAsync();
    }
}

I'll create an issue.

EDIT:
Issue: #5035

sdanyliv Jul 22, 2025
Maintainer

@BenjaBobs, I found the root cause of the issue. When using up to three interpolation parameters, the translation works correctly. However, with four or more, the C# compiler selects a different string.Format overload, which leads to the problem.

A fix has been prepared: #5034

BenjaBobs Jul 22, 2025

Oh wow that's quite interesting, I had no idea. Must be an optimization thing. Thanks for looking at it so quickly. 😅

BenjaBobs · 2025-07-23T07:20:37Z

BenjaBobs
Jul 23, 2025

During migration I discovered this:

When I have a DateTime variable and use one of the fluent methods for "modifying" it, the parameter is not reduced to the final value, instead SQL to perform the modification on the Db is generated:

var dt = DateTime.UtcNow;
var query = db.GetTable<Person>().Where(p => p.CreatedAt < dt.AddDays(1));

dotnet fiddle example

Is this on purpose?

1 reply

sdanyliv Jul 23, 2025
Maintainer

Yes. Whe ensure that both binary expression sides has the same DateTime format before comparison. With current codebase it is best that we can do.

BenjaBobs · 2025-07-23T07:41:21Z

BenjaBobs
Jul 23, 2025

It seems that expression extension methods using [SqlQueryDependent] do not handle conditional invocation based on nullable values great, when the nullable value is null:
dotnet fiddle example

// I know I'm not supposed to use [SqlQueryDependent] here as the id parameter doesn't actually affect the generated sql
// this is just to showcase the thing
[Sql.Expression("Id = {1}")]
public static bool HasId(this Person person, [SqlQueryDependent] int id)
{
    return person.Id == id;
}

// Query
var maybeId = (int?)5;
var queryThatWorks = db.GetTable<Person>().Where(p => maybeId.HasValue ? p.HasId(maybeId.Value) : true);
Console.WriteLine(queryThatWorks.ToSqlQuery().Sql);

// Change maybeId to null to hit the other branch
maybeId = null;
var queryThatProducesError = db.GetTable<Person>().Where(p => maybeId.HasValue ? p.HasId(maybeId.Value) : true);
Console.WriteLine(queryThatProducesError.ToSqlQuery().Sql);

2 replies

sdanyliv Jul 23, 2025
Maintainer

It is real example, or you just created this for demonstartion? I do not see reason in HasId function or the way how it is implemented.

BenjaBobs Jul 23, 2025

The real example for me was this:

Big block of code

    [Expression(
        ProviderName.SqlServer,
        """
            CASE {1}
                WHEN 0 THEN CONVERT(datetime2(7), FORMAT({0}, 'yyyy-MM-dd HH:mm:ss.ffffff')) 
                WHEN 1 THEN CONVERT(datetime2(7), FORMAT({0}, 'yyyy-MM-dd HH:mm:ss.fff')) 
                WHEN 2 THEN CONVERT(datetime2(7), FORMAT({0}, 'yyyy-MM-dd HH:mm:ss')) 
                WHEN 3 THEN CONVERT(datetime2(7), FORMAT({0}, 'yyyy-MM-dd HH:mm:00')) 
                WHEN 4 THEN CONVERT(datetime2(7), FORMAT({0}, 'yyyy-MM-dd HH:00:00')) 
                WHEN 5 THEN CONVERT(datetime2(7), FORMAT({0}, 'yyyy-MM-dd 00:00:00')) 
                WHEN 6 THEN CONVERT(datetime2(7), FORMAT({0}, 'yyyy-MM-01 00:00:00')) 
                WHEN 7 THEN CONVERT(datetime2(7), FORMAT({0}, 'yyyy-01-01 00:00:00')) 
            END
            """,
        ServerSideOnly = true
    )]
    [Expression(
        ProviderName.SQLite,
        // For unit 0 (microseconds): build the string by taking the part up to seconds and then
        // extracting only the fractional digits (skipping the seconds and decimal) from %f.
        """
                CASE {1}
                    WHEN 0 THEN strftime('%Y-%m-%d %H:%M:%S.', {0}) || substr(strftime('%f', {0}), 4, 6) || '0'
                    WHEN 1 THEN strftime('%Y-%m-%d %H:%M:%S.', {0}) || substr(strftime('%f', {0}), 4, 3) || '0000'
                    WHEN 2 THEN strftime('%Y-%m-%d %H:%M:%S', {0}) || '.0000000'
                    WHEN 3 THEN strftime('%Y-%m-%d %H:%M', {0}) || ':00.0000000'
                    WHEN 4 THEN strftime('%Y-%m-%d %H', {0}) || ':00:00.0000000'
                    WHEN 5 THEN strftime('%Y-%m-%d', {0}) || ' 00:00:00.0000000'
                    WHEN 6 THEN substr(strftime('%Y-%m-%d', {0}),1,7) || '-01 00:00:00.0000000'
                    WHEN 7 THEN substr(strftime('%Y-%m-%d', {0}),1,4) || '-01-01 00:00:00.0000000'
                END
            """,
        ServerSideOnly = true
    )]
    [Expression(
        ProviderName.PostgreSQL,
        """
                CASE {1}
                    WHEN 0 THEN date_trunc('microseconds', {0}) 
                    WHEN 1 THEN date_trunc('milliseconds', {0}) 
                    WHEN 2 THEN date_trunc('second', {0}) 
                    WHEN 3 THEN date_trunc('minute', {0}) 
                    WHEN 4 THEN date_trunc('hour', {0}) 
                    WHEN 5 THEN date_trunc('day', {0}) 
                    WHEN 6 THEN date_trunc('month', {0}) 
                    WHEN 7 THEN date_trunc('year', {0}) 
                END
            """,
        ServerSideOnly = true
    )]
    public static DateTime TruncateToSql(
        this DateTime self,
        [SqlQueryDependent] TemporalUnit unit
    ) => self.TruncateTo(unit);

With the usage:

.Where(stock =>
    request.MaxPrecision == null
        ? stock.UpdatedAt > request.Cutoff
        : stock.UpdatedAt.TruncateToSql(request.MaxPrecision.Value)
            > request.Cutoff.TruncateToSql(request.MaxPrecision.Value)
)

After further investigation I found that really the [SqlQueryDependent] doesn't belong on that extension method.
Linq2db 5.4 handled this, so I thought I'd still report it just in case. 🙂

BenjaBobs · 2025-07-23T12:12:48Z

BenjaBobs
Jul 23, 2025

It seems arbitrarily nested LoadWith's no longer work in all previous cases.
Possibly continuation of #4797 ?

It seems that when using both Where and LoadWith, in 6.0 ordering matters, if the Where touches the same properties as the LoadWith.
Example:

// worked before, but no only seems to allow 1-level deep LoadWith
db.GetTable<Person>()
  .Where(p => p.Children.Any(c => c.IsHungry))
  .LoadWith(
    p => p.Children,
    child => child.LoadWith(c => c.Friends) // <-- seems to no longer work
  )
  .ToArrayAsync();

But if I switch the order it seems to work:

db.GetTable<Person>()
  .LoadWith(
    p => p.Children,
    child => child.LoadWith(c => c.Friends)
  )
  .Where(p => p.Children.Any(c => c.IsHungry))
  .ToArrayAsync();

Are there any side effects to just moving the Where below the LoadWith or is that a decent solution?

dotnet fiddle

Minimal repro

using System;
using System.Linq;
using System.Threading.Tasks;
using LinqToDB;
using LinqToDB.Async;
using LinqToDB.Data;
using LinqToDB.Mapping;
using Microsoft.Data.Sqlite;

[Table(Name = "People")]
public sealed class Person
{
    [Column, PrimaryKey, Identity]
    public int Id { get; set; }

    [Column]
    public string? Name { get; set; }
	
	[Column]
	public int? ParentId { get; set; }

    [Association(ThisKey = nameof(Id), OtherKey = nameof(ParentId))]
    public Person[] Children { get; set; }
}

public class Program
{
    public static async Task Main()
    {
        using var sqlite = new SqliteConnection("Data Source=:memory:");
        await sqlite.OpenAsync();

        // Create a linq2db connection
        using var db = new DataConnection(
            new DataOptions()
                .UseDataProvider(LinqToDB.DataProvider.SQLite.SQLiteTools.GetDataProvider())
                .UseConnection(sqlite)
        );
		
		// Data
		await db.CreateTableAsync<Person>();
		var grandParentId = await db.InsertWithInt32IdentityAsync(new Person { Name = "Grandparent" });
		var parentId = await db.InsertWithInt32IdentityAsync(new Person { Name = "Parent", ParentId = grandParentId });
		await db.InsertAsync(new Person { Name = "Child", ParentId = parentId });

		// Query
		var works = await db.GetTable<Person>()
			.LoadWith(p => p.Children, children => children.LoadWith(child => child.Children))
			.FirstAsync();
		Print(works);
		
		// The order of the LoadWith and Where calls matter
		var alsoWorks = await db.GetTable<Person>()
			.LoadWith(p => p.Children, children => children.LoadWith(child => child.Children))
			.Where(p => p.Children!.Any(c => c.Name == "Parent"))
			.FirstAsync();
		Print(alsoWorks);
		
		var onlySomewhatWorks = await db.GetTable<Person>()
			.Where(p => p.Children!.Any(c => c.ParentId != null)) // <-- maybe messes with the LoadWith expression tree?
			.LoadWith(p => p.Children, children => children.LoadWith(child => child.Children))
			.FirstAsync();
		Print(onlySomewhatWorks);
    }
	
	static void Print(Person p)
	{
		Console.WriteLine(System.Text.Json.JsonSerializer.Serialize(p));
	}
}

Which prints

{"Id":1,"Name":"Grandparent","ParentId":null,"Children":[{"Id":2,"Name":"Parent","ParentId":1,"Children":[{"Id":3,"Name":"Child","ParentId":2,"Children":null}]}]}
{"Id":1,"Name":"Grandparent","ParentId":null,"Children":[{"Id":2,"Name":"Parent","ParentId":1,"Children":[{"Id":3,"Name":"Child","ParentId":2,"Children":null}]}]}
{"Id":1,"Name":"Grandparent","ParentId":null,"Children":[{"Id":2,"Name":"Parent","ParentId":1,"Children":null}]}

2 replies

sdanyliv Jul 23, 2025
Maintainer

Please convert this to an issue.

BenjaBobs Jul 23, 2025

Done: #5036

qpd-repos · 2025-07-31T12:35:51Z

qpd-repos
Jul 31, 2025

I upgraded from version 5.4.1 to 6 and I'm facing a problem where saving doesn't work if I create a nested object

This worked in 5.4.1 and doesn't work in 6
I get an error The LINQ expression could not be converted to SQL.Expression

await db.Process
        .InsertAsync(() => new ProcessDb
        {
            Id = approvalProcess.Id,
            DocumentId = approvalProcess.DocumentId,
            ContextId = approvalProcess.ContextId,
            State = new StateDb
            {
                CompletedTasks = approvalProcess.CompletedTasks,
                CurrentTask = approvalProcess.CurrentTask,
                Step = approvalProcess.Step,
                Status = approvalProcess.Status,
                StartAt = approvalProcess.StartAt
            },
            ConcurrencyVersion = 1
        }, cancellationToken)
        .ConfigureAwait(false);

Now, instead, I need to do this

   var state = new StateDb
  {
      CompletedTasks = approvalProcess.CompletedTasks,
      CurrentTask = approvalProcess.CurrentTask,
      Step = approvalProcess.Step,
      Status = approvalProcess.Status,
      StartAt = approvalProcess.StartAt
  };
  
  await db.Process
          .InsertAsync(() => new ProcessDb
          {
              Id = approvalProcess.Id,
              DocumentId = approvalProcess.DocumentId,
              ContextId = approvalProcess.ContextId,
              State = state,
              ConcurrencyVersion = 1
          }, cancellationToken)
          .ConfigureAwait(false);

Please tell me is this the intended behavior or is it really a bug?

1 reply

MaceWindu Jul 31, 2025
Maintainer Author

Looks like issue, tracked here #5056

qpd-repos · 2025-08-06T13:30:29Z

qpd-repos
Aug 6, 2025

In version 6, I encountered a problem that was not present in 5.4.1.
I have a property with an enum value in the database and the same property in the model that my method accepts. When using these values in Where(), I get an error
System.InvalidCastException: “Writing values of ‘EnumValue’ is not supported for parameters having NpgsqlDbType ‘Varchar’.”

I made a small simplified example

async Task TestEnum(EnumValue? value)
{
    var query = db.Table.AsQueryable();

    if (value.HasValue)
        query = query.Where(t => t.EnumValue == value.Value);

    await query.CountAsync();
}

I also noticed that if I do this

async Task TestEnum(EnumValue value)
{
    var query = db.Table.AsQueryable();

    query = query.Where(t => t.EnumValue == value);

    await query.CountAsync();
}

Then I stop getting the error.
You can see the full code here: https://github.com/qpd-repos/demo/blob/master/demo/Program.cs

2 replies

sdanyliv Aug 6, 2025
Maintainer

Please create issue from this comment.

qpd-repos Aug 8, 2025

#5075

ww9 · 2025-08-19T22:19:15Z

ww9
Aug 19, 2025

Hi! I plan to start a new ASP.NET project this week that will use linq2db.
Can I already use linq2db with .NET 10 preview?
The project will enter production only next year and .NET 10 is planned to be released this year, in November.

1 reply

BenjaBobs Aug 19, 2025

I don't see any reason you wouldn't be able to. My team has been using it on the latest .net version for years and it's always been great.

ImoutoChan · 2025-12-09T17:33:25Z

ImoutoChan
Dec 9, 2025

https://github.com/linq2db/linq2db/wiki/Linq-To-DB-6#preview-2-obsoletions

Update[Async] overloads with table as first parameter were obsoleted in favor of overloads, which allow user to specify target table explicitly from update query

I'm trying to understand how I should update my code. Is there any example in tests?

Right now I have a query like that:

await _orderContext.Orders
            .InnerJoin(
                temp,
                (x, y) => x.Id == y.Id,
                (x, y) => new
                {
                    Target = x,
                    Source = y
                })
            .UpdateAsync(
                _orderContext.Orders,
                x => new Order
                {
                    ShortId = x.Source.ShortId
                },
                token: ct);

But UpdateAsync is marked as obsolete. How I supposed to rewrite it? Some examples in migration guide would be appreciated

0 replies

sdanyliv · 2025-12-09T18:13:13Z

sdanyliv
Dec 9, 2025
Maintainer

Use the following

await _orderContext.Orders
    .InnerJoin(
        temp,
        (x, y) => x.Id == y.Id,
        (x, y) => new
        {
            Target = x,
            Source = y
        })
    .Set(x => x.Target.ShortId, x => x.Source.ShortId)
    .UpdateAsync(ct);

0 replies

JaBistDuNarrisch · 2026-02-20T08:49:23Z

JaBistDuNarrisch
Feb 20, 2026

Before 6.x I used a DataOptions instance, opened a transaction and added it to the DataOptions

Then I reused the DataOptions instance multiple times like new DataConnection(options: dataOptionsSource);

It worked out before 6.x.

Now I receive an ORA-604 error.

 var dataOptions = new DataOptions().UseProvider(providerName:  myProviderName)
            .UseConnectionString(connectionString: myConnectionString);

using var contextSource = new DataConnection(options: dataOptionsSource);

// Then create a SERIALIZABLE level transaction
using var transactionSource = await contextSource.Connection
     .BeginTransactionAsync(isolationLevel: IsolationLevel.Serializable, cancellationToken: cancellationToken);

// Add to dataOptions:
dataOptions = dataOptions 
            .UseTransaction(dataProvider: contextSource.DataProvider, transaction: transactionSource);

Due to the Connection being annotated as obsolete I added

var dbConnection = await contextSource.OpenDbConnectionAsync(cancellationToken);

And used the dbConnection but still I have the ORA-604 exception.

How can I manage to share/reuse the transaction in 6.x like
new DataConnection(dataOptions)

3 replies

JaBistDuNarrisch Mar 17, 2026

@MaceWindu do you know how to do it in v6?

MaceWindu Mar 17, 2026
Maintainer Author

It still should work. Could you create issue with sample code? by ORA604 you mean this error https://docs.oracle.com/en/error-help/db/ora-00604 ? I don't see how it could be caused by this code currently

JaBistDuNarrisch Mar 25, 2026

Yes, probably something changed in the new version but I needed to switch to flashback queries in Oracle anyway.

    public static ITable<T> AsOfTimestampUTC<T>(this ITable<T> table, DateTime timestamp) where T : class
    {
        if (timestamp.Kind != DateTimeKind.Utc)
        {
            throw new ArgumentException("Only UTC allowed");
        }
        var timestampString = timestamp.ToString("yyy-MM-dd HH:mm:ss.ff", CultureInfo.InvariantCulture);
        var sqlString = $"AS OF TIMESTAMP FROM_TZ(TO_TIMESTAMP('{timestampString}', 'YYYY-MM-DD HH24:MI:SS.FF'), 'UTC')";
        var sql = "{0} " + sqlString + " {1}";
        return table.WithTableExpression(sql);
    }

Ramazan-creator · 2026-04-06T08:11:38Z

Ramazan-creator
Apr 6, 2026

Hello!
After upgrading to version 6.2.1, the error LinqToDB.LinqToDBException: The LINQ expression '(int?)(int)x.Id.RawValue' could not be converted to SQL appeared. There were no issues in version 5.4.1.
x.Id is a structure, and RawValue receives a value. In this case, it's a short, and lssgst.StatsTypeId is a short?
What could be the problem and what are the possible solutions?

return await (
    from lssgst in db.LineServiceStatsGroupStatsTypes
    from st in db.StatsTypes.LeftJoin(x => x.Id.RawValue == lssgst.StatsTypeId)
    select new StatTypeWithStatsGroupId(
        lssgst.StatsTypeId,
        st.FullName,
        lssgst.LineServiceStatsGroupId,
        lssgst.SportId))
    .ToListAsync(ct);

4 replies

sdanyliv Apr 6, 2026
Maintainer

It is something that needs real issue with reproducible example. Classes and types and maybe custom mapping if it exists.

Ramazan-creator Apr 6, 2026

[Table(Database = "Mapping", Schema = "dbo", Name = "LineService$StatsGroupStatsType")]
internal sealed class LineServiceStatsGroupStatsType
{
    [Column("Id", DataType = DataType.Int32), PrimaryKey, Identity]
    public int Id { get; set; }

    [Column("LineServiceStatsGroupId", CanBeNull = false, DataType = DataType.Int32)]
    public int LineServiceStatsGroupId { get; set; }

    [Column("ZenitSportId", CanBeNull = false, DataType = DataType.Int16)]
    public short SportId { get; set; }

    [Column("ZenitStatsTypeId", CanBeNull = true, DataType = DataType.Int16)]
    public short? StatsTypeId { get; set; }
}


[Table(Database = "Main", Schema = "dbo", Name = "StatsType")]
public sealed class StatsType
{
    [Column("Id", DataType = DataType.Int16), PrimaryKey]
    public StatsTypeId Id { get; set; }

    [Column("FullName", CanBeNull = false, DataType = DataType.VarChar, Length = 64)]
    public string FullName { get; set; } = default!;
}


/// <summary>
/// MAIN.dbo.StatsType.Id
/// </summary>
[PublicAPI]
[Newtonsoft.Json.JsonConverter(typeof(NjConverter))]
[System.ComponentModel.TypeConverter(typeof(ScmTypeConverter))]
[System.Text.Json.Serialization.JsonConverter(typeof(StjConverter))]
public readonly partial struct StatsTypeId : IEquatable<StatsTypeId>, IComparable<StatsTypeId>, ISpanFormattable, IUtf8SpanFormattable, ISpanParsable<StatsTypeId>, IUtf8SpanParsable<StatsTypeId>, IPrimitiveWrapper<StatsTypeId, short>, IEqualityOperators<StatsTypeId, StatsTypeId, bool>
{
    
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public StatsTypeId(short value) =>
        RawValue = value;

    [MethodImpl(MethodImplOptions.AggressiveInlining)][Pure]
    public static StatsTypeId Create(short value) =>
        new(value);

    [MethodImpl(MethodImplOptions.AggressiveInlining)][Pure]
    public static StatsTypeId? From(short? value) =>
        value == null ? null : new(value.GetValueOrDefault());

    public short RawValue
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        get;
    }

    #region Equality
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public bool Equals(StatsTypeId other) =>
        RawValue == other.RawValue;

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public override bool Equals(object? obj) =>
        obj is StatsTypeId other && Equals(other);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public override int GetHashCode() =>
        RawValue;

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static bool operator ==(StatsTypeId left, StatsTypeId right) =>
        left.Equals(right);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static bool operator !=(StatsTypeId left, StatsTypeId right) =>
        !left.Equals(right);
    #endregion

    #region Compare
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public int CompareTo(StatsTypeId other) =>
        RawValue.CompareTo(other.RawValue);                

    #endregion

    #region ToString & Format
    [MethodImpl(MethodImplOptions.AggressiveInlining)][Pure]
    public override string ToString() =>
        RawValue.ToString(FormatProviders.NumberFormatProvider);

    [MethodImpl(MethodImplOptions.AggressiveInlining)][Pure]
    public string ToString([StringSyntax(StringSyntaxAttribute.NumericFormat)] string? format, IFormatProvider? formatProvider) =>
        RawValue.ToString(format, formatProvider ?? FormatProviders.NumberFormatProvider);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public bool TryFormat(Span<char> destination, out int charsWritten, [StringSyntax(StringSyntaxAttribute.NumericFormat)] ReadOnlySpan<char> format, IFormatProvider? provider) =>
        RawValue.TryFormat(destination, out charsWritten, format, provider ?? FormatProviders.NumberFormatProvider);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public bool TryFormat(Span<byte> utf8Destination, out int bytesWritten, [StringSyntax(StringSyntaxAttribute.NumericFormat)] ReadOnlySpan<char> format, IFormatProvider? provider) =>
        RawValue.TryFormat(utf8Destination, out bytesWritten, format, provider ?? FormatProviders.NumberFormatProvider);
    #endregion

    #region Parse
    [MethodImpl(MethodImplOptions.AggressiveInlining)][Pure]
    public static StatsTypeId Parse(string s) =>
        new(short.Parse(s, FormatProviders.NumberFormatProvider));

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static bool TryParse([NotNullWhen(true)] string? s, out StatsTypeId result)
    {
        if (short.TryParse(s, FormatProviders.NumberFormatProvider, out var value))
        {
            result = new(value);
            return true;
        }

        result = default;
        return false;
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)][Pure]
    public static StatsTypeId Parse(string s, IFormatProvider? provider) =>
        new(short.Parse(s, provider ?? FormatProviders.NumberFormatProvider));

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, out StatsTypeId result)
    {
        if (short.TryParse(s, provider ?? FormatProviders.NumberFormatProvider, out var value))
        {
            result = new(value);
            return true;
        }

        result = default;
        return false;
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)][Pure]
    public static StatsTypeId Parse(ReadOnlySpan<char> s, IFormatProvider? provider) =>
        new(short.Parse(s, provider ?? FormatProviders.NumberFormatProvider));

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, out StatsTypeId result)
    {
        if (short.TryParse(s, provider ?? FormatProviders.NumberFormatProvider, out var value))
        {
            result = new(value);
            return true;
        }

        result = default;
        return false;
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)][Pure]
    public static StatsTypeId Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider) =>
        new(short.Parse(utf8Text, provider ?? FormatProviders.NumberFormatProvider));

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, out StatsTypeId result)
    {
        if (short.TryParse(utf8Text, provider ?? FormatProviders.NumberFormatProvider, out var value))
        {
            result = new(value);
            return true;
        }

        result = default;
        return false;
    }
    #endregion

    #region Newtonsoft.Json
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public void WriteValue(Newtonsoft.Json.JsonWriter writer) =>
        writer.WriteValue(RawValue);

    private sealed class NjConverter : Newtonsoft.Json.JsonConverter
    {
        public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object? value, Newtonsoft.Json.JsonSerializer serializer)
        {
            if (value == null)
                writer.WriteNull();
            else
                writer.WriteValue(((StatsTypeId)value).RawValue);
        }

        public override object? ReadJson(Newtonsoft.Json.JsonReader reader, Type objectType, object? existingValue, Newtonsoft.Json.JsonSerializer serializer)
        {
            var readerValue = reader.Value;

            switch (readerValue)
            {
                case null:
                    return null;
                case long longValue and <= short.MaxValue and >= short.MinValue:
                    return new StatsTypeId((short)longValue);
                case string stringValue when TryParse(stringValue, out var value):
                    return value;
            }

            var message = $"Cannot convert value '{readerValue}' of type '{readerValue.GetType()}' to '{typeof(StatsTypeId)}'.";
            message += reader is Newtonsoft.Json.IJsonLineInfo lineInfo && lineInfo.HasLineInfo()
                ? $" Path '{reader.Path}', line {lineInfo.LineNumber}, position {lineInfo.LinePosition}."
                : $" Path '{reader.Path}'.";

            throw new Newtonsoft.Json.JsonSerializationException(message);
        }

        public override bool CanConvert(Type objectType) =>
            objectType == typeof(StatsTypeId) ||
            objectType == typeof(StatsTypeId?);
    }

    private sealed class ScmTypeConverter : System.ComponentModel.TypeConverter
    {
        public override bool CanConvertFrom(System.ComponentModel.ITypeDescriptorContext? context, Type sourceType) =>
            sourceType == typeof(string) ||
            base.CanConvertFrom(context, sourceType);

        public override object? ConvertFrom(System.ComponentModel.ITypeDescriptorContext? context, System.Globalization.CultureInfo? culture, object value) =>
            value is string s
                ? Parse(s)
                : base.ConvertFrom(context, culture, value);

        public override object? ConvertTo(System.ComponentModel.ITypeDescriptorContext? context, System.Globalization.CultureInfo? culture, object? value, Type destinationType)
        {
            if (destinationType == typeof(string) && value is StatsTypeId wrappedValue)
                return wrappedValue.ToString();

            return base.ConvertTo(context, culture, value, destinationType);
        }
    }
    #endregion

    #region System.Text.Json
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public void WriteValue(System.Text.Json.Utf8JsonWriter writer) =>
        writer.WriteNumberValue(RawValue);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public void Write(System.Text.Json.Utf8JsonWriter writer, string propertyName) =>
        writer.WriteNumber(propertyName, RawValue);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public void Write(System.Text.Json.Utf8JsonWriter writer, ReadOnlySpan<char> propertyName) =>
        writer.WriteNumber(propertyName, RawValue);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public void Write(System.Text.Json.Utf8JsonWriter writer, System.Text.Json.JsonEncodedText propertyName) =>
        writer.WriteNumber(propertyName, RawValue);

    private sealed class StjConverter : System.Text.Json.Serialization.JsonConverter<StatsTypeId>
    {
        public override StatsTypeId Read(ref System.Text.Json.Utf8JsonReader reader, Type typeToConvert, System.Text.Json.JsonSerializerOptions options) =>
            new(reader.GetInt16());

        public override void Write(System.Text.Json.Utf8JsonWriter writer, StatsTypeId value, System.Text.Json.JsonSerializerOptions options)
        {
            writer.WriteNumberValue(value.RawValue);
        }

        public override StatsTypeId ReadAsPropertyName(ref System.Text.Json.Utf8JsonReader reader, Type typeToConvert, System.Text.Json.JsonSerializerOptions options)
        {
            var bytes = reader.HasValueSequence ? reader.ValueSequence.ToArray() : reader.ValueSpan;
            if (!global::System.Buffers.Text.Utf8Parser.TryParse(bytes, out short value, out var consumed) || consumed != bytes.Length)
                throw new System.Text.Json.JsonException("Could not parse value from propertyName");

            return new(value);
        }

        public override void WriteAsPropertyName(System.Text.Json.Utf8JsonWriter writer, StatsTypeId value, System.Text.Json.JsonSerializerOptions options)
        {
            writer.WritePropertyName(value.ToString());
        }
    }
    #endregion

    #region Microsoft.Data.SqlClient
    public static System.Data.SqlDbType SqlDbType
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        get => global::System.Data.SqlDbType.SmallInt;
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public void SetParameterValue(Microsoft.Data.SqlClient.SqlParameter param) =>
        param.Value = RawValue;

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static StatsTypeId GetFrom(Microsoft.Data.SqlClient.SqlParameter param) =>
        new((short)param.Value);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static StatsTypeId? GetFromOrNull(Microsoft.Data.SqlClient.SqlParameter param)
    {
        var value = param.Value;
        return value == DBNull.Value
            ? null
            : new((short)value);
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static StatsTypeId GetFrom(Microsoft.Data.SqlClient.SqlDataReader reader, int ordinal) =>
        new(reader.GetInt16(ordinal));

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static StatsTypeId? GetFromOrNull(Microsoft.Data.SqlClient.SqlDataReader reader, int ordinal)
    {
        var value = reader.GetSqlInt16(ordinal);
        return value.IsNull
            ? null
            : new(value.Value);
    }
    #endregion
}


/// <summary>
/// <see cref="StatsTypeId"/> extensions.
/// </summary>
[PublicAPI]
public static class StatsTypeIdExtensions
{
    #region Microsoft.Data.SqlClient
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static PrimitiveWrapperSqlParameter<StatsTypeId> AddStatsTypeIdOutputParam(
        this Microsoft.Data.SqlClient.SqlCommand command, string paramName) =>
        command.AddOutputParam<StatsTypeId>(paramName);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static PrimitiveWrapperSqlParameter<StatsTypeId> AddStatsTypeIdInputOutputParam(
        this Microsoft.Data.SqlClient.SqlCommand command, string paramName, StatsTypeId value) =>
        command.AddInputOutputParam(paramName, value);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static PrimitiveWrapperSqlParameter<StatsTypeId> AddStatsTypeIdInputOutputParam(
        this Microsoft.Data.SqlClient.SqlCommand command, string paramName, StatsTypeId? value) =>
        command.AddInputOutputParam(paramName, value);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static PrimitiveWrapperSqlParameter<StatsTypeId> AddStatsTypeIdInputParam(
        this Microsoft.Data.SqlClient.SqlCommand command, string paramName, StatsTypeId value) =>
        command.AddInputParam(paramName, value);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static PrimitiveWrapperSqlParameter<StatsTypeId> AddStatsTypeIdInputParam(
        this Microsoft.Data.SqlClient.SqlCommand command, string paramName, StatsTypeId? value) =>
        command.AddInputParam(paramName, value);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static PrimitiveWrapperSqlParameter<StatsTypeId> AddStatsTypeIdInputParam(
        this Microsoft.Data.SqlClient.SqlCommand command, string paramName) =>
        command.AddInputParam<StatsTypeId>(paramName);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static StatsTypeId GetStatsTypeId(this Microsoft.Data.SqlClient.SqlDataReader reader, int ordinal) =>
        StatsTypeId.GetFrom(reader, ordinal);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static StatsTypeId GetStatsTypeId(this Microsoft.Data.SqlClient.SqlDataReader reader, string name) =>
        StatsTypeId.GetFrom(reader, reader.GetOrdinal(name));

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static StatsTypeId? GetStatsTypeIdOrNull(this Microsoft.Data.SqlClient.SqlDataReader reader, int ordinal) =>
        StatsTypeId.GetFromOrNull(reader, ordinal);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static StatsTypeId? GetStatsTypeIdOrNull(this Microsoft.Data.SqlClient.SqlDataReader reader, string name) =>
        StatsTypeId.GetFromOrNull(reader, reader.GetOrdinal(name));

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static StatsTypeId GetStatsTypeIdOrDefault(this Microsoft.Data.SqlClient.SqlDataReader reader, int ordinal) =>
        StatsTypeId.GetFromOrNull(reader, ordinal).GetValueOrDefault();

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static StatsTypeId GetStatsTypeIdOrDefault(this Microsoft.Data.SqlClient.SqlDataReader reader, string name) =>
        StatsTypeId.GetFromOrNull(reader, reader.GetOrdinal(name)).GetValueOrDefault();
    #endregion
}


public sealed record StatTypeWithStatsGroupId(short? StatTypeId, string StatTypeName, int? StatsGroupId, short SportId);


public async Task<Result<IReadOnlyList<StatTypeWithStatsGroupId>, string>> GetZenitStatsTypesWithStatsGroupIds(CancellationToken ct)
{
    try
    {
        using (_logger.WithCallerMethodName())
        await using (var db = new DbMapping(_connectionFactory.Create(null, threadName: $"{nameof(GetZenitStatsTypesWithStatsGroupIds)}")))
        {
            return await (
                from lssgst in db.LineServiceStatsGroupStatsTypes
                from st in db.StatsTypes.LeftJoin(x => x.Id.RawValue == lssgst.ZenitStatsTypeId)
                select new StatTypeWithStatsGroupId(
                    lssgst.ZenitStatsTypeId,
                    st.FullName,
                    lssgst.LineServiceStatsGroupId,
                    lssgst.SportId))
                .ToListAsync(ct);
        }
    }
    catch (Exception exception)
    {
        _logger.LogError(exception, "Exception occurred while retrieving GetStatsTypesWithStatsGroupIds directory");
        return exception.Message;
    }
}

There it is

sdanyliv Apr 6, 2026
Maintainer

Can you create issue? It is discussion thread.

Ramazan-creator Apr 7, 2026

#5453

Uh oh!

Version 6 migration Q&A #5023

Uh oh!

Uh oh!

MaceWindu Jul 17, 2025 Maintainer

Replies: 12 comments · 29 replies

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

sdanyliv Jul 17, 2025 Maintainer

Uh oh!

Uh oh!

Uh oh!

sdanyliv Jul 17, 2025 Maintainer

Uh oh!

Uh oh!

Uh oh!

sdanyliv Jul 22, 2025 Maintainer

Uh oh!

Uh oh!

Uh oh!

Uh oh!

sdanyliv Jul 22, 2025 Maintainer

Uh oh!

Uh oh!

Uh oh!

sdanyliv Jul 23, 2025 Maintainer

Uh oh!

Uh oh!

sdanyliv Jul 23, 2025 Maintainer

Uh oh!

Uh oh!

Uh oh!

sdanyliv Jul 23, 2025 Maintainer

Uh oh!

Uh oh!

Uh oh!

MaceWindu Jul 31, 2025 Maintainer Author

Uh oh!

Uh oh!

sdanyliv Aug 6, 2025 Maintainer

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

MaceWindu
Jul 17, 2025
Maintainer

Replies: 12 comments 29 replies

sdanyliv Jul 17, 2025
Maintainer

sdanyliv Jul 17, 2025
Maintainer

sdanyliv Jul 22, 2025
Maintainer

sdanyliv Jul 22, 2025
Maintainer

sdanyliv Jul 23, 2025
Maintainer

sdanyliv Jul 23, 2025
Maintainer

sdanyliv Jul 23, 2025
Maintainer

MaceWindu Jul 31, 2025
Maintainer Author

sdanyliv Aug 6, 2025
Maintainer