Bloqueo de CLR en SQL Server 2014 (Windows 2012R2)

Tengo este pequeño CLR que hace una función RegEX en una cadena en columnas.

Cuando se ejecuta en SQL Server 2014 (12.0.2000) en Windows Server 2012R2, el proceso se bloquea con

Mensaje 0, Nivel 11, Estado 0, Línea 0 Se produjo un error grave en el comando actual. Los resultados, si los hay, deben descartarse.

y da un volcado de pila si lo hago

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

pero cuando lo hago

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

devuelve las filas.

Funciona perfectamente en la misma compilación de SQL Server que se ejecuta en Windows 8.1.

¿Algunas ideas?

- Editar Es tan simple como puede ser

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

Entonces, con pequeños cambios, esto funciona ahora: la lección principal en C # parece ser la misma que en TSQL, tenga cuidado con la conversión de datos implícita.

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

El problema es un conflicto de configuración regional entre el sistema operativo Windows y SQL Server (específicamente la base de datos donde se carga el ensamblado). Puede ejecutar la siguiente consulta para ver en qué están configurados ambos:

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

Si son diferentes, entonces definitivamente puede tener un comportamiento "extraño", como lo que está viendo. El problema es que:

• SqlStringincluye más que solo el texto en sí: incluye la clasificación predeterminada de la base de datos en la que existe el ensamblado. La recopilación se compone de dos piezas de información: la información de la configuración regional (es decir, LCID) y las opciones de comparación (es decir, SqlCompareOptions) que detallan la sensibilidad a mayúsculas, acentos, kana, ancho o todo (binario y binario2).
• Las operaciones de cadena en .NET, a menos que se especifique explícitamente una configuración regional, utilice la información de la configuración regional del subproceso actual, que se establece en Windows (es decir, el sistema operativo / SO).

El conflicto generalmente ocurre cuando se hace referencia a un parámetro SqlString sin usar .Valueo .ToString()tal que haga una conversión implícita a SqlString. En ese caso, causaría una excepción diciendo que los LCID no coinciden.

Aparentemente, existen otros escenarios, como realizar comparaciones de cadenas (¿algunas / todas?), Incluso cuando se usa Regex como lo muestra este caso (aunque hasta ahora no he podido reproducir esto).

Algunas ideas para soluciones:

Ideal (siempre se cumplirán las expectativas con respecto a cómo funcionan las comparaciones):

• Cambie el LCID de Windows o SQL Server (idioma predeterminado) para que ambos coincidan

Menos que ideal (el comportamiento de la configuración regional de Windows podría no ser las mismas reglas para la igualdad y la clasificación, por lo que podría haber resultados inesperados):

• Use el .ToStringmétodo o la .Valuepropiedad, que devuelven la cadena sin el LCID de SQL Server para que todas las operaciones usen el LCID del sistema operativo.

Podría ayudar:

• Tal vez use en SqlCharslugar de, SqlStringya que no trae consigo la información LCID y de recopilación de SQL Server
• Especifique que la cultura no importa a través de StringComparison.InvariantCulture:
  • String.Compare(string, string, StringComparison.InvariantCulture) o String.Compare(string, string, StringComparison.InvariantCultureIgnoreCase)
  • Para Regex, especifique RegexOptions.CultureInvariant

Actualizado..

La localización es diferente entre el motor SQL y el servidor de ventana como @srutzky señala:

os_language_version SqlServerLCID
1033 1039

El siguiente cambio en el código: la configuración de la opción RegexOptions.CultureInvariantevita el error. El código sin cambios no bloqueará SQL Server 2012 en Windows Server 2012R2 con la misma configuración de idioma, pero lo hace en 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);
 }