Popola dati casuali da un'altra tabella

CONFIGURAZIONE

Iniziamo assumendo che le tabelle e i dati siano i seguenti. Nota che presumo che dataset1 ha una chiave primaria (può essere composta, ma, per semplicità, rendiamola intera):

CREATE TABLE dataset1
(
     id INTEGER PRIMARY KEY,
     column4 TEXT
) ;

CREATE TABLE dataset2
(
    column1 TEXT
) ;
 

Riempiamo entrambe le tabelle con dati di esempio

INSERT INTO dataset1
    (id, column4)
SELECT
    i, 'column 4 for id ' || i
FROM
    generate_series(101, 120) AS s(i);

INSERT INTO dataset2
    (column1)
SELECT
    'SOMETHING ' || i
FROM 
    generate_series (1001, 1020) AS s(i) ;
 

Controllo di integrità:

SELECT count(DISTINCT column4) FROM dataset1 ;
 

| contare || ----:|| 20 |

Caso 1:numero di righe nel set di dati1 <=righe nel set di dati2

Eseguiremo un rimescolamento completo. I valori del set di dati2 verranno utilizzati una volta e non più di una volta.

SPIEGAZIONE

Per effettuare un aggiornamento che rimescoli tutti i valori da column4 in modo casuale, abbiamo bisogno di alcuni passaggi intermedi.

Innanzitutto, per il dataset1 , dobbiamo creare un elenco (relazione) di tuple (id, rn) , sono solo:

(id_1,   1),
(id_2,   2),
(id_3,   3),
...
(id_20, 20)
 

Dove id_1 , ..., id_20 sono gli ID presenti su dataset1 .Possono essere di qualsiasi tipo, non devono essere necessariamente consecutive e possono essere composte.

Per il dataset2 , dobbiamo creare un altro elenco di (column_1,rn) , che assomiglia a:

(column1_1,  17),
(column1_2,   3),
(column1_3,  11),
...
(column1_20, 15)
 

In questo caso, la seconda colonna contiene tutti i valori 1 .. 20, ma mescolati.

Una volta che abbiamo le due relazioni, JOIN loro ON ... rn . Questo, in pratica, produce ancora un altro elenco di tuple con (id, column1) , dove l'accoppiamento è stato eseguito in modo casuale. Usiamo queste coppie per aggiornare dataset1 .

LA VERA DOMANDA

Tutto questo può essere fatto (chiaramente, spero) usando alcuni CTE (WITH dichiarazione) per mantenere le relazioni intermedie:

WITH original_keys AS
(
    -- This creates tuples (id, rn), 
    -- where rn increases from 1 to number or rows
    SELECT 
        id, 
        row_number() OVER  () AS rn
    FROM 
        dataset1
)
, shuffled_data AS
(
    -- This creates tuples (column1, rn)
    -- where rn moves between 1 and number of rows, but is randomly shuffled
    SELECT 
        column1,
        -- The next statement is what *shuffles* all the data
        row_number() OVER  (ORDER BY random()) AS rn
    FROM 
        dataset2
)
-- You update your dataset1
-- with the shuffled data, linking back to the original keys
UPDATE
    dataset1
SET
    column4 = shuffled_data.column1
FROM
    shuffled_data
    JOIN original_keys ON original_keys.rn = shuffled_data.rn
WHERE
    dataset1.id = original_keys.id ;
 

Nota che il trucco viene eseguita per mezzo di:

row_number() OVER (ORDER BY random()) AS rn
 

Il row_number() funzione finestra che produce tanti numeri consecutivi quante sono le righe, a partire da 1. Questi numeri vengono mescolati casualmente perché OVER La clausola prende tutti i dati e li ordina casualmente.

CONTROLLI

Possiamo ricontrollare:

SELECT count(DISTINCT column4) FROM dataset1 ;
 

| contare || ----:|| 20 |

SELECT * FROM dataset1 ;
 

UPDATE
    dataset1
SET
    column4 = shuffled_data.column1
FROM
    (SELECT 
        column1,
        row_number() OVER  (ORDER BY random()) AS rn
    FROM 
        dataset2
    ) AS shuffled_data
    JOIN 
    (SELECT 
        id, 
        row_number() OVER  () AS rn
    FROM 
        dataset1
    ) AS original_keys ON original_keys.rn = shuffled_data.rn
WHERE
    dataset1.id = original_keys.id ;
 

SELECT * FROM dataset1;
 

CREATE FUNCTION random_column1() 
    RETURNS TEXT
    VOLATILE      -- important!
    LANGUAGE SQL
AS
$$
    SELECT
        column1
    FROM
        dataset2
    ORDER BY
        random()
    LIMIT
        1 ;
$$ ;
 

UPDATE
    dataset1
SET
    column4 = random_column1();