UDF 中的 COLLATE 无法按预期工作

Question

我有一个带有文本字段的 table。我想要 select 行，其中文本全部大写。此代码可以正常工作，returns ABC:

SELECT txt
FROM (SELECT 'ABC' AS txt UNION SELECT 'cdf') t
WHERE 
txt COLLATE SQL_Latin1_General_CP1_CS_AS = UPPER(txt)

然后我创建 UDF（按照建议）：

CREATE FUNCTION [dbo].[fnsConvert]
(
      @p NVARCHAR(2000) ,
      @c NVARCHAR(2000)
)
RETURNS NVARCHAR(2000)
AS
    BEGIN
        IF ( @c = 'SQL_Latin1_General_CP1_CS_AS' )
            SET @p = @p COLLATE SQL_Latin1_General_CP1_CS_AS
        RETURN @p    
    END

和运行如下（对我来说这看起来是等效的代码）：

SELECT txt
FROM (SELECT 'ABC' AS txt UNION SELECT 'cdf') t
WHERE 
dbo.fnsConvert(txt, 'SQL_Latin1_General_CP1_CS_AS') = UPPER(txt)

然而，这个 returns ABC 以及 cdf.

为什么会这样，我该如何让它发挥作用？

PS 我在这里需要 UDF 才能从 .Net LINQ2SQL 提供程序调用区分大小写的比较。

Answer 1

我认为您对排序规则的工作原理感到困惑。如果你想强制使用区分大小写的排序规则，你可以在你的 where 谓词中执行它，而不是使用这样的函数。标量函数的性能非常糟糕。

以下是您如何对此类事物使用排序规则。

SELECT txt
FROM (SELECT 'ABC' AS txt UNION SELECT 'cdf') t
WHERE txt collate SQL_Latin1_General_CP1_CS_AS = UPPER(txt)

Answer 2

这是我所做的：我更改了函数来执行比较，而不是设置排序规则，然后 return 一个 1 或 0。

CREATE FUNCTION [dbo].[fnsConvert]
(
      @p NVARCHAR(2000) ,
      @c NVARCHAR(2000)
)
RETURNS BIT
AS

    BEGIN
        DECLARE @result BIT

        IF ( @c = 'SQL_Latin1_General_CP1_CS_AS' )
        BEGIN
            IF @p COLLATE SQL_Latin1_General_CP1_CS_AS = UPPER(@p) 
                SET @result = 1
            ELSE
                SET @result = 0    
        END
        ELSE
            SET @result = 0 

        RETURN @result
    END

然后使用该函数的查询稍微改变一下。

SELECT txt
FROM (SELECT 'ABC' AS txt UNION SELECT 'cdf') t
WHERE 
dbo.fnsConvert(txt, 'SQL_Latin1_General_CP1_CS_AS') = 1

Answer 3

变量不能有自己的排序规则。它将始终使用服务器的默认值。检查这个：

--我声明了三个变量，每个变量都有自己的排序规则——至少有人会这么认为：

DECLARE @deflt VARCHAR(100) = 'aBc'; --Latin1_General_CI_AS in my system
DECLARE @Arab VARCHAR(100) = 'aBc' COLLATE Arabic_100_CS_AS_WS_SC;
DECLARE @Rom VARCHAR(100) = 'aBc' COLLATE Romanian_CI_AI

--现在检查一下。所有三个变量都被视为系统的默认排序规则：

SELECT [name], system_type_name, collation_name
FROM sys.dm_exec_describe_first_result_set(N'SELECT @deflt AS Deflt, @Arab AS Arab, @Rom AS Rom'
                                          ,N'@deflt varchar(100), @Arab varchar(100),@Rom varchar(100)'
                                          ,0);

/*
name    system_type_name    collation_name
Deflt   varchar(100)        Latin1_General_CI_AS
Arab    varchar(100)        Latin1_General_CI_AS
Rom     varchar(100)        Latin1_General_CI_AS
*/

--现在我们检查 "aBc" 与 "ABC"

的简单比较

SELECT CASE WHEN @deflt = 'ABC' THEN 'CI' ELSE 'CS' END AS CheckDefault
      ,CASE WHEN @Arab = 'ABC' THEN 'CI' ELSE 'CS' END AS CheckArab
      ,CASE WHEN @Rom = 'ABC' THEN 'CI' ELSE 'CS' END AS CheckRom

/*CI    CI  CI*/

--但是我们可以为一个给定的动作指定排序规则！

SELECT CASE WHEN @deflt = 'ABC' THEN 'CI' ELSE 'CS' END AS CheckDefault
      ,CASE WHEN @Arab = 'ABC' COLLATE Arabic_100_CS_AS_WS_SC THEN 'CI' ELSE 'CS' END AS CheckArab
      ,CASE WHEN @Rom = 'ABC' COLLATE Romanian_CI_AI THEN 'CI' ELSE 'CS' END AS CheckRom

/*CI    CS  CI*/

--但是 table 的列会有所不同：

CREATE TABLE #tempTable(deflt VARCHAR(100)
                       ,Arab VARCHAR(100) COLLATE Arabic_100_CS_AS_WS_SC
                       ,Rom VARCHAR(100) COLLATE Romanian_CI_AI);

INSERT INTO #tempTable(deflt,Arab,Rom) VALUES('aBc','aBc','aBc');

SELECT [name], system_type_name, collation_name
FROM sys.dm_exec_describe_first_result_set(N'SELECT * FROM #tempTable',NULL,0);
DROP TABLE #tempTable;

/*
name    system_type_name    collation_name
deflt   varchar(100)        Latin1_General_CI_AS
Arab    varchar(100)        Arabic_100_CS_AS_WS_SC
Rom     varchar(100)        Romanian_CI_AI
*/

--这也适用于声明的 table 变量。比较"knows"指定的排序规则：

DECLARE @TableVariable TABLE(deflt VARCHAR(100)
                            ,Arab VARCHAR(100) COLLATE Arabic_100_CS_AS_WS_SC
                            ,Rom VARCHAR(100) COLLATE Romanian_CI_AI);

INSERT INTO @TableVariable(deflt,Arab,Rom) VALUES('aBc','aBc','aBc');

SELECT CASE WHEN tv.deflt = 'ABC' THEN 'CI' ELSE 'CS' END AS CheckDefault
      ,CASE WHEN tv.Arab = 'ABC' THEN 'CI' ELSE 'CS' END AS CheckArab
      ,CASE WHEN tv.Rom = 'ABC' THEN 'CI' ELSE 'CS' END AS CheckRom
FROM @TableVariable AS tv

/*CI    CS  CI*/

更新一些文档

At this link详情可以看。排序规则 不会更改值 。它应用了一个规则（与NOT NULL相关，它不改变值，只是添加了是否可以设置NULL的规则）。

文档说的很清楚

Is a clause that can be applied to a database definition or a column definition to define the collation, or to a character string expression to apply a collation cast.

稍后你会发现

Creating or altering a database

Creating or altering a table column

Casting the collation of an expression

更新 2：解决方案的建议

如果你想控制比较是完成 CS 还是 CI 你可以试试这个：

DECLARE @tbl TABLE(SomeValueInDefaultCollation VARCHAR(100));
INSERT INTO  @tbl VALUES ('ABC'),('aBc');

DECLARE @CompareCaseSensitive BIT = 0;
DECLARE @SearchFor VARCHAR(100) = 'aBc';

SELECT *
FROM @tbl 
WHERE (@CompareCaseSensitive=1 AND SomeValueInDefaultCollation=@SearchFor COLLATE Latin1_General_CS_AS)
   OR (ISNULL(@CompareCaseSensitive,0)=0 AND SomeValueInDefaultCollation=@SearchFor COLLATE Latin1_General_CI_AS);

将 @CompareCaseSensitive 设置为 1 它将 return 只是 aBc，将 NULL 或 0 设置为 return 两行。

这是 - 当然！ - 性能比 UDF 好得多。

Answer 4

请尝试使用BINARY_CHECKSUM函数，不需要UDF函数：

SELECT txt
FROM (SELECT 'ABC' AS txt UNION SELECT 'cdf') t
WHERE 
BINARY_CHECKSUM(txt)= BINARY_CHECKSUM(UPPER(txt))

Answer 5

我同意 @Shnugo 当你创建局部变量时它将采用默认排序规则

但是，您可以明确地将函数返回的变量值与用户定义的排序规则进行排序，如下所示：

select * from 
(SELECT 'ABC' AS txt UNION SELECT 'cdf') a
where (dbo.fnsConvert(txt, 'SQL_Latin1_General_CP1_CS_AS') 
collate SQL_Latin1_General_CP1_CS_AS)  = UPPER(txt)

此外 collate子句只能应用于数据库定义，列定义或string/character表达式，换句话说它用于数据库对象，即表、列、索引

collation_name不能用变量或表达式表示。

Answer 6

如@Shnugo 所述，排序规则不是变量的属性，但它可以是列定义的属性。

对于 TSQL 之外启用排序规则的比较，您可以定义一个具有显式排序规则的（持久化）计算列：

create table Q47890189 (
    txt nvarchar(100),
    colltxt as txt collate SQL_Latin1_General_CP1_CS_AS persisted
)

insert into Q47890189 (txt) values ('ABC')
insert into Q47890189 (txt) values ('cdf')

select * from Q47890189 where txt = UPPER(txt)
select * from Q47890189 where colltxt = UPPER(colltxt)

请注意，持久化列也可以被索引，并且比调用标量函数具有更好的性能。

Answer 7

COLLATE :是一个子句，可以应用于数据库定义或列定义以定义排序规则，或应用于字符串表达式以应用排序规则转换。

COLLATE不转换任何列或变量..它定义了整理的特征。

CREATE TABLE [dbo].[OINV]
    [CardCode] [nvarchar](50) NULL
)

如果我有 table 和 5175460 rows 然后将其转换为另一种数据类型需要时间，因为它的值被转换为新的数据类型。

alter table OINV
alter column CardCode varchar(50)
--1 min 45 sec

alter table OINV
alter column CardCode nvarchar(50) COLLATE SQL_Latin1_General_CP1_CS_AS

如果我不转换数据类型而只想更改整理然后需要 1 毫秒来做 so.That 意味着它不会将 5175460 行转换为所述整理。它只是定义该列的整理。

当此列用于 where 条件时，该列将表现出所述整理的特征。

UDF/TVF is not perform-ant way to do so.Best way is to alter table

另一个例子，

declare @i varchar(60)='ABC'

SELECT txt
FROM (SELECT 'abc' AS txt UNION SELECT 'cdf') t
WHERE 
txt  = @i COLLATE SQL_Latin1_General_CP1_CS_AS

我不能这样声明，

declare @i varchar(60) COLLATE SQL_Latin1_General_CP1_CS_AS='ABC'

因此变量只有在与 collate 一起使用时才会表现出 collate 特性。

在你的情况下，你 return 只是普通变量，

UDF 这样做的方式，

CREATE FUNCTION testfn (
    @test VARCHAR(100)
    ,@i INT
    )
RETURNS TABLE
AS
RETURN (
        -- insert into @t values(@test)
        SELECT @test COLLATE SQL_Latin1_General_CP1_CS_AS AS a
        )


SELECT *
FROM (
    SELECT 'ABC' AS txt

    UNION

    SELECT 'cdf'
    ) t
OUTER APPLY dbo.testfn(txt, 0) fn
WHERE fn.a = UPPER(txt)

要定义多个排序规则，您必须使用不同的排序规则定义多个 table。 TVF 只能 return 静态 table 模式，因此只能有一个整理定义。

因此 TVF 不是执行任务的正确方法。

Answer 8

MSDN明确定义COLLATE:

Is a clause that can be applied to a database definition or a column definition to define the collation, or to a character string expression to apply a collation cast.

你能在这里看到一个关于变量的词吗？

如果需要UDF，只需使用table值函数：

CREATE FUNCTION dbo.test 
(   
    @text nvarchar(max)
)
RETURNS TABLE 
AS
RETURN 
(
    SELECT c COLLATE SQL_Latin1_General_CP1_CS_AS as txt
    FROM (VALUES (@text)) as t(c)
)
GO

并像这样使用它：

;WITH cte AS (
    SELECT N'ABC' as txt
    UNION 
    SELECT N'cdf'
)

SELECT c.txt
FROM cte c
OUTER APPLY dbo.test (c.txt) t
WHERE t.txt = UPPER(c.txt)

输出：

txt
------
ABC

UDF 中的 COLLATE 无法按预期工作

COLLATE in UDF does not work as expected

sql

tsql

sql-server

collation

更新一些文档

更新 2：解决方案的建议