Apparemment, ma fonction d'assemblage CLR provoque des blocages?

Notre application doit fonctionner aussi bien avec une base de données Oracle ou une base de données Microsoft SQL Server. Pour faciliter cela, nous avons créé une poignée d'UDF pour homogénéiser notre syntaxe de requête. Par exemple, SQL Server a GETDATE () et Oracle a SYSDATE. Ils remplissent la même fonction mais ce sont des mots différents. Nous avons écrit un UDF wrapper appelé NOW () pour les deux plates-formes qui encapsule la syntaxe spécifique à la plate-forme appropriée dans un nom de fonction commun. Nous avons d'autres fonctions de ce type, dont certaines n'ont pratiquement rien d'autre mais n'existent que dans un but d'homogénéisation. Malheureusement, cela a un coût pour SQL Server. Les FDU scalaires en ligne font des ravages sur les performances et désactivent complètement le parallélisme. Comme alternative, nous avons écrit des fonctions d'assemblage CLR pour atteindre les mêmes objectifs. Lorsque nous avons déployé cela sur un client, il a commencé à rencontrer des blocages fréquents. Ce client particulier utilise des techniques de réplication et de haute disponibilité et je me demande s'il y a une sorte d'interaction en cours ici. Je ne comprends tout simplement pas comment l'introduction d'une fonction CLR pourrait causer des problèmes comme celui-ci. Pour référence, j'ai inclus la définition UDF scalaire d'origine ainsi que la définition CLR de remplacement en C # et la déclaration SQL correspondante. J'ai également un XML de blocage que je peux fournir si cela aide.

UDF d'origine

CREATE FUNCTION [fn].[APAD]
(
    @Value VARCHAR(4000)
    , @tablename VARCHAR(4000) = NULL
    , @columnname VARCHAR(4000) = NULL
)

RETURNS VARCHAR(4000)
WITH SCHEMABINDING
AS

BEGIN
    RETURN LTRIM(RTRIM(@Value))
END
GO

Fonction d'assemblage CLR

[SqlFunction(IsDeterministic = true)]
public static string APAD(string value, string tableName, string columnName)
{
    return value?.Trim();
}

Déclaration SQL Server pour la fonction CLR

CREATE FUNCTION [fn].[APAD]
(
    @Value NVARCHAR(4000),
    @TableName NVARCHAR(4000),
    @ColumnName NVARCHAR(4000)
) RETURNS NVARCHAR(4000)
AS
EXTERNAL NAME ASI.fn.APAD
GO

Quelle (s) version (s) de SQL Server utilisez-vous?

Je me souviens avoir vu un léger changement de comportement dans SQL Server 2017 il n'y a pas si longtemps. Je devrai revenir en arrière et voir si je peux trouver où j'en ai pris note, mais je pense que cela avait à voir avec un verrouillage de schéma initié lors de l'accès à un objet SQLCLR.

Pendant que je recherche cela, je dirai ce qui suit concernant votre approche:

1. Veuillez utiliser les Sql*types pour les paramètres d'entrée, les types de retour. Vous devriez utiliser SqlStringau lieu de string. SqlStringest très similaire à une chaîne nullable (la vôtre value?, mais elle comporte d'autres fonctionnalités spécifiques à SQL Server. Tous les Sql*types ont une Valuepropriété qui renvoie le type .NET attendu (par exemple, SqlString.Valueretours string, SqlInt32retours int, SqlDateTimeretours DateTime, etc.).

2. Je déconseille d'abord toute cette approche, que les impasses soient liées ou non. Je dis cela parce que:

   1. Même avec des UDF SQLCLR déterministes pouvant participer à des plans parallèles, vous obtiendrez très probablement des résultats de performance pour émuler des fonctions intégrées simplistes.
   2. L'API SQLCLR ne le permet pas VARCHAR. Êtes-vous d'accord avec la conversion implicite de tout en NVARCHARpuis de nouveau en VARCHARpour des opérations simples?
   3. L'API SQLCLR ne permet pas la surcharge, vous pouvez donc avoir besoin de plusieurs versions de fonctions qui autorisent différentes signatures dans T-SQL et / ou PL / SQL.
   4. Semblable à ne pas autoriser la surcharge, il y a une grande différence entre NVARCHAR(4000)et NVARCHAR(MAX): le MAXtype (en ayant même un seul dans la signature) fait que l'appel SQLCLR prend deux fois plus longtemps que de ne pas avoir de MAXtype dans la signature (je crois que cela tient vrai pour VARBINARY(MAX)vs VARBINARY(4000)aussi). Vous devez donc choisir entre:
      • utiliser uniquement NVARCHAR(MAX)pour avoir une API simplifiée, mais prendre le coup de performance lorsque vous utilisez 8000 octets ou moins de données de chaîne, ou
      • créer deux variantes pour toutes / la plupart / plusieurs fonctions de chaîne: une avec des MAXtypes et une sans (pour quand vous êtes assuré de ne jamais dépasser 8 000 octets de données de chaîne en entrée ou en sortie). C'est l'approche que j'ai choisie pour la plupart des fonctions de ma bibliothèque SQL # : il y a une Trim()fonction qui a probablement un ou plusieurs MAXtypes, et une Trim4k()version qui n'a jamais de MAXtype nulle part dans le schéma de signature ou de jeu de résultats. Les versions "4k" sont absolument plus efficaces.

   5. Vous ne faites pas attention à émuler les fonctionnalités étant donné l'exemple de la question. LTRIMet RTRIMne découper que les espaces, tandis que .NET String.Trim()supprime les espaces blancs (au moins l'espace, les tabulations et les nouvelles lignes). Par exemple:

        PRINT LTRIM(RTRIM(N'      a       '));

   6. De plus, je viens de remarquer que votre fonction, à la fois en T-SQL et en C #, n'utilise que 1 des 3 paramètres d'entrée. S'agit-il simplement d'une preuve de concept ou d'un code expurgé?