Как имитировать регулярные выражения в LINQ-to-SQL

Ответ 1

Я изменил запрос, используя вместо Regex.IsMatch следующее:

where SqlMethods.Like(cust.Acct, ProductionMask)  

где ProductionMask = "[bBgG][0-9][0-9][0-9][0-9]"

эквивалентный RegEx: ^[B,G]\d{4}$

Если кто-нибудь увидит, что 2 маски не должны давать одинаковые результаты, сообщите мне...

Ответ 2

Используете ли вы LINQ-to-SQL? Если да, форумы MSDN сообщают следующее:

LINQ to SQL не может переводить регулярные выражения для SQL, потому что нет поддержка Regex на конце SQL.

Однако он дает 3 варианта.

Ответ 3

Особая благодарность Роману Храмцову и db_developer за справочную информацию, и благодаря Microsoft: P

Расширение RegExpLike для сервера Sql

Ссылки:
http://www.codeproject.com/Articles/42764/Regular-Expressions-in-MS-SQL-Server-2005-2008
http://msdn.microsoft.com/en-us/library/dd456847.aspx

Шаг1: Скомпилируйте SqlRegularExpressions.cs для генерации 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);
    }

}

Шаг 2: Запустите DbInstall.sql SQL в базе данных

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

Шаг 3: В правой части диаграммы модели выберите "Обновить модель из базы данных...", используйте мастер обновления, чтобы добавить хранимые функции в модель.

Шаг 4: Создайте импортированные функции в классе контекста объекта.

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.");
        }
}

Шаг 5: Наконец, вы можете использовать регулярные выражения для 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();

Ответ 4

Не могли бы вы заменить Regex.IsMatch на

where cust.AcctNum.StartsWith(ProductionMask)

Или Содержит/Концы В зависимости от ваших потребностей

Ответ 5

У меня была такая же проблема, но мне удалось избавиться от нее. Я знаю, что это медленно, но работает, любая подсказка оптимизации/исправления будет приветствоваться:) Сначала код собирает данные, а затем обрабатывает, поэтому вам нужно отфильтровать столько, сколько вы можете, прежде чем звонить toarray() или купить больше бара:)

Надеюсь, поможет, наслаждаться

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. Это быстрый способ обработки световых таблиц данных, вы можете улучшите его, просто извлекая необходимые столбцы для обработки и просто возвращать идентификационные столбцы для полного доступа к строкам. Вы можете использовать мой последний пост для более общих сценариев тяжелого режима. Выбор за вами.