Generazione di una stringa di 8 caratteri casuale e univoca utilizzando MySQL

Sto lavorando a un gioco che coinvolge i veicoli a un certo punto. Ho una tabella MySQL denominata "veicoli" contenente i dati sui veicoli, inclusa la colonna "targa" che memorizza le targhe dei veicoli.

Ora arriva la parte con cui ho problemi. Devo trovare una targa inutilizzata prima di creare un nuovo veicolo: dovrebbe essere una stringa casuale di 8 caratteri alfanumerici. Il modo in cui ho ottenuto ciò è stato utilizzare un ciclo while in Lua, che è il linguaggio in cui sto programmando, per generare stringhe e interrogare il DB per vedere se viene utilizzato. Tuttavia, poiché il numero di veicoli aumenta, mi aspetto che questo diventi ancora più inefficiente di quanto lo sia adesso. Pertanto, ho deciso di provare a risolvere questo problema utilizzando una query MySQL.

La query di cui ho bisogno dovrebbe semplicemente generare una stringa alfanumerica di 8 caratteri che non è già nella tabella. Ho pensato di nuovo all'approccio del ciclo di generazione e verifica, ma non sto limitando questa domanda a questo solo nel caso in cui ce ne sia uno più efficiente. Sono stato in grado di generare stringhe definendo una stringa contenente tutti i caratteri consentiti e inserendola in modo casuale come sottostringa e nient'altro.

Qualsiasi aiuto è apprezzato.

Questo problema consiste in due sotto-problemi molto diversi:

• la stringa deve essere apparentemente casuale
• la stringa deve essere univoca

Mentre la casualità è abbastanza facilmente raggiungibile, l'unicità senza un ciclo di ripetizione non lo è. Questo ci porta a concentrarci prima sull'unicità. L'unicità non casuale può essere banalmente ottenuta con AUTO_INCREMENT. Quindi usare una trasformazione pseudo-casuale che preserva l'unicità andrebbe bene:

• Hash è stato suggerito da @paul
• Anche la crittografia AES si adatta
• Ma ce n'è uno carino: RAND(N)se stesso!

È garantita una sequenza di numeri casuali creati dallo stesso seme

• riproducibile
• diverso per le prime 8 iterazioni
• se il seme è un INT32

Quindi usiamo l'approccio di @ AndreyVolk o di @ GordonLinoff, ma con un seeded RAND :

ad esempio, Assumin idè una AUTO_INCREMENTcolonna:

INSERT INTO vehicles VALUES (blah); -- leaving out the number plate
SELECT @lid:=LAST_INSERT_ID();
UPDATE vehicles SET numberplate=concat(
  substring('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', rand(@seed:=round(rand(@lid)*4294967296))*36+1, 1),
  substring('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', rand(@seed:=round(rand(@seed)*4294967296))*36+1, 1),
  substring('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', rand(@seed:=round(rand(@seed)*4294967296))*36+1, 1),
  substring('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', rand(@seed:=round(rand(@seed)*4294967296))*36+1, 1),
  substring('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', rand(@seed:=round(rand(@seed)*4294967296))*36+1, 1),
  substring('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', rand(@seed:=round(rand(@seed)*4294967296))*36+1, 1),
  substring('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', rand(@seed:=round(rand(@seed)*4294967296))*36+1, 1),
  substring('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', rand(@seed)*36+1, 1)
)
WHERE id=@lid;

Come ho affermato nel mio commento, non mi preoccuperei della probabilità di collisione. Genera semplicemente una stringa casuale e controlla se esiste. In tal caso, riprova e non dovresti aver bisogno di farlo più di un paio di volte a meno che tu non abbia già assegnato un numero enorme di piatti.

Un'altra soluzione per generare una stringa pseudo-casuale lunga 8 caratteri in puro (My) SQL:

SELECT LEFT(UUID(), 8);

Puoi provare quanto segue (pseudo-codice):

DO 
    SELECT LEFT(UUID(), 8) INTO @plate;
    INSERT INTO plates (@plate);
WHILE there_is_a_unique_constraint_violation
-- @plate is your newly assigned plate number

Dato che questo post ha ricevuto un livello di attenzione inaspettato, lasciatemi evidenziare il commento di ADTC : il pezzo di codice sopra è abbastanza stupido e produce cifre sequenziali.

Per una casualità leggermente meno stupida prova invece qualcosa di simile:

SELECT LEFT(MD5(RAND()), 8)

E per una vera casualità (crittograficamente sicura), usa RANDOM_BYTES()invece di RAND()(ma poi prenderei in considerazione di spostare questa logica fino al livello dell'applicazione).

Che ne dici di calcolare l'hash MD5 (o altro) di numeri interi sequenziali, quindi prendere i primi 8 caratteri.

vale a dire

MD5(1) = c4ca4238a0b923820dcc509a6f75849b => c4ca4238
MD5(2) = c81e728d9d4c2f636f067f89cc14862c => c81e728d
MD5(3) = eccbc87e4b5ce2fe28308fd9f2a7baf3 => eccbc87e

eccetera.

avvertimento: non ho idea di quanti potresti allocare prima di una collisione (ma sarebbe un valore noto e costante).

modifica: questa è ora una vecchia risposta, ma l'ho vista di nuovo con il tempo sulle mie mani, quindi, dall'osservazione ...

Probabilità di tutti i numeri = 2,35%

Probabilità di tutte le lettere = 0,05%

Prima collisione quando MD5 (82945) = "7b763dcb ..." (stesso risultato di MD5 (25302))

Crea una stringa casuale

Ecco una funzione MySQL per creare una stringa casuale di una determinata lunghezza.

DELIMITER $$

CREATE DEFINER=`root`@`%` FUNCTION `RandString`(length SMALLINT(3)) RETURNS varchar(100) CHARSET utf8
begin
    SET @returnStr = '';
    SET @allowedChars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
    SET @i = 0;

    WHILE (@i < length) DO
        SET @returnStr = CONCAT(@returnStr, substring(@allowedChars, FLOOR(RAND() * LENGTH(@allowedChars) + 1), 1));
        SET @i = @i + 1;
    END WHILE;

    RETURN @returnStr;
END

Utilizzo SELECT RANDSTRING(8)per restituire una stringa di 8 caratteri.

Puoi personalizzare il file @allowedChars.

L'unicità non è garantita: come vedrai nei commenti ad altre soluzioni, questo non è possibile. Invece dovrai generare una stringa, controllare se è già in uso e riprovare se lo è.

Controlla se la stringa casuale è già in uso

Se vogliamo mantenere il codice di controllo delle collisioni fuori dall'app, possiamo creare un trigger:

DELIMITER $$

CREATE TRIGGER Vehicle_beforeInsert
  BEFORE INSERT ON `Vehicle`
  FOR EACH ROW
  BEGIN
    SET @vehicleId = 1;
    WHILE (@vehicleId IS NOT NULL) DO 
      SET NEW.plate = RANDSTRING(8);
      SET @vehicleId = (SELECT id FROM `Vehicle` WHERE `plate` = NEW.plate);
    END WHILE;
  END;$$
DELIMITER ;

Ecco un modo, utilizzando i caratteri alfabetici come caratteri validi:

select concat(substring('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', rand()*36+1, 1),
              substring('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', rand()*36+1, 1),
              substring('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', rand()*36+1, 1),
              substring('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', rand()*36+1, 1),
              substring('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', rand()*36+1, 1),
              substring('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', rand()*36+1, 1),
              substring('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', rand()*36+1, 1),
              substring('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', rand()*36+1, 1)
             ) as LicensePlaceNumber;

Nota non vi è alcuna garanzia di unicità. Dovrai verificarlo separatamente.

Ecco un altro metodo per generare una stringa casuale:

SELECT SUBSTRING(MD5(RAND()) FROM 1 FOR 8) AS myrandomstring

Puoi usare le funzioni rand () e char () di MySQL :

select concat( 
    char(round(rand()*25)+97),
    char(round(rand()*25)+97),
    char(round(rand()*25)+97),
    char(round(rand()*25)+97),
    char(round(rand()*25)+97),
    char(round(rand()*25)+97),
    char(round(rand()*25)+97),
    char(round(rand()*25)+97)
) as name;

Puoi generare una stringa alfanumerica casuale con:

lpad(conv(floor(rand()*pow(36,8)), 10, 36), 8, 0);

Puoi usarlo in un BEFORE INSERTtrigger e verificare la presenza di un duplicato in un ciclo while:

CREATE TABLE `vehicles` (
    `plate` CHAR(8) NULL DEFAULT NULL,
    `data` VARCHAR(50) NOT NULL,
    UNIQUE INDEX `plate` (`plate`)
);

DELIMITER //
CREATE TRIGGER `vehicles_before_insert` BEFORE INSERT ON `vehicles`
FOR EACH ROW BEGIN

    declare str_len int default 8;
    declare ready int default 0;
    declare rnd_str text;
    while not ready do
        set rnd_str := lpad(conv(floor(rand()*pow(36,str_len)), 10, 36), str_len, 0);
        if not exists (select * from vehicles where plate = rnd_str) then
            set new.plate = rnd_str;
            set ready := 1;
        end if;
    end while;

END//
DELIMITER ;

Ora inserisci i tuoi dati come

insert into vehicles(col1, col2) values ('value1', 'value2');

E il trigger genererà un valore per la platecolonna.

( demo sqlfiddle )

Funziona in questo modo se la colonna consente NULL. Se vuoi che sia NOT NULL devi definire un valore predefinito

`plate` CHAR(8) NOT NULL DEFAULT 'default',

Puoi anche utilizzare qualsiasi altro algoritmo di generazione di stringhe casuali nel trigger se i caratteri alfanumerici maiuscoli non sono ciò che desideri. Ma il grilletto si prenderà cura dell'unicità.

Per generare una stringa casuale, puoi usare:

SUBSTRING(MD5(RAND()) FROM 1 FOR 8)

Riceverai così:

353E50CC

Per una stringa composta da 8 numeri casuali e lettere maiuscole e minuscole, questa è la mia soluzione:

LPAD(LEFT(REPLACE(REPLACE(REPLACE(TO_BASE64(UNHEX(MD5(RAND()))), "/", ""), "+", ""), "=", ""), 8), 8, 0)

Spiegato dall'interno verso l'esterno:

1. RAND genera un numero casuale compreso tra 0 e 1
2. MD5 calcola la somma MD5 di (1), 32 caratteri da af e 0-9
3. UNHEX traduce (2) in 16 byte con valori da 00 a FF
4. TO_BASE64 codifica (3) come base64, 22 caratteri da az e AZ e 0-9 più "/" e "+", seguito da due "="
5. i tre REPLACErimuovono i caratteri "/", "+" e "=" da (4)
6. LEFT prende i primi 8 caratteri da (5), cambia 8 in qualcos'altro se hai bisogno di più o meno caratteri nella tua stringa casuale
7. LPADinserisce zeri all'inizio di (6) se è lungo meno di 8 caratteri; di nuovo, cambia 8 in qualcos'altro se necessario

Utilizzo i dati di un'altra colonna per generare un "hash" o una stringa univoca

UPDATE table_name SET column_name = Right( MD5(another_column_with_data), 8 )

8 lettere dell'alfabeto - Tutte maiuscole:

UPDATE `tablename` SET `tablename`.`randomstring`= concat(CHAR(FLOOR(65 + (RAND() * 25))),CHAR(FLOOR(65 + (RAND() * 25))),CHAR(FLOOR(65 + (RAND() * 25))),CHAR(FLOOR(65 + (RAND() * 25)))CHAR(FLOOR(65 + (RAND() * 25))),CHAR(FLOOR(65 + (RAND() * 25))),CHAR(FLOOR(65 + (RAND() * 25))),CHAR(FLOOR(65 + (RAND() * 25))));

Se non hai un id o un seme, come se fosse per un elenco di valori in insert:

REPLACE(RAND(), '.', '')

Soluzione semplice ed efficiente per ottenere una stringa casuale di 10 caratteri con lettere e cifre maiuscole e minuscole:

select substring(base64_encode(md5(rand())) from 1+rand()*4 for 10);

Se stai bene con targhe "casuali" ma del tutto prevedibili, puoi utilizzare un registro a scorrimento a feedback lineare per scegliere il numero di targa successivo: è garantito che passi attraverso ogni numero prima di ripetere. Tuttavia, senza una matematica complessa, non sarai in grado di passare attraverso ogni stringa alfanumerica di 8 caratteri (otterrai 2 ^ 41 su 36 ^ 8 (78%) possibili piastre). Per far sì che questo riempia meglio il tuo spazio, potresti escludere una lettera dai piatti (forse O), dandoti il ​​97%.

Tenendo conto del numero totale di caratteri richiesto, avresti una minima possibilità di generare due targhe esattamente simili. Quindi potresti probabilmente farla franca generando i numeri in LUA.

Hai 36 ^ 8 diverse targhe univoche (2.821.109.907.456, è molto), anche se avessi già un milione di targhe, avresti una minima possibilità di generarne una che hai già, circa lo 0,000035%

Certo, tutto dipende da quante targhe finirai per creare.

Questa funzione genera una stringa casuale in base alla lunghezza dell'input e ai caratteri consentiti come questo:

SELECT str_rand(8, '23456789abcdefghijkmnpqrstuvwxyz');

codice funzione:

DROP FUNCTION IF EXISTS str_rand;

DELIMITER //

CREATE FUNCTION str_rand(
    u_count INT UNSIGNED,
    v_chars TEXT
)
RETURNS TEXT
NOT DETERMINISTIC
NO SQL
SQL SECURITY INVOKER
COMMENT ''
BEGIN
    DECLARE v_retval TEXT DEFAULT '';
    DECLARE u_pos    INT UNSIGNED;
    DECLARE u        INT UNSIGNED;

    SET u = LENGTH(v_chars);
    WHILE u_count > 0
    DO
      SET u_pos = 1 + FLOOR(RAND() * u);
      SET v_retval = CONCAT(v_retval, MID(v_chars, u_pos, 1));
      SET u_count = u_count - 1;
    END WHILE;

    RETURN v_retval;
END;
//
DELIMITER ;

Questo codice si basa sulla funzione stringa casuale inviata da "Ross Smith II"

Per creare un alfanumerico casuale di 10 cifre , esclusi i caratteri simili 01oOlI:

LPAD(LEFT(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(TO_BASE64(UNHEX(MD5(RAND()))), "/", ""), "+", ""), "=", ""), "O", ""), "l", ""), "I", ""), "1", ""), "0", ""), "o", ""), 10), 10, 0)

Questo è esattamente ciò di cui avevo bisogno per creare un codice voucher . I caratteri confusi vengono rimossi per ridurre gli errori durante la digitazione in un modulo di codice voucher.

Spera che questo aiuti qualcuno, sulla base della brillante risposta di Jan Uhlig .

Si prega di vedere la risposta di Jan per una ripartizione su come funziona questo codice.

DELIMITER $$

USE `temp` $$

DROP PROCEDURE IF EXISTS `GenerateUniqueValue`$$

CREATE PROCEDURE `GenerateUniqueValue`(IN tableName VARCHAR(255),IN columnName VARCHAR(255)) 
BEGIN
    DECLARE uniqueValue VARCHAR(8) DEFAULT "";
    WHILE LENGTH(uniqueValue) = 0 DO
        SELECT CONCAT(SUBSTRING('ABCDEFGHIJKLMNOPQRSTUVWXYZ123456789', RAND()*34+1, 1),
                SUBSTRING('ABCDEFGHIJKLMNOPQRSTUVWXYZ123456789', RAND()*34+1, 1),
                SUBSTRING('ABCDEFGHIJKLMNOPQRSTUVWXYZ123456789', RAND()*34+1, 1),
                SUBSTRING('ABCDEFGHIJKLMNOPQRSTUVWXYZ123456789', RAND()*34+1, 1),
                SUBSTRING('ABCDEFGHIJKLMNOPQRSTUVWXYZ123456789', RAND()*34+1, 1),
                SUBSTRING('ABCDEFGHIJKLMNOPQRSTUVWXYZ123456789', RAND()*34+1, 1),
                SUBSTRING('ABCDEFGHIJKLMNOPQRSTUVWXYZ123456789', RAND()*34+1, 1),
                SUBSTRING('ABCDEFGHIJKLMNOPQRSTUVWXYZ123456789', RAND()*34+1, 1)
                ) INTO @newUniqueValue;
        SET @rcount = -1;
        SET @query=CONCAT('SELECT COUNT(*) INTO @rcount FROM  ',tableName,' WHERE ',columnName,'  like ''',@newUniqueValue,'''');
        PREPARE stmt FROM  @query;
        EXECUTE stmt;
        DEALLOCATE PREPARE stmt;
    IF @rcount = 0 THEN
            SET uniqueValue = @newUniqueValue ;
        END IF ;
    END WHILE ;
    SELECT uniqueValue;
    END$$

DELIMITER ;

Usa questa procedura memorizzata e usala ogni volta che vuoi

Call GenerateUniqueValue('tableName','columnName')

Un modo semplice per generare un numero univoco

set @i = 0;
update vehicles set plate = CONCAT(@i:=@i+1, ROUND(RAND() * 1000)) 
order by rand();

Genera 8 caratteri chiave

lpad(conv(floor(rand()*pow(36,6)), 10, 36), 8, 0); 

Come posso generare una stringa univoca e casuale per una delle colonne della mia tabella MySql?

Stavo cercando qualcosa di simile e ho deciso di creare una mia versione in cui puoi anche specificare un seme diverso se lo desideri (elenco di caratteri) come parametro:

CREATE FUNCTION `random_string`(length SMALLINT(3), seed VARCHAR(255)) RETURNS varchar(255) CHARSET utf8
    NO SQL
BEGIN
    SET @output = '';

    IF seed IS NULL OR seed = '' THEN SET seed = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'; END IF;

    SET @rnd_multiplier = LENGTH(seed);

    WHILE LENGTH(@output) < length DO
        # Select random character and add to output
        SET @output = CONCAT(@output, SUBSTRING(seed, RAND() * (@rnd_multiplier + 1), 1));
    END WHILE;

    RETURN @output;
END

Può essere utilizzato come:

SELECT random_string(10, '')

Che userebbe il seme incorporato di caratteri maiuscoli e minuscoli + cifre. NULL sarebbe anche valore invece di "".

Ma si potrebbe specificare un seme personalizzato durante la chiamata:

SELECT random_string(10, '1234')