¿Cómo se crea una cadena aleatoria que sea adecuada para una ID de sesión en PostgreSQL?

Me gustaría hacer una cadena aleatoria para usar en la verificación de la sesión usando PostgreSQL. Sé que puedo obtener un número aleatorio con SELECT random(), así que lo intenté SELECT md5(random()), pero no funciona. ¿Cómo puedo hacer esto?

Sugeriría esta sencilla solución:

Esta es una función bastante simple que devuelve una cadena aleatoria de la longitud dada:

Create or replace function random_string(length integer) returns text as
$$
declare
  chars text[] := '{0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z}';
  result text := '';
  i integer := 0;
begin
  if length < 0 then
    raise exception 'Given length cannot be less than 0';
  end if;
  for i in 1..length loop
    result := result || chars[1+random()*(array_length(chars, 1)-1)];
  end loop;
  return result;
end;
$$ language plpgsql;

Y el uso:

select random_string(15);

Salida de ejemplo:

select random_string(15) from generate_series(1,15);

  random_string
-----------------
 5emZKMYUB9C2vT6
 3i4JfnKraWduR0J
 R5xEfIZEllNynJR
 tMAxfql0iMWMIxM
 aPSYd7pDLcyibl2
 3fPDd54P5llb84Z
 VeywDb53oQfn9GZ
 BJGaXtfaIkN4NV8
 w1mvxzX33NTiBby
 knI1Opt4QDonHCJ
 P9KC5IBcLE0owBQ
 vvEEwc4qfV4VJLg
 ckpwwuG8YbMYQJi
 rFf6TchXTO3XsLs
 axdQvaLBitm6SDP
(15 rows)

Puede arreglar su intento inicial de esta manera:

SELECT md5(random()::text);

Mucho más simple que algunas de las otras sugerencias. :-)

Basándose en la solución de Marcin, podría hacer esto para usar un alfabeto arbitrario (en este caso, los 62 caracteres alfanuméricos ASCII):

SELECT array_to_string(array 
       ( 
              select substr('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', trunc(random() * 62)::integer + 1, 1)
              FROM   generate_series(1, 12)), '');

Puede obtener 128 bits aleatorios de un UUID. Este es el método para hacer el trabajo en PostgreSQL moderno.

CREATE EXTENSION pgcrypto;
SELECT gen_random_uuid();

           gen_random_uuid            
--------------------------------------
 202ed325-b8b1-477f-8494-02475973a28f

También puede valer la pena leer los documentos sobre UUID

El tipo de datos uuid almacena identificadores únicos universales (UUID) como se define en RFC 4122, ISO / IEC 9834-8: 2005 y estándares relacionados. (Algunos sistemas se refieren a este tipo de datos como un identificador único global, o GUID, en su lugar). Este identificador es una cantidad de 128 bits que se genera mediante un algoritmo elegido para que sea muy poco probable que alguien más genere el mismo identificador. en el universo conocido utilizando el mismo algoritmo. Por lo tanto, para los sistemas distribuidos, estos identificadores brindan una mejor garantía de unicidad que los generadores de secuencias, que son únicos dentro de una sola base de datos.

¿Qué tan rara es una colisión con UUID o adivinable? Asumiendo que son aleatorios

Se necesitarían generar alrededor de 100 billones de UUID de la versión 4 para tener una probabilidad de 1 entre mil millones de un solo duplicado ("colisión"). La probabilidad de una colisión aumenta al 50% solo después de que se hayan generado 261 UUID (2,3 x 10 ^ 18 o 2,3 quintillones). Relacionando estos números con las bases de datos, y considerando la cuestión de si la probabilidad de una colisión de UUID de la versión 4 es insignificante, considere un archivo que contenga 2,3 trillones de UUID de la versión 4, con un 50% de probabilidad de contener una colisión de UUID. Sería de 36 exabytes de tamaño, asumiendo que no hay otros datos o gastos generales, miles de veces más grandes que las bases de datos más grandes que existen actualmente, que son del orden de los petabytes. A una tasa de mil millones de UUID generados por segundo, se necesitarían 73 años para generar los UUID para el archivo. También requeriría alrededor de 3. 6 millones de discos duros de 10 terabytes o cartuchos de cinta para almacenarlos, suponiendo que no haya copias de seguridad ni redundancia. Leer el archivo a una tasa de transferencia típica de "disco a búfer" de 1 gigabit por segundo requeriría más de 3000 años para un solo procesador. Dado que la tasa de error de lectura irrecuperable de las unidades es de 1 bit por cada 1018 bits leídos, en el mejor de los casos, mientras que el archivo contendría aproximadamente 1020 bits, solo leer el archivo una vez de un extremo a otro resultaría, al menos, en aproximadamente 100 veces más errores. leer UUID que los duplicados. Los errores de almacenamiento, red, alimentación y otros errores de hardware y software serían sin duda miles de veces más frecuentes que los problemas de duplicación de UUID. La tasa de transferencia de 1 gigabit por segundo requeriría más de 3000 años para un solo procesador. Dado que la tasa de error de lectura irrecuperable de las unidades es de 1 bit por cada 1018 bits leídos, en el mejor de los casos, mientras que el archivo contendría aproximadamente 1020 bits, solo leer el archivo una vez de un extremo a otro resultaría, al menos, en aproximadamente 100 veces más errores. leer UUID que los duplicados. Los errores de almacenamiento, red, alimentación y otros errores de hardware y software serían sin duda miles de veces más frecuentes que los problemas de duplicación de UUID. La tasa de transferencia de 1 gigabit por segundo requeriría más de 3000 años para un solo procesador. Dado que la tasa de error de lectura irrecuperable de las unidades es de 1 bit por cada 1018 bits leídos, en el mejor de los casos, mientras que el archivo contendría aproximadamente 1020 bits, solo leer el archivo una vez de un extremo a otro resultaría, al menos, en aproximadamente 100 veces más errores. leer UUID que los duplicados. Los errores de almacenamiento, red, alimentación y otros errores de hardware y software serían sin duda miles de veces más frecuentes que los problemas de duplicación de UUID.

fuente: wikipedia

En resumen,

• UUID está estandarizado.
• gen_random_uuid()son 128 bits aleatorios almacenados en 128 bits (2 ** 128 combinaciones). 0-desperdicio.
• random() solo genera 52 bits aleatorios en PostgreSQL (2 ** 52 combinaciones).
• md5()almacenado como UUID es de 128 bits, pero solo puede ser tan aleatorio como su entrada ( 52 bits si se usarandom() )
• md5()almacenado como texto tiene 288 bits, pero solo puede ser tan aleatorio como su entrada ( 52 bits si se usarandom() ), más del doble del tamaño de un UUID y una fracción de la aleatoriedad)
• md5() como hash, se puede optimizar tanto que no hace mucho.
• UUID es muy eficiente para el almacenamiento: PostgreSQL proporciona un tipo de exactamente 128 bits. A diferencia de texty varchar, etc., que se almacenan como varlenaque tienen gastos generales para la longitud de la cadena.
• El UUID ingenioso de PostgreSQL viene con algunos operadores, conversiones y características predeterminados.

Estuve jugando con PostgreSQL recientemente, y creo que encontré una solución un poco mejor, usando solo métodos incorporados de PostgreSQL, sin pl / pgsql. La única limitación es que actualmente genera solo cadenas UPCASE, o números, o cadenas en minúsculas.

template1=> SELECT array_to_string(ARRAY(SELECT chr((65 + round(random() * 25)) :: integer) FROM generate_series(1,12)), '');
 array_to_string
-----------------
 TFBEGODDVTDM

template1=> SELECT array_to_string(ARRAY(SELECT chr((48 + round(random() * 9)) :: integer) FROM generate_series(1,12)), '');
 array_to_string
-----------------
 868778103681

El segundo argumento del generate_seriesmétodo dicta la longitud de la cadena.

¡Utilice string_agg!

SELECT string_agg (substr('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', ceil (random() * 62)::integer, 1), '')
FROM   generate_series(1, 45);

Estoy usando esto con MD5 para generar un UUID también. Solo quiero un valor aleatorio con más bits que un random ()entero.

Si bien no está activo de forma predeterminada, puede activar una de las extensiones principales:

CREATE EXTENSION IF NOT EXISTS pgcrypto;

Entonces su declaración se convierte en una simple llamada a gen_salt () que genera una cadena aleatoria:

select gen_salt('md5') from generate_series(1,4);

 gen_salt
-----------
$1$M.QRlF4U
$1$cv7bNJDM
$1$av34779p
$1$ZQkrCXHD

El número inicial es un identificador de hash. Hay varios algoritmos disponibles, cada uno con su propio identificador:

• md5: $ 1 $
• bf: $ 2a $ 06 $
• des: sin identificador
• xdes: _J9 ..

Más información sobre extensiones:

• pgCrypto: http://www.postgresql.org/docs/9.2/static/pgcrypto.html
• Extensiones incluidas: http://www.postgresql.org/docs/9.2/static/contrib.html

EDITAR

Como lo indica Evan Carrol, a partir de la v9.4 puede usar gen_random_uuid()

http://www.postgresql.org/docs/9.4/static/pgcrypto.html

No creo que esté buscando una cadena aleatoria per se. Lo que necesitaría para la verificación de la sesión es una cadena que esté garantizada como única. ¿Almacena información de verificación de sesión para auditar? En ese caso, necesita que la cadena sea única entre sesiones. Conozco dos enfoques bastante simples:

1. Usa una secuencia. Bueno para usar en una sola base de datos.
2. Utilice un UUID. Universalmente único, muy bueno también en entornos distribuidos.

Se garantiza que los UUID son únicos en virtud de su algoritmo de generación; de hecho, es extremadamente improbable que genere dos números idénticos en cualquier máquina, en cualquier momento (tenga en cuenta que esto es mucho más fuerte que en cadenas aleatorias, que tienen una periodicidad mucho menor que los UUID).

Debe cargar la extensión uuid-ossp para usar UUID. Una vez instalado, llame a cualquiera de las funciones uuid_generate_vXXX () disponibles en sus llamadas SELECT, INSERT o UPDATE. El tipo uuid es un número de 16 bytes, pero también tiene una representación de cadena.

El parámetro INTEGER define la longitud de la cadena. Garantizado para cubrir los 62 caracteres alfanuméricos con la misma probabilidad (a diferencia de otras soluciones que flotan en Internet).

CREATE OR REPLACE FUNCTION random_string(INTEGER)
RETURNS TEXT AS
$BODY$
SELECT array_to_string(
    ARRAY (
        SELECT substring(
            '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
            FROM (ceil(random()*62))::int FOR 1
        )
        FROM generate_series(1, $1)
    ), 
    ''
)
$BODY$
LANGUAGE sql VOLATILE;

@Kavius ​​recomendó usar pgcrypto, pero en lugar de gen_salt, ¿de qué gen_random_bytes? ¿Y qué tal en sha512lugar de md5?

create extension if not exists pgcrypto;
select digest(gen_random_bytes(1024), 'sha512');

Documentos:

F.25.5. Funciones de datos aleatorios

gen_random_bytes (número entero) devuelve bytea

Devuelve el recuento de bytes aleatorios criptográficamente fuertes. Se pueden extraer como máximo 1024 bytes a la vez. Esto es para evitar agotar el grupo de generadores de aleatoriedad.

select * from md5(to_char(random(), '0.9999999999999999'));

select encode(decode(md5(random()::text), 'hex')||decode(md5(random()::text), 'hex'), 'base64')