Masterly.FluentRegex.EntityFrameworkCore 3.2.0

Masterly.FluentRegex.EntityFrameworkCore

Entity Framework Core integration for Masterly.FluentRegex: run fluent patterns inside LINQ queries, translated to the database's own regex dialect, with proven index-friendly prefilters and CHECK constraints generated from the same pattern.

using Masterly.FluentRegex;
using Masterly.FluentRegex.EntityFrameworkCore;

public static class Patterns
{
    public static readonly Pattern Sku = Pattern.With
        .StartOfLine.UppercaseLetter.Repeat.Times(3).Literal("-").AsciiDigit.Repeat.Times(4).EndOfLine;
}

services.AddDbContext<ShopContext>(options => options
    .UseNpgsql(connectionString)
    .UseFluentRegex());                                   // dialect detected from the provider

// WHERE p."Sku" IS NOT NULL AND p."Sku" ~ '\A[A-Z]{3}-[0-9]{4}(?=\n?\Z)' AND length(p."Sku") <= 9
// The regex keeps the exact .NET meaning ($ also accepts a final newline); the length bound is proven.
List<Product> skus = await db.Products.Where(p => Patterns.Sku.IsMatch(p.Sku!)).ToListAsync();

// Works on every database: SQL prefilter (a proven superset) + exact .NET match
List<Product> exact = await db.Products.ToMatchingListAsync(p => p.Sku, Patterns.Sku);

// CHECK ("Sku" ~ '...') on PostgreSQL, REGEXP_LIKE([Sku], N'...') on SQL Server 2025, ...
// Same semantics as Pattern.IsMatch and [MatchesPattern], so the database and the validator never disagree.
modelBuilder.Entity<Product>().Property(p => p.Sku).HasPattern(Patterns.Sku);

• MatchingAsync / ToMatchingListAsync run on every database: the SQL part is a proven superset of the pattern (the exact dialect regex, otherwise a superset LIKE plus a length bound, otherwise only a NULL check) and the .NET engine applies the exact pattern. Must rules of a ConstrainedPattern run in .NET.
• Index hints (on by default): proven facts such as a required prefix add AND col LIKE 'prefix%' and an upper length bound next to the regex, so a B-tree index can narrow the scan without changing results.
• NULL never matches, exactly as in .NET: Matches(NULL) is false, so !Matches(...) keeps NULL rows, with or without index hints.
• SQL Server's linguistic collations fold case, merge combining accents and skip ignorable characters in LIKE, so SQL Server LIKEs compare under COLLATE Latin1_General_100_BIN2, where they mean exactly what .NET means: ^[A-Z]{3}-[0-9]{4}\z becomes the exact LIKE '[A-Z][A-Z][A-Z]-[0-9][0-9][0-9][0-9]' on any column. Declare UseLikeCollation(LikeCollation.Binary) for _BIN2/_BIN columns to drop the COLLATE and keep index seeks.
• SqlRegex.Condition("\"Email\"", pattern, SqlDialect.PostgreSql) returns the predicate as raw SQL for Dapper.
• Targets .NET 8 (EF Core 8) and .NET 10 (EF Core 10). Full documentation: docs/features/entity-framework.md.