我正在尝试在SQL Server中编写一些正则表达式，以匹配除字母之外的字符串之前或之后的任何内容。
'%ABC%'不起作用，因为它包含字母。
'%[^a-z]ABC[^a-z]%'不起作用，因为它与结果以ABC开头或结尾的任何查询都不匹配。因为[^a-z]表示任何不是字母字符的字符，但仍然是字符。
解决这个问题的正则表达式是：
[^a-z]ABC[^a-z]|ABC[^a-z]|[^a-z]ABC
但你不能在SQL中写这个：
'%[^a-z]ABC[^a-z]|ABC[^a-z]|[^a-z]ABC%'
或
'%[^a-z]ABC[^a-z]%|%ABC[^a-z]%|%[^a-z]ABC%'
我不想在我的SQL中使用OR，因为我有一个包含以下内容的存储过程：
WHERE var like @var
我会用
之类的东西来执行它@var = '%[^a-z]APU[^a-z]%'
我宁愿没有多个参数，也不要尝试将多个值传递给单个参数。
有没有办法调整'%[^a-z]ABC[^a-z]%'的正则表达式ABC可以开始或结束字符串？
答案 0 :(得分：1)
您可以这样做：
where ' ' + var + ' ' like '%[^a-z]ABC[^a-z]%'
这也将匹配字符串开头和结尾的模式。
我不确定这是否真的符合您的要求。
答案 1 :(得分：1)
您也可以使用此CLR代码在SQL Server中使用真正的正则表达式 请参阅代码，将SQL语句添加到SQL Server实例中的函数
pd.Series.diff使用Framework 3.5进行编译，以下命令可以提供帮助
df.assign(Diff=df.In.diff())
编译完成后，将DLL放入using System;
using Microsoft.SqlServer.Server;
using System.Text.RegularExpressions;
using System.Collections;
using System.Data.SqlTypes;
namespace XXX.DotNet.XXX
{
/// <summary>
/// Cette classe est utilisée pour mettre à disposition une librairie de fonctions d'Expressions Régulières destinées pour SQL Server 2005 (et plus) en CLR
/// </summary>
public class RegularExpressionFunctions
{
/**
<summary>
Cette méthode permet de récupérer toutes les sous-chaines d'une chaine correspondant à une expression régulière (sous forme de chaine concaténée)
</summary>
<param name="pattern">
Cette chaîne de caractères représente l'expression régulière à comparer
</param>
<param name="sentence">
Cette chaîne de caractères représente l'expression à évaluer
</param>
<param name="separator">
Cette chaîne de caractères sera insérée entre chaque sous-chaîne
</param>
<returns>
Soit null si aucune sous-chaine ne correspond, soit une chaine correspondant à la concaténation des différentes sous-chaînes séparées par une chaîne de séparation
</returns>
*/
[SqlFunction(IsDeterministic = true, IsPrecise = true, Name = "RegExMatches")]
public static String RegExMatches(String pattern, String sentence, String separator)
{
Regex rgx = new Regex(pattern);
MatchCollection matches = rgx.Matches(sentence);
int nbFound = matches.Count;
if(nbFound == 0){return null;}// Retourne null si aucune sous-chaîne ne correspond à l'expression régulière
String toReturn = "";
for(int i = 0; i < nbFound; i++)
{
Match match = matches[i];
if(i != 0)
{
toReturn += separator;
}
toReturn += match.Value;
}
return toReturn;// Retourne les sous-chaînes séparées par la chaîne de séparation
}
/**
<summary>
Cette méthode permet de récupérer toutes les sous-chaines d'une chaine correspondant à une expression régulière (sous forme de tableau)
</summary>
<param name="pattern">
Cette chaîne de caractères représente l'expression régulière à comparer
</param>
<param name="sentence">
Cette chaîne de caractères représente l'expression à évaluer
</param>
<returns>
Un tableau de taille égale au nombre de sous-chaîne trouvées, contenant dans chaque case une sous-chaîne correspondant à l'expression régulière
</returns>
*/
[SqlFunction(Name = "RegExMatchesSplit", FillRowMethodName = "NextSplitRow", DataAccess = DataAccessKind.Read)]
public static IEnumerable RegExMatchesSplit(String pattern, String sentence)
{
Regex rgx = new Regex(pattern);
MatchCollection matches = rgx.Matches(sentence);
int nbFound = matches.Count;
//String[][] toReturn = new String[nbFound][];
String[] toReturn = new String[nbFound];
for(int i = 0; i < nbFound; i++)
{
/*toReturn[i] = new String[2];
toReturn[i][0] = sentence;
toReturn[i][1] = matches[i].Value;*/
toReturn[i] = matches[i].Value;
}
return toReturn;// Retourne les sous-chaînes dans un tableau
}
public static void NextSplitRow(Object obj, /*out SqlString sentence, */out SqlString match)
{
/*String[] row = (String[])obj;
sentence = new SqlString(row[0]);
match = new SqlString(row[1]);*/
match = new SqlString(obj.ToString());
}
/**
<summary>
Cette méthode permet de récupérer le nombre de sous-chaînes d'une chaîne correspondant à une expression régulière
</summary>
<param name="pattern">
Cette chaîne de caractères représente l'expression régulière à comparer
</param>
<param name="sentence">
Cette chaîne de caractères représente l'expression à évaluer
</param>
<returns>
Le nombre d'occurences des sous-chaînes trouvée par l'expression régulière dans la chaîne d'entrée
</returns>
*/
[SqlFunction(IsDeterministic = true, IsPrecise = true, Name = "RegExNbMatches")]
public static int RegExNbMatches(String pattern, String sentence)
{
return new Regex(pattern).Matches(sentence).Count;// Retourne le nombre de sous-chaînes trouvées
}
/**
<summary>
Cette méthode permet de savoir si une chaîne de caractère correspond à un pattern d'expression régulière
</summary>
<param name="pattern">
Cette chaîne de caractères représente l'expression régulière à comparer
</param>
<param name="sentence">
Cette chaîne de caractères représente l'expression à évaluer
</param>
<returns>
True si l'expression correspond bien au pattern, false dans le cas contraire
</returns>
*/
[SqlFunction(IsDeterministic = true, IsPrecise = true, Name = "RegExIsMatch")]
public static bool RegExIsMatch(String pattern, String sentence)
{
return new Regex(pattern).IsMatch(sentence);
}
/**
TODO - Documentation
*/
[SqlFunction(IsDeterministic = true, IsPrecise = true, Name = "RegExMatch")]
public static String RegExMatch(String pattern, String sentence)
{
Match match = new Regex(pattern).Match(sentence);
if(!match.Success){return null;}
return match.Value;
}
}
}
（或其他地方并根据更改以下SQL查询）
然后使用以下代码添加函数并使用下一个查询
进行测试"C:\Windows\Microsoft.NET\Framework\v3.5\csc.exe" /t:library RegularExpressionFunctions.cs
使用以下查询来测试您的功能
C:\CLR\Regex\