Generowanie losowego i unikalnego ciągu 8 znaków przy użyciu MySQL

Pracuję nad grą, która w pewnym momencie dotyczy pojazdów. Mam tabelę MySQL o nazwie „pojazdy” zawierającą dane o pojazdach, w tym kolumnę „tablica rejestracyjna”, która przechowuje tablice rejestracyjne pojazdów.

Teraz nadchodzi część, z którą mam problemy. Muszę znaleźć nieużywaną tablicę rejestracyjną przed utworzeniem nowego pojazdu - powinien to być alfanumeryczny 8-znakowy losowy ciąg. Jak to osiągnąłem, wykorzystałem pętlę while w Lua, czyli języku, w którym programuję, do generowania ciągów i wysyłania zapytań do bazy danych, aby sprawdzić, czy jest używana. Jednak wraz ze wzrostem liczby pojazdów spodziewam się, że stanie się to jeszcze bardziej nieefektywne, jak jest teraz. Dlatego zdecydowałem się spróbować rozwiązać ten problem za pomocą zapytania MySQL.

Zapytanie, którego potrzebuję, powinno po prostu wygenerować 8-znakowy ciąg alfanumeryczny, którego nie ma jeszcze w tabeli. Ponownie pomyślałem o podejściu do tworzenia i sprawdzania pętli, ale nie ograniczam tego pytania do tego, na wypadek gdyby było bardziej wydajne. Udało mi się wygenerować ciągi znaków, definiując ciąg zawierający wszystkie dozwolone znaki i losowo składający się z niego, i nic więcej.

Każda pomoc jest mile widziana.

Ten problem składa się z dwóch bardzo różnych podproblemów:

• ciąg musi być pozornie przypadkowy
• ciąg musi być unikalny

Chociaż przypadkowość jest dość łatwa do osiągnięcia, unikalność bez pętli ponawiania już nie. To prowadzi nas do skoncentrowania się najpierw na wyjątkowości. Nieprzypadkową wyjątkowość można w trywialny sposób osiągnąć za pomocą AUTO_INCREMENT. Tak więc użycie pseudolosowej transformacji zachowującej niepowtarzalność byłoby w porządku:

• Hash został zasugerowany przez @paul
• Szyfrowanie AES również pasuje
• Ale jest fajny: RAND(N)sam!

Gwarantujemy, że sekwencja liczb losowych utworzona przez to samo ziarno będzie

• odtwarzalny
• różny dla pierwszych 8 iteracji
• jeśli ziarno jest INT32

Więc używamy podejścia @ AndreyVolk lub @ GordonLinoff, ale z rozstawionym RAND :

np. Assumin idto AUTO_INCREMENTkolumna:

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;

Nie zawracałbym sobie głowy prawdopodobieństwem kolizji. Po prostu wygeneruj losowy ciąg i sprawdź, czy istnieje. Jeśli tak, spróbuj ponownie i nie powinieneś robić tego więcej niż kilka razy, chyba że masz już przypisaną ogromną liczbę tablic.

Inne rozwiązanie do generowania 8-znakowego pseudolosowego ciągu w czystym (My) SQL:

SELECT LEFT(UUID(), 8);

Możesz wypróbować następujący (pseudokod):

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

Ponieważ ten post zyskał nieoczekiwany poziom uwagi, pozwolę sobie podkreślić komentarz ADTC : powyższy fragment kodu jest dość głupi i tworzy kolejne cyfry.

Aby uzyskać nieco mniej głupią przypadkowość, spróbuj zamiast tego czegoś takiego:

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

Aby uzyskać prawdziwą (kryptograficznie bezpieczną) losowość, użyj RANDOM_BYTES()zamiast RAND()(ale wtedy rozważę przeniesienie tej logiki do warstwy aplikacji).

A co z obliczeniem wartości skrótu MD5 (lub innego) sekwencyjnych liczb całkowitych, a następnie pobraniem pierwszych 8 znaków.

to znaczy

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

itp.

Uwaga: nie mam pojęcia, ile można przydzielić przed kolizją (ale byłaby to znana i stała wartość).

edycja: To jest teraz stara odpowiedź, ale widziałem ją ponownie z czasem na moich rękach, więc z obserwacji ...

Szansa na wszystkie liczby = 2,35%

Szansa na wszystkie litery = 0,05%

Pierwsza kolizja, gdy MD5 (82945) = "7b763dcb ..." (taki sam wynik jak MD5 (25302))

Utwórz losowy ciąg

Oto funkcja MySQL do tworzenia losowego ciągu o określonej długości.

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

Stosowanie SELECT RANDSTRING(8) do zwrócenia ciągu 8 znaków.

Możesz dostosować @allowedChars .

Wyjątkowość nie jest gwarantowana - jak zobaczysz w komentarzach do innych rozwiązań, po prostu nie jest to możliwe. Zamiast tego musisz wygenerować ciąg, sprawdzić, czy jest już używany, i spróbować ponownie, jeśli jest.

Sprawdź, czy losowy ciąg jest już używany

Jeśli chcemy zachować kod sprawdzający kolizje poza aplikacją, możemy stworzyć wyzwalacz:

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 ;

Oto jeden sposób, używając cyfr alfanumerycznych jako prawidłowych znaków:

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;

Uwaga: nie ma gwarancji wyjątkowości. Musisz to sprawdzić osobno.

Oto inna metoda generowania losowego ciągu:

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

Możesz użyć funkcji rand () i char () 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;

Możesz wygenerować losowy ciąg alfanumeryczny za pomocą:

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

Możesz użyć go w BEFORE INSERTwyzwalaczu i sprawdzić duplikat w pętli 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 ;

Teraz po prostu wstaw swoje dane, takie jak

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

Wyzwalacz wygeneruje wartość dla platekolumny.

( demo sqlfiddle )

Działa to w ten sposób, jeśli kolumna dopuszcza wartości NULL. Jeśli chcesz, aby NIE było NULL, musisz zdefiniować wartość domyślną

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

Możesz także użyć dowolnego innego algorytmu generowania losowych ciągów w wyzwalaczu, jeśli duże litery alfanumeryczne nie są tym, czego chcesz. Ale wyzwalacz zadba o wyjątkowość.

Aby wygenerować losowy ciąg, możesz użyć:

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

Otrzymujesz coś takiego:

353E50CC

Oto moje rozwiązanie dla łańcucha składającego się z 8 liczb losowych oraz wielkich i małych liter:

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

Wyjaśnione od wewnątrz:

1. RAND generuje liczbę losową od 0 do 1
2. MD5 oblicza sumę MD5 (1), 32 znaki z af i 0-9
3. UNHEX tłumaczy (2) na 16 bajtów z wartościami od 00 do FF
4. TO_BASE64 koduje (3) jako base64, 22 znaki od az i AZ oraz 0-9 plus „/” i „+”, po których następuje dwa „=”
5. te trzy REPLACEusuwają znaki „/”, „+” i „=” z (4)
6. LEFT pobiera pierwsze 8 znaków z (5), zmień 8 na coś innego, jeśli potrzebujesz więcej lub mniej znaków w losowym ciągu
7. LPADwstawia zera na początku (6), jeśli ma mniej niż 8 znaków; ponownie, w razie potrzeby zmień 8 na coś innego

I Użyj danych z innej kolumny, aby wygenerować „hash” lub unikalny ciąg

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

8 liter alfabetu - wielkie litery:

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))));

Jeśli nie masz identyfikatora lub ziarna, tak jak jest to lista wartości we wstawieniu:

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

Proste i wydajne rozwiązanie umożliwiające uzyskanie losowego ciągu 10 znaków z dużymi i małymi literami oraz cyframi:

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

Jeśli nie masz nic przeciwko „losowym”, ale całkowicie przewidywalnym tablicom rejestracyjnym, możesz użyć rejestru przesuwnego z liniowym sprzężeniem zwrotnym, aby wybrać następny numer rejestracyjny - gwarantujemy, że przejdziesz przez każdy numer przed powtórzeniem. Jednak bez skomplikowanej matematyki nie będziesz w stanie przejść przez każdy 8-znakowy ciąg alfanumeryczny (otrzymasz 2 ^ 41 z 36 ^ 8 (78%) możliwych tablic). Aby lepiej wypełniało to twoją przestrzeń, możesz wykluczyć literę z tablic (może O), co daje 97%.

Biorąc pod uwagę całkowitą liczbę potrzebnych postaci, miałbyś bardzo małą szansę na wygenerowanie dwóch dokładnie podobnych tablic rejestracyjnych. W ten sposób prawdopodobnie mógłbyś uciec z generowaniem liczb w LUA.

Masz 36 ^ 8 różnych unikalnych numerów rejestracyjnych (2821,109,907,456, to dużo), nawet gdybyś miał już milion numerów, masz bardzo małą szansę na wygenerowanie takiej, którą już masz, około 0,000035%

Oczywiście wszystko zależy od tego, ile numerów rejestracyjnych ostatecznie utworzysz.

Ta funkcja generuje losowy ciąg na podstawie długości wejściowej i dozwolonych znaków, takich jak:

SELECT str_rand(8, '23456789abcdefghijkmnpqrstuvwxyz');

kod funkcji:

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 ;

Ten kod jest oparty na funkcji shuffle string wysyłanej przez „Ross Smith II”

Aby utworzyć losowy 10-cyfrowy alfanumeryczny , z wyłączeniem podobnych znaków 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)

Właśnie tego potrzebowałem, aby utworzyć kod kuponu . Mylące znaki są usuwane, aby zmniejszyć liczbę błędów podczas wpisywania ich w formularzu kodu kuponu.

Mam nadzieję, że to komuś pomoże, na podstawie błyskotliwej odpowiedzi Jana Uhliga .

Zobacz odpowiedź Jana, aby dowiedzieć się, jak działa ten kod.

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 ;

Użyj tej procedury składowanej i używaj jej za każdym razem, jak

Call GenerateUniqueValue('tableName','columnName')

Prosty sposób na wygenerowanie unikalnego numeru

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

Wygeneruj klucz 8-znakowy

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

Jak wygenerować unikalny, losowy ciąg dla jednej z moich kolumn tabeli MySql?

Szukałem czegoś podobnego i postanowiłem stworzyć własną wersję, w której możesz również określić inne ziarno, jeśli chcesz (lista znaków) jako parametr:

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

Może być używany jako:

SELECT random_string(10, '')

Który użyłby wbudowanego materiału siewnego wielkich i małych liter + cyfr. NULL byłoby również wartością zamiast „”.

Ale można określić niestandardowe ziarno podczas wywoływania:

SELECT random_string(10, '1234')