Blocage de CLR sur SQL Server 2014 (Windows 2012R2)

J'ai ce petit CLR qui fait une fonction RegEX sur une chaîne de colonnes.

Lors de l'exécution sur SQL Server 2014 (12.0.2000) sur Windows Server 2012R2, le processus se bloque avec

Msg 0, niveau 11, état 0, ligne 0 Une erreur grave s'est produite sur la commande actuelle. Le cas échéant, les résultats doivent être ignorés.

et donne un vidage de la pile si je fais

select count (*) from table where (CLRREGEX,'Regex')

mais quand je fais

select * from table where (CLRREGEX,'Regex') 

il renvoie les lignes.

Fonctionne parfaitement sur la même version de SQL Server exécutée sur Windows 8.1.

Des idées?

- Modifier C'est aussi simple que possible

using System;
using System.Collections.Generic;
using System.Text;
using System.Data.SqlTypes;           //SqlString, SqlInt32, SqlBoolean
using System.Text.RegularExpressions; //Match, Regex
using Microsoft.SqlServer.Server;     //SqlFunctionAttribute
public partial class UserDefinedFunctions
{
    public static readonly RegexOptions Options = RegexOptions.IgnorePatternWhitespace | RegexOptions.Multiline;
    [SqlFunction]
    [Microsoft.SqlServer.Server.SqlFunction(IsDeterministic = true, IsPrecise = true)]
    public static SqlBoolean RegExMatch(SqlString input, SqlString pattern)
    {
        if (input.IsNull || pattern.IsNull) //nulls dont qualify for a match
            return SqlBoolean.False;
    return Regex.IsMatch(input.Value, pattern.Value, RegexOptions.IgnoreCase);
    }
}

Donc, par petits changements, cela fonctionne maintenant: la leçon principale en C # semble être la même que dans TSQL, méfiez-vous de la conversion implicite des données.

using System;
using System.Text;
using System.Data.SqlTypes;           //SqlString, SqlInt32, SqlBoolean
using System.Text.RegularExpressions; //Match, Regex
using Microsoft.SqlServer.Server;     //SqlFunctionAttribute
public partial class UserDefinedFunctions
{
public static readonly RegexOptions Options = RegexOptions.IgnorePatternWhitespace | RegexOptions.Singleline | RegexOptions.Compiled | RegexOptions.IgnoreCase | RegexOptions.CultureInvariant;

    [Microsoft.SqlServer.Server.SqlFunction(IsDeterministic = true, IsPrecise = true, DataAccess = DataAccessKind.Read)]
    public static SqlBoolean RegExMatch(SqlString input, SqlString pattern)
{
    if (input.IsNull || pattern.IsNull) //nulls dont qualify for a match
        return SqlBoolean.False;
    string sqldata = input.ToString();
    string regex = pattern.ToString();
    return Regex.IsMatch(sqldata, regex);
 }

Le problème est un conflit de paramètres régionaux entre le système d'exploitation Windows et SQL Server (en particulier la base de données où l'assembly est chargé). Vous pouvez exécuter la requête suivante pour voir à quoi ils sont tous deux définis:

SELECT os_language_version,
       DATABASEPROPERTYEX(N'{name of DB where Assembly exists}', 'LCID') AS 'DatabaseLCID'
FROM   sys.dm_os_windows_info;

S'ils sont différents, vous pouvez certainement obtenir un comportement "étrange", comme ce que vous voyez. Le problème est que:

• SqlStringinclut plus que le texte lui-même: il inclut le classement par défaut de la base de données dans laquelle l'assembly existe. Le classement est composé de deux informations: les informations locales (c.-à-d. LCID) et les options de comparaison (c.-à-d. SqlCompareOptions) qui détaillent la sensibilité à la casse, aux accents, au kana, à la largeur ou à tout (binaire et binaire2).
• Les opérations de chaîne dans .NET, sauf indication explicite de paramètres régionaux, utilisez les informations de paramètres régionaux du thread actuel, qui sont définies dans Windows (c'est-à-dire le système d'exploitation / OS).

Le conflit se produit généralement lors du référencement d'un paramètre SqlString sans utiliser .Valueou .ToString()tel qu'il effectue une conversion implicite vers SqlString. Dans ce cas, cela provoquerait une exception indiquant que les LCID ne correspondent pas.

Il existe apparemment d'autres scénarios, tels que des comparaisons de chaînes (certaines / toutes?), Y compris lors de l'utilisation de Regex comme le montre ce cas (bien que jusqu'à présent je n'ai pas été en mesure de reproduire cela).

Quelques idées de correctifs:

Idéal (les attentes seront toujours satisfaites quant au fonctionnement des comparaisons):

• Modifiez le LCID Windows ou SQL Server (langue par défaut) afin que les deux correspondent

Moins qu'idéal (le comportement des paramètres régionaux Windows peut ne pas être les mêmes règles d'égalité et de tri et il peut donc y avoir des résultats inattendus):

• Utilisez la .ToStringméthode ou la .Valuepropriété, qui renvoient toutes les deux la chaîne sans le LCID SQL Server afin que les opérations utilisent toutes le LCID du système d'exploitation.

Pourrait aider:

• Peut-être utiliser SqlCharsau lieu de SqlStringcar il n'apporte pas le LCID et les informations de classement de SQL Server
• Spécifiez que la culture n'a pas d'importance via StringComparison.InvariantCulture:
  • String.Compare(string, string, StringComparison.InvariantCulture) ou String.Compare(string, string, StringComparison.InvariantCultureIgnoreCase)
  • Pour Regex, spécifiez RegexOptions.CultureInvariant

Mis à jour..

La localisation est différente entre le moteur SQL et le serveur de fenêtres comme le souligne @srutzky:

os_language_version SqlServerLCID
1033 1039

La modification suivante du code - la définition de l'option RegexOptions.CultureInvariantcontourne l'erreur. Le code inchangé ne plantera pas SQL Server 2012 sur Windows Server 2012R2 avec les mêmes paramètres de langue mais le fait sur SQL Server 2014.

using System;
using System.Text;
using System.Data.SqlTypes;           //SqlString, SqlInt32, SqlBoolean
using System.Text.RegularExpressions; //Match, Regex
using Microsoft.SqlServer.Server;     //SqlFunctionAttribute
public partial class UserDefinedFunctions
{
public static readonly RegexOptions Options = RegexOptions.IgnorePatternWhitespace | RegexOptions.Singleline | RegexOptions.Compiled | RegexOptions.IgnoreCase | RegexOptions.CultureInvariant;

    [Microsoft.SqlServer.Server.SqlFunction(IsDeterministic = true, IsPrecise = true)]
    public static SqlBoolean RegExMatch(SqlString input, SqlString pattern)
{
    if (input.IsNull || pattern.IsNull) //nulls dont qualify for a match
        return SqlBoolean.False;
    string sqldata = input.ToString();
    string regex = pattern.ToString();
    return Regex.IsMatch(sqldata, regex);
 }