If by support you mean handling of RegEx class usage in linq queries, then no.

I'll look if this is possible to implement...

It's just another extension. PR will be appreciated.
I do not think that we have to deal with RedEx class, it is closer to Sql.Like implementation.

for example

[Sql.Expression(ProviderName.MySql, "{0} REGEXP {1}")]
public static bool RegExp(string regex, string data)
{
    throw new NotImplementedException();
}

db.GetTable<Person>().Where(_ => RegExp("bla-bla-bla", _.Name)).ToList()

the only thing it would be sensitive to database RegEx dialect.

To make honest support it would be needed to create extension and convert c# RegEx to DB RegEx. If somebody knows how to convert one RegEx dialect to other it would be easy to implement support like:

public static class Sql
{
    public static class Regex
    {
        public static bool Match(Regex regex, string data) => regex.IsMatch(data);
    }
}

db.GetTable<Person>().Where(_ => Sql.Regex.Match(new Regex("bla-bla-bla"), _.Name)).ToList();

pull #1077

Is it also possible to support this:

			var q =
				from t in db.Category
				where Regex.IsMatch(t.CategoryName, "Condim.*")
				select t;

it means use the .NET Regex Class. Where can I look to implement this?

It is possible. But, how different regexp syntax in other databases? If dialects are too different - i prefer do not introduce Regex.IsMatch replacement.

Don't know how different they are. But I think most should be the same (if it is supported).

Where do I have to look to implement smth. like this?

We have to be sure that syntax is not different. We supports more than 10 databases and it will introduce undefined behavior for others. If you want to replace Regex.IsMatch function - you have to create all needed transformations for other databases. As i have mentioned before - it's not worth our time.

ef core also supports it: https://blogs.msdn.microsoft.com/mvpawardprogram/2016/11/22/entity-framework-core/

Link is about third party npgsql EF Provider - only Postgre SQL.
I suggest to open API for such kind of tricks
https://github.com/linq2db/linq2db/blob/master/Source/LinqToDB/Linq/Expressions.cs#L448
If you know what are you doing in your project - go on.

Of course regular expression syntax can have subtle differences in every engine, even in different versions of the same engine. Only some basic regular expressions, using the common subset of features may work. It's just like the SQL language itself. It's pretty much standardized, but only to a limited degree.

Here are my findings:

• Prior to 8.0.4, MySQL was using the Henry Spencer regular expression library to support regular expression operations.
• Starting with MySQL 8.0.4, ICU’s Regular Expressions package is used.
• PostgreSQL uses POSIX Regular Expressions with some extensions borrowed from Perl and Tcl, calls them "ARE".
• Oracle generally implements POSIX Regular Expressions but also includes selected parts of PCRE.
• SQL Server doesn't have any RE support by default. If you want it, you have to resort to using a CLR integration (for example this library), or one of the external languages available in latest versions: R, Java or Python. You then have 4 flavors of regular expressions possible - each of those differs a bit from the others. And to use it you first have to set it up:
  • In .NET you have to have a database into which you'll import the CLR functions with CREATE ASSEMBLY followed by several CREATE FUNCTIONs and during runtime qualify the functions with the DB name.
  • In R and Python you have to CREATE EXTERNAL LANGUAGE and then use sp_execute_external_script with a bunch of code, and for Java you have to compile it upfront and load into the server with CREATE EXTERNAL LIBRARY.
• In SQLite there's the REGEXP keyword, but it doesn't have the regular expression functionality until you load an extension containing the regexp() function. Then the flavor of supported regexps will be whatever the extension provide.
• That's enough. If you want more information, please check your favorite engine's documentation.

So, having a truly portable regular expressions in LINQ to DB is a hard task. I think implementing a simple generic wrappers is doable, but it's going to be a supportability nightmare. Users will have hard time understanding why are there error messages returned by SQL Server when their perfect LINQ to DB should just run.

My take on this:

(1) I don't see why someone would attempt to create an abstraction layer to unify all regexps flavors:

• It's a very big task that requires a lot of difficult effort and testing;
• It will incur extra parsing/compilation work at runtime;
• It won't work for dynamically built regexes based on data;
• Users will be confused as they need to learn a different regex flavor than the actual one from their db (speaking from experience, I have to use 3 different regexes flavors at my job and man it's mentally taxing);
• It opens a long-term, huge, can of worms. I can foresee the bug reports on specific RDBMS or even RDBMS point releases, the issues asking support for a provider-specific non-standard extension that is not in your lingua franca, etc.

(2) On the other hand, just like all other provider-specific SQL extensions linq2db exposes, I see value in using these functions even when they're not portable.
In fact I have mapped Oracle regexp_like myself because we need to use it in our queries.

I see linq2db more as "full access to RDMBS power" than a "minimal common layer between all RDBMS". In fact, even basic operations can't be bridged between providers, did you know that 'abc' + null does not yield the same result in SQL Server and Oracle? Try to blindly port your code from one to the other now 🤣. Cross-provider code is always a lot of work and care.

Bottom line: I think adding those as some kind of provider-specific bool Match(string, string) with no attempt to look at the regex itself is useful, simple and the way to go.

My intention was not to have portable regexes for every database, but a unified way to use the regexes, even if they work different on every database.

We have a UI with a tableview where a customer could build different complex filters

and here I also wanted to support regex. On every customer these could be different cause he used another databases (we support oracle, mysql, mssql, sqlite and postgres), but our code to execute the regex could be the same.

And also in unitests where we ran our queries agains objects, it would work if we support it with standard regex.match

But atm. I do not work on this (okay the issue is already 5 years old :-) )

fixed in #4392

don't close until the PR is merged.

/azp run test-all

Something new to add to the discussion of: "should we simply use Regex.IsMatch as the entry point (assuming we pass the pattern "as-is" with no attempt at adapting to RDBMS), or should we add our own Sql.RegexLike":

Now VS IDE is attempting to provide colorization and intellisense for known string DSLs, including regexes. I think it would be even more confusing to get pattern tooltips and completions that are incorrect in this instance.