prosource

랜덤 행을 선택하는 가장 좋은 방법 PostgreSQL

probook 2023. 4. 18. 23:06

랜덤 행을 선택하는 가장 좋은 방법 PostgreSQL

Postgre에서 행을 임의로 선택하고 싶다.SQL, 이거 해봤는데:

select * from table where random() < 0.01;

그러나 다른 일부에서는 다음과 같이 권장하고 있습니다.

select * from table order by random() limit 1000;

5억 줄이나 되는 큰 테이블이 있는데 빨리 했으면 좋겠어요.

어떤 접근법이 더 나은가?어떤 차이가 있을까?랜덤 행을 선택하는 가장 좋은 방법은 무엇입니까?

고속화 방법

고객의 사양(및 코멘트의 추가 정보)에 따라,

숫자 ID 열(정수)에는 간격이 거의(또는 중간 정도) 없습니다.
쓰기 작업이 거의 없거나 거의 없습니다.
ID 열을 인덱싱해야 합니다!프라이머리 키가 도움이 됩니다.

아래 쿼리는 빅 테이블의 순차적 스캔이 필요하지 않으며 인덱스 스캔만 필요합니다.

먼저 메인 쿼리에 대한 견적을 얻습니다.

SELECT count(*) AS ct              -- optional
     , min(id)  AS min_id
     , max(id)  AS max_id
     , max(id) - min(id) AS id_span
FROM   big;

은, 「유하 the the the the the」입니다.count(*)(큰 테이블용)위의 사양에 따라서는 필요 없습니다.전체 카운트를 대체하기 위한 견적은 거의 무료로 제공되므로 문제 없습니다.

SELECT (reltuples / relpages * (pg_relation_size(oid) / 8192))::bigint AS ct
FROM   pg_class
WHERE  oid = 'big'::regclass;  -- your table name

상세설명:

Postgre 테이블의 행 수를 빠르게 검출하는 방법SQL

ct보다 훨씬 작지 않다id_span쿼리는 다른 접근방식을 능가합니다.

WITH params AS (
   SELECT 1       AS min_id           -- minimum id <= current min id
        , 5100000 AS id_span          -- rounded up. (max_id - min_id + buffer)
    )
SELECT *
FROM  (
   SELECT p.min_id + trunc(random() * p.id_span)::integer AS id
   FROM   params p
        , generate_series(1, 1100) g  -- 1000 + buffer
   GROUP  BY 1                        -- trim duplicates
) r
JOIN   big USING (id)
LIMIT  1000;                          -- trim surplus

'난수'에서id공백이 있으므로 검색할 행의 수에 10%(공백이 쉽게 가려질 수 있음)를 추가합니다.
★★id는 우연히번될 수 단, 큰 에서는 거의 만),( ID 를 사용합니다).DISTINCT를 참조해 주세요.
id을 사용하다이것은 인덱스를 배치하면 매우 빠를 것입니다.
으로 잉여분을 iddups와 gaps에 의해 먹혀들지 않은 것.모든 행이 선택될 확률은 완전히 동일합니다.

쇼트 버전

이 조회를 단순화할 수 있습니다.위의 질문의 CTE는 교육적인 목적으로만 사용됩니다.

SELECT *
FROM  (
   SELECT DISTINCT 1 + trunc(random() * 5100000)::integer AS id
   FROM   generate_series(1, 1100) g
   ) r
JOIN   big USING (id)
LIMIT  1000;

rCTE로 개선

특히 격차와 견적에 대해 확신이 없는 경우.

WITH RECURSIVE random_pick AS (
   SELECT *
   FROM  (
      SELECT 1 + trunc(random() * 5100000)::int AS id
      FROM   generate_series(1, 1030)  -- 1000 + few percent - adapt to your needs
      LIMIT  1030                      -- hint for query planner
      ) r
   JOIN   big b USING (id)             -- eliminate miss

   UNION                               -- eliminate dupe
   SELECT b.*
   FROM  (
      SELECT 1 + trunc(random() * 5100000)::int AS id
      FROM   random_pick r             -- plus 3 percent - adapt to your needs
      LIMIT  999                       -- less than 1000, hint for query planner
      ) r
   JOIN   big b USING (id)             -- eliminate miss
   )
TABLE  random_pick
LIMIT  1000;  -- actual limit

기본 쿼리에서 더 적은 잉여로 작업할 수 있습니다.간격이 너무 많아 첫 번째 반복에서 충분한 행을 찾을 수 없는 경우 rCTE는 재귀 용어를 사용하여 계속 반복됩니다.ID 공간에 필요한 갭이 비교적 적거나 제한에 도달하기 전에 재귀가 고갈될 수 있습니다.그렇지 않으면 퍼포먼스를 최적화하기 위한 목적에 반하는 충분한 버퍼부터 시작해야 합니다.

되는 것은 .UNIONRCTE를 사용하다

깥 the theLIMITCTE를 사용하다

이 쿼리는 사용 가능한 인덱스를 사용하여 실제로 랜덤 행을 생성하고 제한을 충족할 때까지 중지하지 않도록 신중하게 작성되었습니다(재귀가 고갈되지 않는 한).만약 당신이 그것을 다시 쓰려고 한다면 여기에 많은 함정이 있다.

기능으로 줄이다

다양한 파라미터로 동일한 테이블을 반복적으로 사용하는 경우:

CREATE OR REPLACE FUNCTION f_random_sample(_limit int = 1000, _gaps real = 1.03)
  RETURNS SETOF big
  LANGUAGE plpgsql VOLATILE ROWS 1000 AS
$func$
DECLARE
   _surplus  int := _limit * _gaps;
   _estimate int := (           -- get current estimate from system
      SELECT (reltuples / relpages * (pg_relation_size(oid) / 8192))::bigint
      FROM   pg_class
      WHERE  oid = 'big'::regclass);
BEGIN
   RETURN QUERY
   WITH RECURSIVE random_pick AS (
      SELECT *
      FROM  (
         SELECT 1 + trunc(random() * _estimate)::int
         FROM   generate_series(1, _surplus) g
         LIMIT  _surplus           -- hint for query planner
         ) r (id)
      JOIN   big USING (id)        -- eliminate misses

      UNION                        -- eliminate dupes
      SELECT *
      FROM  (
         SELECT 1 + trunc(random() * _estimate)::int
         FROM   random_pick        -- just to make it recursive
         LIMIT  _limit             -- hint for query planner
         ) r (id)
      JOIN   big USING (id)        -- eliminate misses
   )
   TABLE  random_pick
   LIMIT  _limit;
END
$func$;

문의:

SELECT * FROM f_random_sample();
SELECT * FROM f_random_sample(500, 1.05);

범용 함수

고유 정수 열(일반적으로 PK)을 가진 모든 테이블에서 이 작업을 수행할 수 있습니다.테이블을 다형성 유형으로 전달하고 (선택사항) PK 열의 이름을 사용합니다.EXECUTE:

CREATE OR REPLACE FUNCTION f_random_sample(_tbl_type anyelement
                                         , _id text = 'id'
                                         , _limit int = 1000
                                         , _gaps real = 1.03)
  RETURNS SETOF anyelement
  LANGUAGE plpgsql VOLATILE ROWS 1000 AS
$func$
DECLARE
   -- safe syntax with schema & quotes where needed
   _tbl text := pg_typeof(_tbl_type)::text;
   _estimate int := (SELECT (reltuples / relpages
                          * (pg_relation_size(oid) / 8192))::bigint
                     FROM   pg_class  -- get current estimate from system
                     WHERE  oid = _tbl::regclass);
BEGIN
   RETURN QUERY EXECUTE format(
   $$
   WITH RECURSIVE random_pick AS (
      SELECT *
      FROM  (
         SELECT 1 + trunc(random() * $1)::int
         FROM   generate_series(1, $2) g
         LIMIT  $2                 -- hint for query planner
         ) r(%2$I)
      JOIN   %1$s USING (%2$I)     -- eliminate misses

      UNION                        -- eliminate dupes
      SELECT *
      FROM  (
         SELECT 1 + trunc(random() * $1)::int
         FROM   random_pick        -- just to make it recursive
         LIMIT  $3                 -- hint for query planner
         ) r(%2$I)
      JOIN   %1$s USING (%2$I)     -- eliminate misses
   )
   TABLE  random_pick
   LIMIT  $3;
   $$
 , _tbl, _id
   )
   USING _estimate              -- $1
       , (_limit * _gaps)::int  -- $2 ("surplus")
       , _limit                 -- $3
   ;
END
$func$;

디폴트 콜(중요!):

SELECT * FROM f_random_sample(null::big);  --!

또는 보다 구체적으로:

SELECT * FROM f_random_sample(null::"my_TABLE", 'oDD ID', 666, 1.15);

정적 버전과 거의 동일한 성능입니다.

가능한 대안

반복 콜에 대해 동일한 세트를 사용할 수 있는 경우(또한 반복 콜에 대해 이야기하고 있습니다), 위의 쿼리를 한 번 실행하여 결과를 테이블에 기록합니다.사용자는 번개 속도로 준임의 선택을 받는다.선택한 간격이나 이벤트에 따라 랜덤 선택을 새로 고칩니다.

Postgres 9.5 소개

는 퍼센티지입니다.매뉴얼:

BERNOULLI ★★★★★★★★★★★★★★★★★」SYSTEM샘플링 방식에서는 각각1개의 인수를 받아들입니다.이 인수는 샘플링할 테이블의 비율입니다.이 값은 0 ~100 의 퍼센티지로 표시됩니다.이 인수에는 임의의 것을 사용할 수 있습니다.real expressionvalue 。

과감하게 강조해 주세요.매우 빠르지만 결과가 무작위로 나온 것은 아닙니다.매뉴얼은 다음과 같습니다.

SYSTEM이 훨씬 .BERNOULLImethod는 작은 샘플링 퍼센티지가 지정된 경우이지만 클러스터링 효과의 결과로 덜 짧은 샘플이 테이블에 반환될 수 있습니다.

반환되는 행의 수는 크게 다를 수 있습니다.이 예에서 약 1000 행을 가져오려면 다음 절차를 수행합니다.

SELECT * FROM big TABLESAMPLE SYSTEM ((1000 * 100) / 5100000.0);

postgresql order by random" 행을 랜덤 순서로 선택합니다.

모든 행이 선택될 확률이 정확히 동일한지 확인하기 위해 테이블스캔을 수행하므로 모두 느립니다.

select your_columns from your_table ORDER BY random()

select * from 
  (select distinct your_columns from your_table) table_alias
ORDER BY random()

select your_columns from your_table ORDER BY random() limit 1

내에 몇 있는 `N`:

플로어 랜덤에 의한 오프셋은 상수 시간입니다.그러나 OFFSET이 진정한 랜덤 샘플을 생산하고 있는지 확신할 수 없습니다.'다음 묶음'을 얻어 테이블스캐닝함으로써 시뮬레이션을 하는 것입니다.이렇게 하면, 상기와는 전혀 다릅니다.

SELECT myid FROM mytable OFFSET floor(random() * N) LIMIT 1;

일정한 시간 Roll Select Random N 행을 주기적인 테이블 스캔과 함께 사용하여 랜덤을 절대적으로 확인합니다.

테이블이 클 경우 위의 테이블스캔은 쇼스토퍼로 종료까지 최대 5분이 소요됩니다.

할 수 .에 의해, 「Da Can」의 완전한 됩니다.이것에 의해, 완전한 랜덤 선택이 보증됩니다.O(1)야간 재인덱싱 테이블스캔을 제외하고 다른 랜덤 행을 수신하기 전에 유지보수가 완료될 때까지 기다려야 하는 고정 시간 속도.

--Create a demo table with lots of random nonuniform data, big_data 
--is your huge table you want to get random rows from in constant time. 
drop table if exists big_data;  
CREATE TABLE big_data (id serial unique, some_data text );  
CREATE INDEX ON big_data (id);  
--Fill it with a million rows which simulates your beautiful data:  
INSERT INTO big_data (some_data) SELECT md5(random()::text) AS some_data
FROM generate_series(1,10000000);
 
--This delete statement puts holes in your index
--making it NONuniformly distributed  
DELETE FROM big_data WHERE id IN (2, 4, 6, 7, 8); 
 
 
--Do the nightly maintenance task on a schedule at 1AM.
drop table if exists big_data_mapper; 
CREATE TABLE big_data_mapper (id serial, big_data_id int); 
CREATE INDEX ON big_data_mapper (id); 
CREATE INDEX ON big_data_mapper (big_data_id); 
INSERT INTO big_data_mapper(big_data_id) SELECT id FROM big_data ORDER BY id;
 
--We have to use a function because the big_data_mapper might be out-of-date
--in between nightly tasks, so to solve the problem of a missing row, 
--you try again until you succeed.  In the event the big_data_mapper 
--is broken, it tries 25 times then gives up and returns -1. 
CREATE or replace FUNCTION get_random_big_data_id()  
RETURNS int language plpgsql AS $$ 
declare  
    response int; 
BEGIN
    --Loop is required because big_data_mapper could be old
    --Keep rolling the dice until you find one that hits.
    for counter in 1..25 loop
        SELECT big_data_id 
        FROM big_data_mapper OFFSET floor(random() * ( 
            select max(id) biggest_value from big_data_mapper 
            )
        ) LIMIT 1 into response;
        if response is not null then
            return response;
        end if;
    end loop;
    return -1;
END;  
$$; 
 
--get a random big_data id in constant time: 
select get_random_big_data_id(); 
 
--Get 1 random row from big_data table in constant time: 
select * from big_data where id in ( 
    select get_random_big_data_id() from big_data limit 1 
); 
┌─────────┬──────────────────────────────────┐ 
│   id    │            some_data             │ 
├─────────┼──────────────────────────────────┤ 
│ 8732674 │ f8d75be30eff0a973923c413eaf57ac0 │ 
└─────────┴──────────────────────────────────┘ 

--Get 4 random rows from big_data in constant time: 
select * from big_data where id in ( 
    select get_random_big_data_id() from big_data limit 3 
);
┌─────────┬──────────────────────────────────┐ 
│   id    │            some_data             │ 
├─────────┼──────────────────────────────────┤ 
│ 2722848 │ fab6a7d76d9637af89b155f2e614fc96 │ 
│ 8732674 │ f8d75be30eff0a973923c413eaf57ac0 │ 
│ 9475611 │ 36ac3eeb6b3e171cacd475e7f9dade56 │ 
└─────────┴──────────────────────────────────┘ 

--Test what happens when big_data_mapper stops receiving 
--nightly reindexing.
delete from big_data_mapper where 1=1; 
select get_random_big_data_id();   --It tries 25 times, and returns -1
                                   --which means wait N minutes and try again.

제품명 : https://www.gab.lc/articles/bigdata_postgresql_order_by_random

또는 위의 모든 것이 너무 많은 작업인 경우.

은 큰 에 ''이라는 을 새로 입니다.big_data.mapper_int고유한 인덱스를 사용하여 null이 되지 않도록 합니다.매일 밤 열이 1 ~ max(n) 사이의 고유한 정수로 재설정됩니다."아무리 정수를 " 를 선택합니다.0 ★★★★★★★★★★★★★★★★★」max(id) 행을 매퍼 인트해당 ID의 행이 없는 경우, 행이 재색인된 후 변경되었기 때문에 다른 임의의 행을 선택합니다. max + 1big_data.mapper_int로 합니다.

또는 TableSample to rescue:

version postgresql이 > 9.5그러면 테이블샘플은 무거운 테이블캔 없이 일정한 시간 랜덤 표본을 수행할 수 있습니다.https://wiki.postgresql.org/wiki/TABLESAMPLE_Implementation

--Select 1 percent of rows from yourtable, 
--display the first 100 rows, order by column a_column
select * from yourtable TABLESAMPLE SYSTEM (1)
order by a_column 
limit 100;

Table Sample은 시간이 걸리고 마음에 들지 않지만 랜덤으로 주문하는 것보다 더 빠른 작업을 백그라운드에서 수행하고 있습니다.좋아, 빠르거나 싸거나, 이 일에는 아무 거나 골라봐.

포스트그레부터SQL 9.5에서는 테이블에서 랜덤 요소를 가져오는 새로운 구문이 있습니다.

SELECT * FROM mytable TABLESAMPLE SYSTEM (5);

에서는 5를 5%의 비율로 .mytable.

상세한 것에 대하여는, http://www.postgresql.org/docs/current/static/sql-select.html 를 참조해 주세요.

ORDER BY가 있는 쪽이 느린 쪽이 될 것입니다.

select * from table where random() < 0.01;레코드로 기록하여 랜덤으로 필터링할지 여부를 결정합니다.은 ★★★★★★★★★★★★★★★★★★.O(N)각 레코드를 한 번만 확인하면 되기 때문입니다.

select * from table order by random() limit 1000;테이블 전체를 정렬하고 첫 번째 1000을 선택합니다.무대 뒤의 부두 마술은 차치하고 순서는O(N * log N).

의 random() < 0.01하나는 출력 레코드의 개수가 다양하다는 것입니다.

데이터 세트를 랜덤으로 정렬하는 것보다 더 나은 방법이 있습니다.Fisher-Yates Shuffle, 에서 상영되는O(N)SQL Shuffle(셔플) - Shuffle(슈플) - Shuffle(셔플) - Shuffle(셔플) - Shuffle(셔플) - Shuffle(셔플) - Suffle(셔플).

select * from table order by random() limit 1000;

필요한 행의 수를 알고 있는 경우는, 체크 아웃 해 주세요.

tm_system_rows

module은 SELECT 명령어의 TABLESAMPLE 절에서 사용할 수 있는 테이블샘플 방식 SYSTEM_ROWS를 제공합니다.

이 테이블 샘플링 방식에서는 읽을 최대 행 수인 단일 정수 인수를 사용할 수 있습니다.테이블에 충분한 행이 포함되어 있지 않은 경우(이 경우 테이블 전체가 선택되지 않는 한) 결과 샘플에는 항상 동일한 수의 행이 포함됩니다.내장된 SYSTEM 샘플링 방법과 마찬가지로 SYSTEM_ROWS는 블록 레벨의 샘플링을 수행합니다.따라서 샘플이 완전히 랜덤하지는 않지만 특히 소수의 행만 요청될 경우 클러스터링 효과를 얻을 수 있습니다.

먼저 확장 버전을 설치합니다.

CREATE EXTENSION tsm_system_rows;

그럼 당신의 질문은

SELECT *
FROM table
TABLESAMPLE SYSTEM_ROWS(1000);

여기 나에게 맞는 결정이 있다.이해하고 실행하는 것은 매우 간단하다고 생각합니다.

SELECT 
  field_1, 
  field_2, 
  field_2, 
  random() as ordering
FROM 
  big_table
WHERE 
  some_conditions
ORDER BY
  ordering 
LIMIT 1000;

한 것을 하시면 됩니다.offset derived from from에서 count.

select * from table_name limit 1
offset floor(random() * (select count(*) from table_name));

제 경험에서 얻은 교훈은 다음과 같습니다.

offset floor(random() * N) limit 1 order by random() limit 1.

는 ★★★★★★★★★★★★★★★★★★★★★★★★★offsetPostgres에서 정렬하는 시간을 절약할 수 있기 때문에 접근 방식이 더 빠를 것입니다.알고보니 아니었네요

포스트그레어에서 가장 간단하고 좋은 방법은SQL:

SELECT * FROM tableName ORDER BY random() LIMIT 1

Erwin Brandstetter가 개략적으로 설명한 구체화된 견해 "가능한 대안"의 변형은 가능합니다.

예를 들어, 반환되는 랜덤화된 값에 중복되지 않도록 합니다.예를 들어 한 번만 사용할 수 있는 짧은 코드를 생성하는 경우가 있습니다.

되지 않은)값행이 " 어떤되지 않는지를 ( 「」)을 가진 하는 것만으로 할 수 여기에서는 이름을 사용하여 부울 열을 만드는 것만으로 단순하게 유지합니다.used.

이것이 입력 테이블이라고 가정합니다(솔루션에는 영향을 주지 않기 때문에 추가 열이 추가될 수 있습니다.

id_values  id  |   used
           ----+--------
           1   |   FALSE
           2   |   FALSE
           3   |   FALSE
           4   |   FALSE
           5   |   FALSE
           ...

를 입력하다ID_VALUES테이블로 이동합니다.으로 Erwin의 Erwin을 .ID_VALUES1번:

CREATE MATERIALIZED VIEW id_values_randomized AS
  SELECT id
  FROM id_values
  ORDER BY random();

구체화된 뷰에는 사용된 열이 포함되어 있지 않습니다. 이치 이 필요가 없습니다.id_valuestable.syslog를 클릭합니다.

값을 취득 , UPDATE-RETURNING 「UPDATE-RETURNING」, 「UPDATE-RETURNING」를 합니다.id_values, 선선택사항id_values부에서id_values_randomized가입하여 관련 가능성을 얻기 위해 원하는 기준을 적용하기 위해 원하는 기준을 적용합니다.원하는 기준을 적용하여 관련 가능성만 얻을 수 있습니다.예를 들어:예를 들어 다음과 같습니다.

UPDATE id_values
SET used = TRUE
WHERE id_values.id IN 
  (SELECT i.id
    FROM id_values_randomized r INNER JOIN id_values i ON i.id = r.id
    WHERE (NOT i.used)
    LIMIT 1)
RETURNING id;

꾸 변경 사항 변경LIMIT필요에 따라 여러 랜덤 값을 필요로 한다면 요 에 라 러 의 덤 이 요 경 우 경 변 as 필 한 if necessary 값 --, a random valuesLIMIT로로 합니다.n여기서 n은 필요한 값의 수입니다.

가 있는 id_valuesUPDATE - Returning update update update update update update update update update update update update update update update update update update update update update update update update update update update update update update update update update update 。1개의 데이터베이스 라운드 트립을 사용하여 랜덤화된 값을 반환합니다."적격" 행의 기준은 필요한 만큼 복잡할 수 있습니다.할 수 .id_values테이블은 언제든지 사용할 수 있으며 구체화된 뷰를 새로 고치는 즉시 애플리케이션에 액세스할 수 있습니다(비수기 시간대에 실행할 수 있습니다). 및 새가 ID에 됩니다.id_values테이블을 사용할 수 있어야 합니다.

하나를 더합니다.r 「」를 사용해 주세요.serial.r.

200,하면, 숫자 「 200 200,000」이 됩니다.n0 < '0' < '0'n<= 200,000.

「」가 붙은 합니다.r > n 분류하다.ASC★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

코드:

select * from YOUR_TABLE 
where r > (
    select (
        select reltuples::bigint AS estimate
        from   pg_class
        where  oid = 'public.YOUR_TABLE'::regclass) * random()
    )
order by r asc limit(1);

코드는 자명합니다.가운데 서브쿼리는 https://stackoverflow.com/a/7945274/1271094 에서 테이블 행 수를 빠르게 추정하기 위해 사용합니다.

에서는, 다시 .n> > > > > > > > > > > > > > > > > > > > > > > >

파티에 조금 늦은 건 알지만 방금 pg_sample이라는 멋진 도구를 찾았어요.

pg_sample- 더큰 데이터 "SQL" "SQL" "SQL" "SQL" "S"

350만 줄 데이터베이스로 해봤는데 너무 빨라서 랜덤은 잘 모르겠어요.

./pg_sample --limit="small_table = *" --limit="large_table = 100000" -U postgres source_db | psql -U postgres target_db

언급URL : https://stackoverflow.com/questions/8674718/best-way-to-select-random-rows-postgresql

'prosource' 카테고리의 다른 글

C# 어플리케이션의 리소스와 임베디드 자원의 차이점은 무엇입니까? (0)	2023.04.23
Git과 Dropbox를 함께 사용하는 방법은? (0)	2023.04.23
파이어폭스 브라우저에서 javascript에서 탁월하도록 동적 html 테이블을 내보냅니다. (0)	2023.04.18
BASH는 1개를 제외한 모든 파일을 복사합니다. (0)	2023.04.18
Swift에서 변수의 유형 또는 클래스를 인쇄하려면 어떻게 해야 합니까? (0)	2023.04.18

현재글랜덤 행을 선택하는 가장 좋은 방법 PostgreSQL

각종 프로그래밍 정보를 다루는 블로그입니다.

WPF, WordPress, Excel, Ajax, PowerShell, AngularJS, GIT, jQuery, mariaDB, spring-boot, oracle, MySQL, reactjs, Python, JSON, MongoDB, C, sql-server, TypeScript, ASP.NET,

Today :
Yesterday :

probook

랜덤 행을 선택하는 가장 좋은 방법 PostgreSQL

랜덤 행을 선택하는 가장 좋은 방법 PostgreSQL

고속화 방법

쇼트 버전

rCTE로 개선

기능으로 줄이다

범용 함수

가능한 대안

Postgres 9.5 소개

postgresql order by random" 행을 랜덤 순서로 선택합니다.

내에 몇 있는 `N`:

일정한 시간 Roll Select Random N 행을 주기적인 테이블 스캔과 함께 사용하여 랜덤을 절대적으로 확인합니다.

또는 위의 모든 것이 너무 많은 작업인 경우.

또는 TableSample to rescue:

tm_system_rows

'prosource' 카테고리의 다른 글

'prosource'의 다른글

티스토리툴바

« 2024/09 »
일	월	화	수	목	금	토
1	2	3	4	5	6	7
8	9	10	11	12	13	14
15	16	17	18	19	20	21
22	23	24	25	26	27	28
29	30

랜덤 행을 선택하는 가장 좋은 방법 PostgreSQL

랜덤 행을 선택하는 가장 좋은 방법 PostgreSQL

고속화 방법

쇼트 버전

rCTE로 개선

기능으로 줄이다

범용 함수

가능한 대안

Postgres 9.5 소개

postgresql order by random" 행을 랜덤 순서로 선택합니다.

내에 몇 있는 N:

일정한 시간 Roll Select Random N 행을 주기적인 테이블 스캔과 함께 사용하여 랜덤을 절대적으로 확인합니다.

또는 위의 모든 것이 너무 많은 작업인 경우.

또는 TableSample to rescue:

tm_system_rows

'prosource' 카테고리의 다른 글

'prosource'의 다른글

관련글

티스토리툴바

내에 몇 있는 `N`: