Comment faire pour simuler des expressions régulières dans LINQ-to-SQL

J'ai changé la requête à utiliser les éléments suivants à la place de la Regex.IsMatch:

where SqlMethods.Like(cust.Acct, ProductionMask)  

où ProductionMask = "[bBgG][0-9][0-9][0-9][0-9]"

l'équivalent de la RegEx est: ^[B,G]\d{4}$

Si quelqu'un voit que les 2 masques ne doivent pas produire les mêmes résultats, s'il vous plaît laissez-moi savoir...

OriginalL'auteur IAbstract

spécial merci à Romain Khramtsov et db_developer pour des informations de référence,
et grâce à Microsoft 😛

RegExpLike Extension Pour Sql Server

Liens de référence:

http://www.codeproject.com/Articles/42764/Regular-Expressions-in-MS-SQL-Server-2005-2008

http://msdn.microsoft.com/en-us/library/dd456847.aspx

Etape 1: Compiler SqlRegularExpressions.cs pour générer SqlRegularExpressions.dll

//SqlRegularExpressions.cs
//© Copyright 2009, Roman Khramtsov /Major League - SqlRegularExpressions
using System;
using System.Data.SqlTypes;         //SqlChars
using System.Collections;           //IEnumerable
using System.Text.RegularExpressions;   //Match, Regex
using Microsoft.SqlServer.Server;       //SqlFunctionAttribute
///<summary>
///Class that allows to support regular expressions in MS SQL Server 2005/2008
///</summary>
public partial class SqlRegularExpressions
{
///<summary>
///Checks string on match to regular expression
///</summary>
///<param name="text">string to check</param>
///<param name="pattern">regular expression</param>
///<returns>true - text consists match one at least, false - no matches</returns>
[SqlFunction]
public static bool Like(string text, string pattern, int options)
{
return (Regex.IsMatch(text, pattern, (RegexOptions)options));
}
///<summary>
///Gets matches from text using pattern
///</summary>
///<param name="text">text to parse</param>
///<param name="pattern">regular expression pattern</param>
///<returns>MatchCollection</returns>
[SqlFunction(FillRowMethodName = "FillMatch")]
public static IEnumerable GetMatches(string text, string pattern, int options)
{
return Regex.Matches(text, pattern, (RegexOptions)options);
}
///<summary>
///Parses match-object and returns its parameters 
///</summary>
///<param name="obj">Match-object</param>
///<param name="index">TThe zero-based starting position in the original string where the captured
///    substring was found</param>
///<param name="length">The length of the captured substring.</param>
///<param name="value">The actual substring that was captured by the match.</param>
public static void FillMatch(object obj, out int index, out int length, out SqlChars value)
{
Match match = (Match)obj;
index = match.Index;
length = match.Length;
value = new SqlChars(match.Value);
}
}

Étape 2: Exécuter DbInstall.sql SQL sur la base de données

DbInstall.sql

sp_configure 'clr enabled', 1
reconfigure
go
--needs full path to DLL
create assembly SqlRegularExpressions 
from '..\SqlRegularExpressions.dll' 
with PERMISSION_SET = SAFE
go
create function RegExpLike(@Text nvarchar(max), @Pattern nvarchar(255), @Options int = 0) 
returns bit 
as external name SqlRegularExpressions.SqlRegularExpressions.[Like]
go
create function RegExpMatches(@text nvarchar(max), @pattern nvarchar(255), @Options int = 0)
returns table ([Index] int, [Length] int, [Value] nvarchar(255))
as external name SqlRegularExpressions.SqlRegularExpressions.GetMatches
go

DbUninstall.sql

drop function RegExpLike
drop function RegExpMatches
drop assembly SqlRegularExpressions
go
sp_configure 'clr enabled', 0
reconfigure
go

Étape 3: Sur le modèle de diagramme de droite de la souris, sélectionnez “mettre à Jour le Modèle de Base de données...”, utilisez l'assistant de mise à jour pour ajouter des fonctions stockées pour modèle.

Étape 4: Créer des fonctions importées au sein de l'entité contexte de la classe.

public class TheCompanyContext : Entities
{
//Please check your entity store name
[EdmFunction("TheCompanyDbModel.Store", "RegExpLike")]
public bool RegExpLike(string text, string pattern, int options)
{
throw new NotSupportedException("Direct calls are not supported.");
}
}

Étape 5: Enfin, vous pouvez utiliser des expressions régulières sur LINQ to entities 🙂

User[] qry = (from u in context.Users
where u.ApplicationName == pApplicationName
&& context.RegExpLike(u.Username, usernameToMatch, (int)RegexOptions.IgnoreCase)
orderby u.Username
select u)
.Skip(startIndex)
.Take(pageSize)
.ToArray();

OriginalL'auteur Onur

J'ai eu le même problème, mais a réussi à se débarrasser de lui.
Je sais que c'est lent mais fonctionne, tout d'optimisation/correction de l'indice seront les bienvenus 🙂
Le code rassemble les données d'abord, puis des processus,
si vous avez besoin de filtrer autant que vous le pouvez avant d'appeler toarray() ou d'acheter plus de ram 🙂

espérons que cela aide,
profitez de

Regex rx = LikeToRegEx(emailToMatch);
User[] qry = (from u in context.Users
where u.ApplicationName == pApplicationName
orderby u.Username
select u)
.ToArray()
.Where(u => rx.IsMatch(u.Email))
.ToArray();
//-- LikeToRegEx : Converts SQL like match pattern to a regular expression -- 
public Regex LikeToRegEx(string likestr, RegexOptions opt = RegexOptions.None)
{
likestr = likestr
.Replace("*", ".")
.Replace("+", ".")
.Replace("(", ".")
.Replace("[", ".")
.Replace("/", ".")
.Replace("\\", ".")
.Replace("^", ".")
.Replace("$", ".")
.Replace("_", ".")
.Replace("%", ".*");
return new Regex(likestr, opt);
}

P. S. C'est un moyen rapide pour le traitement de la lumière tableaux de données, vous pouvez
améliorer seulement par l'extraction de colonnes nécessaires pour le traitement et la juste
de retour de l'ID de colonnes pour un accès complet aux lignes. Vous pouvez utiliser mon dernier post
pour un cadre plus général lourds scénarios. Le choix est le vôtre.

OriginalL'auteur Onur