SQL CLR 中的多线程缓存

Question

是否有任何多线程缓存机制可以在 SQL CLR 函数中工作而无需将程序集注册为“不安全”？

正如in this post 所述，简单地使用lock 语句将在安全程序集上引发异常：

System.Security.HostProtectionException: 
Attempted to perform an operation that was forbidden by the CLR host.

The protected resources (only available with full trust) were: All
The demanded resources were: Synchronization, ExternalThreading

我希望对我的函数的任何调用都以线程安全的方式使用相同的内部缓存，以便许多操作可以同时进行缓存读取和写入。本质上-我需要一个ConcurrentDictionary，它将在SQLCLR“安全”程序集中工作。不幸的是，使用ConcurrentDictionary 本身会产生与上述相同的异常。

SQLCLR 或 SQL Server 是否有内置的东西来处理这个问题？还是我误解了SQLCLR的线程模型？

我已尽我所能阅读有关 SQLCLR 安全限制的内容。特别是，以下文章可能有助于理解我在说什么：

• SQL Server CLR Integration Part 1: Security
• Deploy/Use assemblies which require Unsafe/External Access with CLR and T-SQL

此代码最终将成为分发给其他人的库的一部分，因此我真的不想被要求以“不安全”的方式运行它。

我正在考虑的一个选项（由 Spender 在下面的 cmets 中提出）是从 SQLCLR 代码中访问 tempdb 并将其用作缓存。 但我不太确定该怎么做。我也不确定它是否会像内存缓存一样具有性能。 请参阅下面的更新。

我对任何其他可用的替代品感兴趣。谢谢。

示例

以下代码使用静态并发字典作为缓存，并通过 SQL CLR 用户定义函数访问该缓存。所有对函数的调用都将使用相同的缓存。但除非程序集被注册为“不安全”，否则这将不起作用。

public class UserDefinedFunctions
{
    private static readonly ConcurrentDictionary<string,string> Cache =
                            new ConcurrentDictionary<string, string>();

    [SqlFunction]
    public static SqlString GetFromCache(string key)
    {
        string value;
        if (Cache.TryGetValue(key, out value))
            return new SqlString(value);
        return SqlString.Null;
    }

    [SqlProcedure]
    public static void AddToCache(string key, string value)
    {
        Cache.TryAdd(key, value);
    }
}

它们位于名为 SqlClrTest 的程序集中，并使用以下 SQL 包装器：

CREATE FUNCTION [dbo].[GetFromCache](@key nvarchar(4000))
RETURNS nvarchar(4000) WITH EXECUTE AS CALLER
AS EXTERNAL NAME [SqlClrTest].[SqlClrTest.UserDefinedFunctions].[GetFromCache]
GO

CREATE PROCEDURE [dbo].[AddToCache](@key nvarchar(4000), @value nvarchar(4000))
WITH EXECUTE AS CALLER
AS EXTERNAL NAME [SqlClrTest].[SqlClrTest.UserDefinedFunctions].[AddToCache]
GO

然后它们在数据库中的使用是这样的：

EXEC dbo.AddToCache 'foo', 'bar'

SELECT dbo.GetFromCache('foo')

更新

我想出了如何使用Context Connection 从 SQLCLR 访问数据库。代码in this Gist 显示了ConcurrentDictionary 方法和tempdb 方法。然后我进行了一些测试，从客户统计数据（平均 10 次试验）测得以下结果：

Concurrent Dictionary Cache
10,000 Writes: 363ms
10,000 Reads :  81ms

TempDB Cache
10,000 Writes: 3546ms
10,000 Reads : 1199ms

这样就放弃了使用 tempdb 表的想法。真的没有别的我可以尝试的吗？

Answer 1

我添加了一条类似的评论，但我将把它放在这里作为答案，因为我认为它可能需要一些背景知识。

ConcurrentDictionary，正如您正确指出的那样，最终需要UNSAFE，因为它使用的线程同步原语甚至超出了lock - 这明确需要访问较低级别的操作系统资源，因此需要在外面钓鱼SQL 托管环境。

因此，获得不需要UNSAFE 的解决方案的唯一方法是使用不使用任何锁或其他线程同步原语的解决方案。但是，如果底层结构是 .Net Dictionary，那么在多个线程之间共享它的唯一真正安全的方法是使用带有旋转等待的 Lock 或 Interlocked.CompareExchange（参见 here）。我似乎找不到任何关于在SAFE 权限集下是否允许后者的信息，但我的猜测是它不是。

我也会质疑在数据库引擎中应用基于 CLR 的解决方案来解决此问题的有效性，其索引和查找能力可能远远超过任何托管 CLR 解决方案。

Answer 2

接受的答案不正确。 Interlocked.CompareExchange 不是一个选项，因为它需要更新共享资源，并且无法在 SAFE 程序集中创建可以更新的所述静态变量。

（在大多数情况下）没有办法在 SAFE 程序集中的调用中缓存数据（也不应该有）。原因是类的单个实例（嗯，在每个数据库每个所有者的应用程序域内）在 所有 会话之间共享。这种行为通常是非常不受欢迎的。

但是，我确实说过“在大多数情况下”这是不可能的。有一种方法，虽然我不确定它是一个错误还是打算这样。我会错误地认为它是一个错误，因为在会话之间共享一个变量是一个非常不稳定的活动。尽管如此，您可以（这样做需要您自担风险，并且这不是特别线程安全的，但可能仍然有效）修改static readonlycollections。对。如：

using Microsoft.SqlServer.Server;
using System.Data.SqlTypes;
using System.Collections;

public class CachingStuff
{
    private static readonly Hashtable _KeyValuePairs = new Hashtable();

    [SqlFunction(DataAccess = DataAccessKind.None, IsDeterministic = true)]
    public static SqlString GetKVP(SqlString KeyToGet)
    {
        if (_KeyValuePairs.ContainsKey(KeyToGet.Value))
        {
            return _KeyValuePairs[KeyToGet.Value].ToString();
        }

        return SqlString.Null;
    }

    [SqlProcedure]
    public static void SetKVP(SqlString KeyToSet, SqlString ValueToSet)
    {
        if (!_KeyValuePairs.ContainsKey(KeyToSet.Value))
        {
            _KeyValuePairs.Add(KeyToSet.Value, ValueToSet.Value);
        }

        return;
    }

    [SqlProcedure]
    public static void UnsetKVP(SqlString KeyToUnset)
    {
        _KeyValuePairs.Remove(KeyToUnset.Value);
        return;
    }
}

运行上面的代码，数据库设置为TRUSTWORTHY OFF，程序集设置为SAFE，我们得到：

EXEC dbo.SetKVP 'f', 'sdfdg';

SELECT dbo.GetKVP('f'); -- sdfdg

SELECT dbo.GetKVP('g'); -- NULL

EXEC dbo.UnsetKVP 'f';

SELECT dbo.GetKVP('f'); -- NULL

---

总而言之，可能有更好的方法不是SAFE，也不是UNSAFE。既然希望使用内存来缓存重复使用的值，为什么不设置一个 memcached 或 redis 服务器并创建 SQLCLR 函数与之通信呢？这只需要将程序集设置为EXTERNAL_ACCESS。

这样您就不必担心几个问题：

• 消耗大量可以/应该用于查询的内存。

• 静态变量中保存的数据不会自动过期。它一直存在，直到您将其删除或 App Domain 被卸载，这可能在很长一段时间内都不会发生。但是 memcached 和 redis 确实允许设置过期时间。

• 这不是明确的线程安全的。但是缓存服务器是。

Answer 3

SQL Server 锁定函数 sp_getapplock 和 sp_releaseapplock 可以在 SAFE 上下文中使用。使用它们来保护一个普通的Dictionary，你就有了自己的缓存！

以这种方式锁定的代价比普通的lock 差很多，但如果您以相对粗粒度的方式访问缓存，这可能不是问题。

--- 更新 ---

Interlocked.CompareExchange 可用于静态实例中包含的字段。 readonly 可以进行静态引用，但是被引用对象中的字段仍然可以是可变的，因此可以被 Interlocked.CompareExchange 使用。

Interlocked.CompareExchange 和 static readonly 在 SAFE 上下文中都是允许的。性能比sp_getapplock好很多。

Answer 4

根据 Andras 的回答，这是我在 SAFE 权限下植入“SharedCache”以在字典中读写。

EvalManager（静态）

using System;
using System.Collections.Generic;
using Z.Expressions.SqlServer.Eval;

namespace Z.Expressions
{
    /// <summary>Manager class for eval.</summary>
    public static class EvalManager
    {
        /// <summary>The cache for EvalDelegate.</summary>
        public static readonly SharedCache<string, EvalDelegate> CacheDelegate = new SharedCache<string, EvalDelegate>();

        /// <summary>The cache for SQLNETItem.</summary>
        public static readonly SharedCache<string, SQLNETItem> CacheItem = new SharedCache<string, SQLNETItem>();

        /// <summary>The shared lock.</summary>
        public static readonly SharedLock SharedLock;

        static EvalManager()
        {
            // ENSURE to create lock first
            SharedLock = new SharedLock();
        }
    }
}

共享锁

using System.Threading;

namespace Z.Expressions.SqlServer.Eval
{
    /// <summary>A shared lock.</summary>
    public class SharedLock
    {
        /// <summary>Acquires the lock on the specified lockValue.</summary>
        /// <param name="lockValue">[in,out] The lock value.</param>
        public static void AcquireLock(ref int lockValue)
        {
            do
            {
                // TODO: it's possible to wait 10 ticks? Thread.Sleep doesn't really support it.
            } while (0 != Interlocked.CompareExchange(ref lockValue, 1, 0));
        }

        /// <summary>Releases the lock on the specified lockValue.</summary>
        /// <param name="lockValue">[in,out] The lock value.</param>
        public static void ReleaseLock(ref int lockValue)
        {
            Interlocked.CompareExchange(ref lockValue, 0, 1);
        }

        /// <summary>Attempts to acquire lock on the specified lockvalue.</summary>
        /// <param name="lockValue">[in,out] The lock value.</param>
        /// <returns>true if it succeeds, false if it fails.</returns>
        public static bool TryAcquireLock(ref int lockValue)
        {
            return 0 == Interlocked.CompareExchange(ref lockValue, 1, 0);
        }
    }
}

共享缓存

using System;
using System.Collections.Generic;

namespace Z.Expressions.SqlServer.Eval
{
    /// <summary>A shared cache.</summary>
    /// <typeparam name="TKey">Type of key.</typeparam>
    /// <typeparam name="TValue">Type of value.</typeparam>
    public class SharedCache<TKey, TValue>
    {
        /// <summary>The lock value.</summary>
        public int LockValue;

        /// <summary>Default constructor.</summary>
        public SharedCache()
        {
            InnerDictionary = new Dictionary<TKey, TValue>();
        }

        /// <summary>Gets the number of items cached.</summary>
        /// <value>The number of items cached.</value>
        public int Count
        {
            get { return InnerDictionary.Count; }
        }

        /// <summary>Gets or sets the inner dictionary used to cache items.</summary>
        /// <value>The inner dictionary used to cache items.</value>
        public Dictionary<TKey, TValue> InnerDictionary { get; set; }

        /// <summary>Acquires the lock on the shared cache.</summary>
        public void AcquireLock()
        {
            SharedLock.AcquireLock(ref LockValue);
        }

        /// <summary>Adds or updates a cache value for the specified key.</summary>
        /// <param name="key">The cache key.</param>
        /// <param name="value">The cache value used to add.</param>
        /// <param name="updateValueFactory">The cache value factory used to update.</param>
        /// <returns>The value added or updated in the cache for the specified key.</returns>
        public TValue AddOrUpdate(TKey key, TValue value, Func<TKey, TValue, TValue> updateValueFactory)
        {
            try
            {
                AcquireLock();

                TValue oldValue;
                if (InnerDictionary.TryGetValue(key, out oldValue))
                {
                    value = updateValueFactory(key, oldValue);
                    InnerDictionary[key] = value;
                }
                else
                {
                    InnerDictionary.Add(key, value);
                }

                return value;
            }
            finally
            {
                ReleaseLock();
            }
        }

        /// <summary>Adds or update a cache value for the specified key.</summary>
        /// <param name="key">The cache key.</param>
        /// <param name="addValueFactory">The cache value factory used to add.</param>
        /// <param name="updateValueFactory">The cache value factory used to update.</param>
        /// <returns>The value added or updated in the cache for the specified key.</returns>
        public TValue AddOrUpdate(TKey key, Func<TKey, TValue> addValueFactory, Func<TKey, TValue, TValue> updateValueFactory)
        {
            try
            {
                AcquireLock();

                TValue value;
                TValue oldValue;

                if (InnerDictionary.TryGetValue(key, out oldValue))
                {
                    value = updateValueFactory(key, oldValue);
                    InnerDictionary[key] = value;
                }
                else
                {
                    value = addValueFactory(key);
                    InnerDictionary.Add(key, value);
                }


                return value;
            }
            finally
            {
                ReleaseLock();
            }
        }

        /// <summary>Clears all cached items.</summary>
        public void Clear()
        {
            try
            {
                AcquireLock();
                InnerDictionary.Clear();
            }
            finally
            {
                ReleaseLock();
            }
        }


        /// <summary>Releases the lock on the shared cache.</summary>
        public void ReleaseLock()
        {
            SharedLock.ReleaseLock(ref LockValue);
        }

        /// <summary>Attempts to add a value in the shared cache for the specified key.</summary>
        /// <param name="key">The key.</param>
        /// <param name="value">The value.</param>
        /// <returns>true if it succeeds, false if it fails.</returns>
        public bool TryAdd(TKey key, TValue value)
        {
            try
            {
                AcquireLock();

                if (!InnerDictionary.ContainsKey(key))
                {
                    InnerDictionary.Add(key, value);
                }

                return true;
            }
            finally
            {
                ReleaseLock();
            }
        }

        /// <summary>Attempts to remove a key from the shared cache.</summary>
        /// <param name="key">The key.</param>
        /// <param name="value">[out] The value.</param>
        /// <returns>true if it succeeds, false if it fails.</returns>
        public bool TryRemove(TKey key, out TValue value)
        {
            try
            {
                AcquireLock();

                var isRemoved = InnerDictionary.TryGetValue(key, out value);
                if (isRemoved)
                {
                    InnerDictionary.Remove(key);
                }

                return isRemoved;
            }
            finally
            {
                ReleaseLock();
            }
        }

        /// <summary>Attempts to get value from the shared cache for the specified key.</summary>
        /// <param name="key">The key.</param>
        /// <param name="value">[out] The value.</param>
        /// <returns>true if it succeeds, false if it fails.</returns>
        public bool TryGetValue(TKey key, out TValue value)
        {
            try
            {
                return InnerDictionary.TryGetValue(key, out value);
            }
            catch (Exception)
            {
                value = default(TValue);
                return false;
            }
        }
    }
}

源文件：

• https://github.com/zzzprojects/Eval-SQL.NET/blob/master/src/Z.Expressions.SqlServer.Eval/EvalManager/EvalManager.cs

• https://github.com/zzzprojects/Eval-SQL.NET/blob/master/src/Z.Expressions.SqlServer.Eval/Shared/SharedLock.cs

• https://github.com/zzzprojects/Eval-SQL.NET/blob/master/src/Z.Expressions.SqlServer.Eval/Shared/SharedCache.cs

Answer 5

您的需求会满足表变量吗？无论如何，它们会尽可能长时间地保存在内存中，因此性能应该非常出色。当然，如果您需要在应用调用之间维护缓存，那它就不是那么有用了。

作为类型创建，您也可以将这样的表传递给 sproc 或 UDF。