postgresql中的唯一随机时间戳

我花了好几个小时来做这件事。我需要创建100000行，时间戳是主键。这就是为什么它必须是独一无二的

我写了一些代码，它可以生成100个随机时间戳，但如果我尝试了100多个，比如1000或10000，我就有一个错误，就像这样

错误：重复的键值违反唯一约束“position_pkey” SQL状态：23505详细信息：键（“时间戳”）=（2014-03-09 04:03:16.843499）已存在

我不知道如何创建10万个唯一时间戳

这是我的职责

CREATE OR REPLACE FUNCTION generate_random(count integer DEFAULT 1)
  RETURNS SETOF timestamp AS
$BODY$
    BEGIN
            RETURN QUERY SELECT distinct NOW()::timestamp + '10ms'::interval *RANDOM()*RANDOM()
FROM generate_series(0,count);

            --SELECT (NOW() - '10000000'::INTERVAL * ROUND(RANDOM() * RANDOM()))::timestamp
                    --     FROM GENERATE_SERIES(1, count);
        END;
$BODY$
  LANGUAGE plpgsql VOLATILE
  COST 1000;

这是生成随机函数，随机生成双数

CREATE OR REPLACE FUNCTION generate_random(c integer DEFAULT 1, min double precision DEFAULT 0.0, max double precision DEFAULT 1.0)
  RETURNS SETOF double precision AS
$BODY$
        BEGIN
            RETURN QUERY SELECT min + (max - min) * RANDOM()
                         FROM GENERATE_SERIES(1, c);
        END;
    $BODY$
  LANGUAGE plpgsql VOLATILE STRICT
  COST 100
  ROWS 1000;

我在查询中这样调用这个函数

INSERT INTO "mytable"(
            "timestamp", x, y, z)
    VALUES (generate_random(1000), generate_random(1000, 0, 50), generate_random(1000, 0, 50), generate_random(1000, 0, 50));

---

因此，我想创建10万行，这些行是唯一的时间戳和一些随机的双倍数（不管是否唯一）

保证唯一时间戳的唯一方法是在插入之间添加延迟。相反，您可以使用序列号

create table mytable (
    s serial primary key,
    ts timestamp,
    x int,
    y int,
    z int
);
insert into mytable (ts, x, y, z) 
select 
    clock_timestamp(),
    500 * RANDOM(),
    500 * RANDOM(),
    500 * RANDOM()
from generate_series(1, 1000)
;

---

保证唯一时间戳的唯一方法是在插入之间添加延迟。相反，您可以使用序列号

create table mytable (
    s serial primary key,
    ts timestamp,
    x int,
    y int,
    z int
);
insert into mytable (ts, x, y, z) 
select 
    clock_timestamp(),
    500 * RANDOM(),
    500 * RANDOM(),
    500 * RANDOM()
from generate_series(1, 1000)
;

---

保证唯一时间戳的唯一方法是在插入之间添加延迟。相反，您可以使用序列号

create table mytable (
    s serial primary key,
    ts timestamp,
    x int,
    y int,
    z int
);
insert into mytable (ts, x, y, z) 
select 
    clock_timestamp(),
    500 * RANDOM(),
    500 * RANDOM(),
    500 * RANDOM()
from generate_series(1, 1000)
;

---

保证唯一时间戳的唯一方法是在插入之间添加延迟。相反，您可以使用序列号

create table mytable (
    s serial primary key,
    ts timestamp,
    x int,
    y int,
    z int
);
insert into mytable (ts, x, y, z) 
select 
    clock_timestamp(),
    500 * RANDOM(),
    500 * RANDOM(),
    500 * RANDOM()
from generate_series(1, 1000)
;

使用feistel密码从序列进行1:1映射的相同方法也可用于时间戳

或者，您可以使用非重复迭代伪随机数生成器

最重要的是，如果将结果缩小到较小的空间，则必须小心，因为会出现碰撞。

使用feistel密码从序列进行1:1映射的相同方法也可用于时间戳

或者，您可以使用非重复迭代伪随机数生成器

最重要的是，如果将结果缩小到较小的空间，则必须小心，因为会出现碰撞。

使用feistel密码从序列进行1:1映射的相同方法也可用于时间戳

或者，您可以使用非重复迭代伪随机数生成器

最重要的是，如果将结果缩小到较小的空间，则必须小心，因为会出现碰撞。

使用feistel密码从序列进行1:1映射的相同方法也可用于时间戳

或者，您可以使用非重复迭代伪随机数生成器

最重要的是，如果将结果缩小到较小的空间，则必须小心，因为会出现冲突。

扩展可以是 用于生成包含具有随机外观的唯一值的间隔 分配

下面是一个在中生成

100000

唯一时间戳的示例

10000000

（1000万）个可能值，基于 将伪随机序列中的元素乘以

10ms

间隔 添加到

now（）

1234

常量是一个模糊键：选择任何其他

bigint

以获得不同系列的结果

如果我们根据值的唯一性和区间大小检查结果：

 SELECT min(t),max(t),count(distinct t) FROM uniq_tstamp ;

            min             |            max             | count  
----------------------------+----------------------------+--------
 2017-02-02 16:00:50.750651 | 2017-02-03 19:47:30.350651 | 100000
(1 row)

查看第一个值：

 SELECT * FROM uniq_tstamp limit 10;
             t              
----------------------------
 2017-02-03 14:42:44.420651
 2017-02-03 11:40:37.200651
 2017-02-02 17:28:50.470651
 2017-02-03 00:34:12.060651
 2017-02-03 00:02:16.780651
 2017-02-03 05:53:41.550651
 2017-02-02 21:53:49.900651
 2017-02-03 02:58:37.420651
 2017-02-03 05:25:00.730651
 2017-02-03 09:13:42.110651

permuteseq应用的随机化不是加密等级，但它是合理的。
扩展可以是
用于生成包含具有随机外观的唯一值的间隔
分配

下面是一个在中生成
100000
唯一时间戳的示例
10000000
（1000万）个可能值，基于
将伪随机序列中的元素乘以
10ms
间隔
添加到
now（）

1234
常量是一个模糊键：选择任何其他
bigint
以获得不同系列的结果

如果我们根据值的唯一性和区间大小检查结果：

 SELECT min(t),max(t),count(distinct t) FROM uniq_tstamp ;

            min             |            max             | count  
----------------------------+----------------------------+--------
 2017-02-02 16:00:50.750651 | 2017-02-03 19:47:30.350651 | 100000
(1 row)

查看第一个值：

 SELECT * FROM uniq_tstamp limit 10;
             t              
----------------------------
 2017-02-03 14:42:44.420651
 2017-02-03 11:40:37.200651
 2017-02-02 17:28:50.470651
 2017-02-03 00:34:12.060651
 2017-02-03 00:02:16.780651
 2017-02-03 05:53:41.550651
 2017-02-02 21:53:49.900651
 2017-02-03 02:58:37.420651
 2017-02-03 05:25:00.730651
 2017-02-03 09:13:42.110651

permuteseq应用的随机化不是加密等级，但它是合理的。
扩展可以是
用于生成包含具有随机外观的唯一值的间隔
分配

下面是一个在中生成
100000
唯一时间戳的示例
10000000
（1000万）个可能值，基于
将伪随机序列中的元素乘以
10ms
间隔
添加到
now（）

1234
常量是一个模糊键：选择任何其他
bigint
以获得不同系列的结果

如果我们根据值的唯一性和区间大小检查结果：

 SELECT min(t),max(t),count(distinct t) FROM uniq_tstamp ;

            min             |            max             | count  
----------------------------+----------------------------+--------
 2017-02-02 16:00:50.750651 | 2017-02-03 19:47:30.350651 | 100000
(1 row)

查看第一个值：

 SELECT * FROM uniq_tstamp limit 10;
             t              
----------------------------
 2017-02-03 14:42:44.420651
 2017-02-03 11:40:37.200651
 2017-02-02 17:28:50.470651
 2017-02-03 00:34:12.060651
 2017-02-03 00:02:16.780651
 2017-02-03 05:53:41.550651
 2017-02-02 21:53:49.900651
 2017-02-03 02:58:37.420651
 2017-02-03 05:25:00.730651
 2017-02-03 09:13:42.110651

permuteseq应用的随机化不是加密等级，但它是合理的。
扩展可以是
用于生成包含具有随机外观的唯一值的间隔
分配

下面是一个在中生成
100000
唯一时间戳的示例
10000000
（1000万）个可能值，基于
将伪随机序列中的元素乘以
10ms
间隔
添加到
now（）

1234
常量是一个模糊键：选择任何其他
bigint
以获得不同系列的结果

如果我们根据值的唯一性和区间大小检查结果：

 SELECT min(t),max(t),count(distinct t) FROM uniq_tstamp ;

            min             |            max             | count  
----------------------------+----------------------------+--------
 2017-02-02 16:00:50.750651 | 2017-02-03 19:47:30.350651 | 100000
(1 row)

查看第一个值：

 SELECT * FROM uniq_tstamp limit 10;
             t              
----------------------------
 2017-02-03 14:42:44.420651
 2017-02-03 11:40:37.200651
 2017-02-02 17:28:50.470651
 2017-02-03 00:34:12.060651
 2017-02-03 00:02:16.780651
 2017-02-03 05:53:41.550651
 2017-02-02 21:53:49.900651
 2017-02-03 02:58:37.420651
 2017-02-03 05:25:00.730651
 2017-02-03 09:13:42.110651

permuteseq
应用的随机化不是加密级别，但它是合理的。
分布均匀的
！=
random
，但差异确实取决于OP的要求。谢谢您的回答，我将尝试此代码，但是postgresql中的延迟又如何呢？我在谷歌上搜索了一下，还没有找到样品。。我只是看到一些睡眠功能。。这对100000行有用吗？@Clodoaldo Neto，我用了你的代码，看起来不错，但我想生成-100到10之间的双倍数