Arresto anomalo del CLR su SQL Server 2014 (windows 2012R2)

Ho questo piccolo CLR che svolge una funzione RegEX su una stringa in colonne.

Durante l'esecuzione su SQL Server 2014 (12.0.2000) su Windows Server 2012R2 il processo si arresta in modo anomalo

Messaggio 0, livello 11, stato 0, riga 0 Si è verificato un errore grave nel comando corrente. I risultati, se presenti, devono essere eliminati.

e dà una discarica dello stack se lo faccio

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

ma quando lo faccio

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

restituisce le righe.

Funziona perfettamente sulla stessa build di SQL Server in esecuzione su Windows 8.1.

Qualche idea?

- Modifica È il più semplice possibile

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

Quindi, con piccole modifiche, questo funziona ora: la lezione principale in C # sembra essere la stessa di TSQL, attenzione alla conversione implicita dei dati.

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

Il problema è un conflitto locale tra il sistema operativo Windows e SQL Server (in particolare il database in cui è caricato l'Assemblea). È possibile eseguire la query seguente per vedere su cosa sono entrambi impostati:

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

Se sono diversi, puoi sicuramente ottenere un comportamento "strano", come quello che stai vedendo. Il problema è che:

• SqlStringinclude più del semplice testo: include le regole di confronto predefinite del database in cui esiste l'assembly. Le regole di confronto sono composte da due informazioni: le informazioni sulla locale (es. LCID) e le opzioni di confronto (es. SqlCompareOptions) che dettagliano la sensibilità a maiuscole, accenti, kana, larghezza o qualsiasi altra cosa (binaria e binaria2).
• Le operazioni con stringhe in .NET, a meno che non venga specificata esplicitamente una locale, utilizzano le informazioni sulla locale del thread corrente, che è impostato in Windows (ovvero il sistema operativo / sistema operativo).

Il conflitto si verifica in genere quando si fa riferimento a un parametro SqlString senza utilizzare .Valueo in .ToString()modo da eseguire una conversione implicita SqlString. In tal caso, si verificherebbe un'eccezione che afferma che i LCID non corrispondono.

Apparentemente ci sono altri scenari, come l'esecuzione di confronti di stringhe (alcuni / tutti?), Anche quando si utilizza Regex come mostra questo caso (anche se finora non sono stato in grado di riprodurlo).

Alcune idee per le correzioni:

Ideale (le aspettative saranno sempre soddisfatte su come funzionano i confronti):

• Modificare il LCID di Windows o SQL Server (lingua predefinita) in modo che entrambi corrispondano

Meno che ideale (il comportamento delle impostazioni internazionali di Windows potrebbe non essere le stesse regole per l'uguaglianza e l'ordinamento e quindi potrebbero esserci risultati imprevisti):

• Utilizzare il .ToStringmetodo o la .Valueproprietà, che restituiscono entrambi la stringa senza il LCID di SQL Server in modo che tutte le operazioni utilizzino il LCID del sistema operativo.

Potrebbe aiutare:

• Forse usare SqlCharsinvece di SqlStringcome non porta il LCID e le informazioni di confronto da SQL Server
• Specifica che la cultura non ha importanza tramite StringComparison.InvariantCulture:
  • String.Compare(string, string, StringComparison.InvariantCulture) o String.Compare(string, string, StringComparison.InvariantCultureIgnoreCase)
  • Per Regex, specificare RegexOptions.CultureInvariant

Aggiornato ..

La localizzazione è diversa tra il motore SQL e il server della finestra come sottolinea @srutzky:

os_language_version SqlServerLCID
1033 1039

La seguente modifica al codice: l'impostazione dell'opzione RegexOptions.CultureInvariantaggira l'errore. Il codice invariato non arresta in modo anomalo SQL Server 2012 su Windows Server 2012R2 con le stesse impostazioni di lingua ma lo fa su 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);
 }