生成具有条件 Snowflake 的唯一随机数

您是否尝试过 UNIFORM，也许这对您有用。https://docs.snowflake.com/en/sql-reference/functions/uniform.html

select  CONCAT('TEST-' , uniform(10000, 99000, random())) from table(generator(rowcount => 100));

除非您使用某种计算部分，否则无法保证随机数生成器函数的唯一性。例如：

create or replace table testX as
select  CONCAT('TEST-' , to_char(seq4(),'0000'),  
uniform(100000, 990000, random())) c 
from table(generator(rowcount => 1000));

每当需要在范围内分配唯一的随机数时，最好通过随机排序而不是生成新的随机数来处理。只需生成序列，然后随机排列其顺序即可。

根据用例，您可以简单地生成行，并对所选数量进行限制：order by random()

select * from (
select 'TEST-' || (seq4() + 10000)::string as MY_TEST_ID
from table(generator(rowcount => 89000))
) order by random() limit 10000
;

这个问题的通用解决方案更复杂，但肯定是可能的。JavaScript UDTF 可以使用范围内的所有值填充数组并对其进行随机排序。在 JavaScript UDTF 上使用 window 函数来确保行分布在单个块中，它将允许在任何 SQL 语句的某个范围内创建唯一的随机整数。

首先，创建表函数：

create or replace function UNIQUE_RANDOM_INTEGERS(LBOUND float, UBOUND float)
returns table (UNIQUE_RAND_INT float)
language javascript
strict volatile
as
$$
{
    initialize: function (argumentInfo, context) {
        this.lBound = argumentInfo.LBOUND.constValue;
        this.uBound = argumentInfo.UBOUND.constValue;
        this.rSpace = this.uBound - this.lBound + 1;
        
        if (this.lBound >= this.uBound) throw new Error(">>>  LBOUND and UBOUND must be constants and UBOUND must be greater than LBOUND <<<");
        if (this.rSpace > 25000000) throw new Error (">>> The difference between LBOUND and UBOUND must be 25,000,000 or less.");
        
        this.rands = new Array(this.rSpace);
        this.currentRow = 0;
        for (let i = 0; i < this.rands.length; i++) {
            this.rands[i] = this.lBound + i;
        }
        this.rands = shuffle(this.rands);
        
        function shuffle(array) {
            let currentIndex = array.length,  randomIndex;
            while (currentIndex != 0) {
                randomIndex = Math.floor(Math.random() * currentIndex);
                currentIndex--;
                [array[currentIndex], array[randomIndex]] = [array[randomIndex], array[currentIndex]];
            }
            return array;
        }
    },
    processRow: function (row, rowWriter, context) {
        //
    },
    finalize: function (rowWriter, context) {
        for (let i = 0; i < this.rSpace; i++) {
            rowWriter.writeRow({UNIQUE_RAND_INT:this.rands[i]});
        }
    },
}
$$;

create or replace function UNIQUE_RANDOM_INTEGERS(LBOUND int, UBOUND int)
returns table(UNIQUE_RAND_INT int)
language sql
as
$$
    select UNIQUE_RAND_INT::int from table(UNIQUE_RANDOM_INTEGERS(LBOUND::float, UBOUND::float) over (partition by 1))
$$;

然后，您可以使用以下 SQL 在某个范围内生成唯一的随机数：

select 'TEST-' || UNIQUE_RAND_INT as MY_RAND_VAL
from table(unique_random_integers(10000, 99000));

另一个洗牌答案：

一些设置：

set range_start = 1;
set range_end = 10;
set range_len = $range_end - $range_start;
set name_width = 6;

select 
    'row_' ||lpad(row_number()over(order by true),$name_width,0) as row_num
from table(generator(ROWCOUNT => $range_len));

给：

所以没有重复，现在洗牌它们，只需给它们和随机值并按顺序排序：

select 
    'row_' ||lpad(row_number()over(order by true),$name_width,0) as row_num
    ,random() as rnd_order
from table(generator(ROWCOUNT => $range_len))
order by rnd_order;

将设置更改为所需的 RELM：

set range_start = 1000;
set range_end = 1000000;
set range_len = $range_end - $range_start;

现在，如果您只想要 500K 答案而不是 9,999K，请在最后限制 500000。.