복붙노트

[SQL] T-SQL 무작위 문자열을 생성

SQL

T-SQL 무작위 문자열을 생성

당신은 T-SQL 사용하여 의사 영숫자 문자열, 당신이 그것을 어떻게 할 것을 생성하고 싶다면? 당신은 어떻게 그것에서 달러 기호, 대시 및 슬래시와 같은 문자를 제외 것인가?

해결법

  1. ==============================

    1.특별히 시험을 위해, 임의의 데이터를 생성 할 때, 데이터는 임의하지만 재현 할 수 있도록하는 것이 매우 유용하다. 비밀은 임의의 기능에 대한 명시 적 씨앗을 사용하는 것입니다, 그래서 테스트가 같은 씨앗을 다시 실행 될 때, 그것은 다시 정확히 같은 문자열을 생성합니다. 여기서 재현 방식 개체 이름을 생성하는 함수의 단순화 된 예이다 :

    특별히 시험을 위해, 임의의 데이터를 생성 할 때, 데이터는 임의하지만 재현 할 수 있도록하는 것이 매우 유용하다. 비밀은 임의의 기능에 대한 명시 적 씨앗을 사용하는 것입니다, 그래서 테스트가 같은 씨앗을 다시 실행 될 때, 그것은 다시 정확히 같은 문자열을 생성합니다. 여기서 재현 방식 개체 이름을 생성하는 함수의 단순화 된 예이다 :

    alter procedure usp_generateIdentifier
    @minLen int = 1
    , @maxLen int = 256
    , @seed int output
    , @string varchar(8000) output
as
begin
    set nocount on;
    declare @length int;
    declare @alpha varchar(8000)
        , @digit varchar(8000)
        , @specials varchar(8000)
        , @first varchar(8000)
    declare @step bigint = rand(@seed) * 2147483647;

    select @alpha = 'qwertyuiopasdfghjklzxcvbnm'
        , @digit = '1234567890'
        , @specials = '_@# '
    select @first = @alpha + '_@';

    set  @seed = (rand((@seed+@step)%2147483647)*2147483647);

    select @length = @minLen + rand(@seed) * (@maxLen-@minLen)
        , @seed = (rand((@seed+@step)%2147483647)*2147483647);

    declare @dice int;
    select @dice = rand(@seed) * len(@first),
        @seed = (rand((@seed+@step)%2147483647)*2147483647);
    select @string = substring(@first, @dice, 1);

    while 0 < @length 
    begin
        select @dice = rand(@seed) * 100
            , @seed = (rand((@seed+@step)%2147483647)*2147483647);
        if (@dice < 10) -- 10% special chars
        begin
            select @dice = rand(@seed) * len(@specials)+1
                , @seed = (rand((@seed+@step)%2147483647)*2147483647);
            select @string = @string + substring(@specials, @dice, 1);
        end
        else if (@dice < 10+10) -- 10% digits
        begin
            select @dice = rand(@seed) * len(@digit)+1
                , @seed = (rand((@seed+@step)%2147483647)*2147483647);
            select @string = @string + substring(@digit, @dice, 1);
        end
        else -- rest 80% alpha
        begin
            declare @preseed int = @seed;
            select @dice = rand(@seed) * len(@alpha)+1
                , @seed = (rand((@seed+@step)%2147483647)*2147483647);

            select @string = @string + substring(@alpha, @dice, 1);
        end

        select @length = @length - 1;   
    end
end
go

    테스트를 실행하는 경우 발신자는 테스트 실행 (결과 테이블에 저장), 다음이 유사한 씨앗을 따라 통과와 연관 임의의 씨앗을 생성합니다 :

    declare @seed int;
declare @string varchar(256);

select @seed = 1234; -- saved start seed

exec usp_generateIdentifier 
    @seed = @seed output
    , @string = @string output;
print @string;  
exec usp_generateIdentifier 
    @seed = @seed output
    , @string = @string output;
print @string;  
exec usp_generateIdentifier 
    @seed = @seed output
    , @string = @string output;
print @string;

    2016년 2월 17일 업데이트 : 아래의 주석을 참조하십시오, 원래 절차는 임의의 씨앗을 진행 방식에 문제가 있었다. 내가 언급 오프별로 한 문제를 해결 또한 코드를 업데이트합니다.

  2. ==============================

    2.GUID를 사용하여

    GUID를 사용하여

    SELECT @randomString = CONVERT(varchar(255), NEWID())

    매우 짧은 ...

  3. ==============================

    3.첫 번째 예와 유사하지만, 더 유연성 :

    첫 번째 예와 유사하지만, 더 유연성 :

    -- min_length = 8, max_length = 12
SET @Length = RAND() * 5 + 8
-- SET @Length = RAND() * (max_length - min_length + 1) + min_length

-- define allowable character explicitly - easy to read this way an easy to 
-- omit easily confused chars like l (ell) and 1 (one) or 0 (zero) and O (oh)
SET @CharPool = 
    'abcdefghijkmnopqrstuvwxyzABCDEFGHIJKLMNPQRSTUVWXYZ23456789.,-_!$@#%^&*'
SET @PoolLength = Len(@CharPool)

SET @LoopCount = 0
SET @RandomString = ''

WHILE (@LoopCount < @Length) BEGIN
    SELECT @RandomString = @RandomString + 
        SUBSTRING(@Charpool, CONVERT(int, RAND() * @PoolLength), 1)
    SELECT @LoopCount = @LoopCount + 1
END

    나는이보다 유연하게 다른 기능 중 하나를 언급하는 것을 잊었다. 그들이 선택 될 가능성이되도록 @CharPool의 문자 블록을 반복하여 특정 문자에 대한 비중을 증가시킬 수있다.

  4. ==============================

    4.짧은 문자열을 반환하려면 다음 코드를 사용합니다 :

    짧은 문자열을 반환하려면 다음 코드를 사용합니다 :

    SELECT SUBSTRING(CONVERT(varchar(40), NEWID()),0,9)
  5. ==============================

    5.당신은 SQL 서버 2008 이상을 실행하는 경우, 당신은 새로운 암호화 기능 crypt_gen_random ()를 사용하고 다음 문자열을 만들기 위해 인코딩 base64로 사용할 수 있습니다. 이는 8000 자까지 작동합니다.

    당신은 SQL 서버 2008 이상을 실행하는 경우, 당신은 새로운 암호화 기능 crypt_gen_random ()를 사용하고 다음 문자열을 만들기 위해 인코딩 base64로 사용할 수 있습니다. 이는 8000 자까지 작동합니다.

    declare @BinaryData varbinary(max)
    , @CharacterData varchar(max)
    , @Length int = 2048

set @BinaryData=crypt_gen_random (@Length) 

set @CharacterData=cast('' as xml).value('xs:base64Binary(sql:variable("@BinaryData"))', 'varchar(max)')

print @CharacterData
  6. ==============================

    6.나는 T-SQL 전문가 아니에요,하지만 simpliest 방법은 내가 이미 그처럼 사용했습니다 :

    나는 T-SQL 전문가 아니에요,하지만 simpliest 방법은 내가 이미 그처럼 사용했습니다 :

    select char((rand()*25 + 65))+char((rand()*25 + 65))

    이것은 (ASCII 65-90에서, A-Z) 개의 문자를 생성한다.

  7. ==============================

    7.

    select left(NEWID(),5)

    이 GUID를 문자열의 5 개 가장 왼쪽 문자를 반환합니다

    Example run
------------
11C89
9DB02
  8. ==============================

    8.여기서 임의의 영숫자 발생기는

    여기서 임의의 영숫자 발생기는

    print left(replace(newid(),'-',''),@length) //--@length is the length of random Num.
  9. ==============================

    9.한 무작위로 편지를 들어, 당신은 사용할 수 있습니다 :

    한 무작위로 편지를 들어, 당신은 사용할 수 있습니다 :

    select substring('ABCDEFGHIJKLMNOPQRSTUVWXYZ',
                 (abs(checksum(newid())) % 26)+1, 1)

    랜드 대 NEWID ()을 ()를 사용하여 사이의 중요한 차이점은 당신이 랜드 ()가 전체 쿼리에 대해 한 번 계산하는 동안 여러 행, NEWID ()를 각 행에 대해 개별적으로 계산을 반환합니다.

  10. ==============================

    10.내가 ID 단지 임의의 영숫자 3 개를 생성하는 데 필요한, 그러나 15 정도까지의 길이를 위해 일할 수 :이 나를 위해 일했다.

    내가 ID 단지 임의의 영숫자 3 개를 생성하는 데 필요한, 그러나 15 정도까지의 길이를 위해 일할 수 :이 나를 위해 일했다.

    declare @DesiredLength as int = 3;
select substring(replace(newID(),'-',''),cast(RAND()*(31-@DesiredLength) as int),@DesiredLength);
  11. ==============================

    11.나는이 많은 훌륭한 답변 오래된 질문 실현. 내가 찾은 그러나이 또한 압라 Hasani에 의해 TechNet의 더 최근 기사를 발견

    나는이 많은 훌륭한 답변 오래된 질문 실현. 내가 찾은 그러나이 또한 압라 Hasani에 의해 TechNet의 더 최근 기사를 발견

    T-SQL : 임의 암호를 생성하는 방법

    이 솔루션은 암호에 초점을 맞추고 있지만 그것은 일반적인 경우에 적용됩니다. 압라 해결책에 도달하기 위해 다양한 고려 사항을 통해 작동합니다. 그것은 매우 유익하다.

    모든 코드 블록이 문서를 형성 포함하는 스크립트는 TechNet 갤러리를 통해 개별적으로 사용할 수 있지만, 나는 확실히 기사에서 시작합니다.

  12. ==============================

    12.이 좋은 답변이 많이 있지만 그 중 지금까지 아무도 컬럼에 대한 기본 값으로 사용자 정의 문자 수영장과 작업을 할 수 없습니다. 나는 이런 식으로 뭔가를 할 수 있기를 원 :

    이 좋은 답변이 많이 있지만 그 중 지금까지 아무도 컬럼에 대한 기본 값으로 사용자 정의 문자 수영장과 작업을 할 수 없습니다. 나는 이런 식으로 뭔가를 할 수 있기를 원 :

    alter table MY_TABLE add MY_COLUMN char(20) not null
  default dbo.GenerateToken(crypt_gen_random(20))

    그래서 나는이 함께했다. 당신이 그것을 수정하면 하드 코드 번호 32 조심하십시오.

    -- Converts a varbinary of length N into a varchar of length N.
-- Recommend passing in the result of CRYPT_GEN_RANDOM(N).
create function GenerateToken(@randomBytes varbinary(max))
returns varchar(max) as begin

-- Limit to 32 chars to get an even distribution (because 32 divides 256) with easy math.
declare @allowedChars char(32);
set @allowedChars = 'abcdefghijklmnopqrstuvwxyz012345';

declare @oneByte tinyint;
declare @oneChar char(1);
declare @index int;
declare @token varchar(max);

set @index = 0;
set @token = '';

while @index < datalength(@randomBytes)
begin
    -- Get next byte, use it to index into @allowedChars, and append to @token.
    -- Note: substring is 1-based.
    set @index = @index + 1;
    select @oneByte = convert(tinyint, substring(@randomBytes, @index, 1));
    select @oneChar = substring(@allowedChars, 1 + (@oneByte % 32), 1); -- 32 is the number of @allowedChars
    select @token = @token + @oneChar;
end

return @token;

end
  13. ==============================

    13.난 단지 당신이 입력 변수에 표시 할 수 있도록하려는 부르는 것들은를 stipluate 개발 한이 절차를 사용하여, 당신은 너무 길이를 정의 할 수 있습니다. 내가 오버 플로우 스택에 새로운 오전, 잘 형식을 바랍니다.

    난 단지 당신이 입력 변수에 표시 할 수 있도록하려는 부르는 것들은를 stipluate 개발 한이 절차를 사용하여, 당신은 너무 길이를 정의 할 수 있습니다. 내가 오버 플로우 스택에 새로운 오전, 잘 형식을 바랍니다.

    IF EXISTS (SELECT * FROM sys.objects WHERE type = 'P' AND object_id = OBJECT_ID(N'GenerateARandomString'))
DROP PROCEDURE GenerateARandomString
GO

CREATE PROCEDURE GenerateARandomString
(
     @DESIREDLENGTH         INTEGER = 100,                  
     @NUMBERS               VARCHAR(50) 
        = '0123456789',     
     @ALPHABET              VARCHAR(100) 
        ='ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz',
     @SPECIALS              VARCHAR(50) 
        = '_=+-$£%^&*()"!@~#:', 
     @RANDOMSTRING          VARCHAR(8000)   OUT 

)

AS

BEGIN
    -- Author David Riley
    -- Version 1.0 
    -- You could alter to one big string .e.e numebrs , alpha special etc
    -- added for more felxibility in case I want to extend i.e put logic  in for 3 numbers, 2 pecials 3 numbers etc
    -- for now just randomly pick one of them

    DECLARE @SWAP                   VARCHAR(8000);      -- Will be used as a tempoary buffer 
    DECLARE @SELECTOR               INTEGER = 0;

    DECLARE @CURRENTLENGHT          INTEGER = 0;
    WHILE @CURRENTLENGHT < @DESIREDLENGTH
    BEGIN

        -- Do we want a number, special character or Alphabet Randonly decide?
        SET @SELECTOR  = CAST(ABS(CHECKSUM(NEWID())) % 3 AS INTEGER);   -- Always three 1 number , 2 alphaBET , 3 special;
        IF @SELECTOR = 0
        BEGIN
            SET @SELECTOR = 3
        END;

        -- SET SWAP VARIABLE AS DESIRED
        SELECT @SWAP = CASE WHEN @SELECTOR = 1 THEN @NUMBERS WHEN @SELECTOR = 2 THEN @ALPHABET ELSE @SPECIALS END;

        -- MAKE THE SELECTION
        SET @SELECTOR  = CAST(ABS(CHECKSUM(NEWID())) % LEN(@SWAP) AS INTEGER);
        IF @SELECTOR = 0
        BEGIN
            SET @SELECTOR = LEN(@SWAP)
        END;

        SET @RANDOMSTRING = ISNULL(@RANDOMSTRING,'') + SUBSTRING(@SWAP,@SELECTOR,1);
        SET @CURRENTLENGHT = LEN(@RANDOMSTRING);
    END;

END;

GO

DECLARE @RANDOMSTRING VARCHAR(8000)

EXEC GenerateARandomString @RANDOMSTRING = @RANDOMSTRING OUT

SELECT @RANDOMSTRING
  14. ==============================

    14.사랑, 친절, 휴가 등 : 때때로 우리는 무작위로 많은 것을 필요 나는 지난 몇 년 동안 몇 임의의 발전기를 수집, 이들은 PINAL 데이브와 나는 일단 발견 유래 응답에서입니다. 참고 문헌 아래.

    사랑, 친절, 휴가 등 : 때때로 우리는 무작위로 많은 것을 필요 나는 지난 몇 년 동안 몇 임의의 발전기를 수집, 이들은 PINAL 데이브와 나는 일단 발견 유래 응답에서입니다. 참고 문헌 아래.

    --Adapted from Pinal Dave; http://blog.sqlauthority.com/2007/04/29/sql-server-random-number-generator-script-sql-query/
SELECT 
    ABS( CAST( NEWID() AS BINARY( 6)) %1000) + 1 AS RandomInt
    , CAST( (ABS( CAST( NEWID() AS BINARY( 6)) %1000) + 1)/7.0123 AS NUMERIC( 15,4)) AS RandomNumeric
    , DATEADD( DAY, -1*(ABS( CAST( NEWID() AS BINARY( 6)) %1000) + 1), GETDATE()) AS RandomDate
    --This line from http://stackoverflow.com/questions/15038311/sql-password-generator-8-characters-upper-and-lower-and-include-a-number
    , CAST((ABS(CHECKSUM(NEWID()))%10) AS VARCHAR(1)) + CHAR(ASCII('a')+(ABS(CHECKSUM(NEWID()))%25)) + CHAR(ASCII('A')+(ABS(CHECKSUM(NEWID()))%25)) + LEFT(NEWID(),5) AS RandomChar
    , ABS(CHECKSUM(NEWID()))%50000+1 AS RandomID
  15. ==============================

    15.여기에 (나는 기존의 답변 충분히 어떤처럼하지 않았기 때문에) 한 오늘 함께했다입니다.

    여기에 (나는 기존의 답변 충분히 어떤처럼하지 않았기 때문에) 한 오늘 함께했다입니다.

    이것은 임의의 문자열의 임시 테이블을 생성한다 (자세한 0-9 및 AF 단지보다 정도), 맞춤 길이 (255, 제한 하드 코드) (NEWID으로 기반으로하지만, 또한 사용자 지정 문자 세트를 지원하고, 하지만) 변경, 임의 기록의 사용자 지정 숫자 할 수있다.

    여기에 소스 코드 (희망 코멘트 도움이)입니다 :

    /**
 * First, we're going to define the random parameters for this
 * snippet. Changing these variables will alter the entire
 * outcome of this script. Try not to break everything.
 *
 * @var {int}       count    The number of random values to generate.
 * @var {int}       length   The length of each random value.
 * @var {char(62)}  charset  The characters that may appear within a random value.
 */

-- Define the parameters
declare @count int = 10
declare @length int = 60
declare @charset char(62) = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'

/**
 * We're going to define our random table to be twice the maximum
 * length (255 * 2 = 510). It's twice because we will be using
 * the newid() method, which produces hex guids. More later.
 */

-- Create the random table
declare @random table (
    value nvarchar(510)
)

/**
 * We'll use two characters from newid() to make one character in
 * the random value. Each newid() provides us 32 hex characters,
 * so we'll have to make multiple calls depending on length.
 */

-- Determine how many "newid()" calls we'll need per random value
declare @iterations int = ceiling(@length * 2 / 32.0)

/**
 * Before we start making multiple calls to "newid", we need to
 * start with an initial value. Since we know that we need at
 * least one call, we will go ahead and satisfy the count.
 */

-- Iterate up to the count
declare @i int = 0 while @i < @count begin set @i = @i + 1

    -- Insert a new set of 32 hex characters for each record, limiting to @length * 2
    insert into @random
        select substring(replace(newid(), '-', ''), 1, @length * 2)

end

-- Now fill the remaining the remaining length using a series of update clauses
set @i = 0 while @i < @iterations begin set @i = @i + 1

    -- Append to the original value, limit @length * 2
    update @random
        set value = substring(value + replace(newid(), '-', ''), 1, @length * 2)

end

/**
 * Now that we have our base random values, we can convert them
 * into the final random values. We'll do this by taking two
 * hex characters, and mapping then to one charset value.
 */

-- Convert the base random values to charset random values
set @i = 0 while @i < @length begin set @i = @i + 1

    /**
     * Explaining what's actually going on here is a bit complex. I'll
     * do my best to break it down step by step. Hopefully you'll be
     * able to follow along. If not, then wise up and come back.
     */

    -- Perform the update
    update @random
        set value =

            /**
             * Everything we're doing here is in a loop. The @i variable marks
             * what character of the final result we're assigning. We will
             * start off by taking everything we've already done first.
             */

            -- Take the part of the string up to the current index
            substring(value, 1, @i - 1) +

            /**
             * Now we're going to convert the two hex values after the index,
             * and convert them to a single charset value. We can do this
             * with a bit of math and conversions, so function away!
             */

            -- Replace the current two hex values with one charset value
            substring(@charset, convert(int, convert(varbinary(1), substring(value, @i, 2), 2)) * (len(@charset) - 1) / 255 + 1, 1) +
    --  (1) -------------------------------------------------------^^^^^^^^^^^^^^^^^^^^^^^-----------------------------------------
    --  (2) ---------------------------------^^^^^^^^^^^^^^^^^^^^^^11111111111111111111111^^^^-------------------------------------
    --  (3) --------------------^^^^^^^^^^^^^2222222222222222222222222222222222222222222222222^------------------------------------
    --  (4) --------------------333333333333333333333333333333333333333333333333333333333333333---^^^^^^^^^^^^^^^^^^^^^^^^^--------
    --  (5) --------------------333333333333333333333333333333333333333333333333333333333333333^^^4444444444444444444444444--------
    --  (6) --------------------5555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555^^^^----
    --  (7) ^^^^^^^^^^^^^^^^^^^^66666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666^^^^

            /**
             * (1) - Determine the two hex characters that we'll be converting (ex: 0F, AB, 3C, etc.)
             * (2) - Convert those two hex characters to a a proper hexadecimal (ex: 0x0F, 0xAB, 0x3C, etc.)
             * (3) - Convert the hexadecimals to integers (ex: 15, 171, 60)
             * (4) - Determine the conversion ratio between the length of @charset and the range of hexadecimals (255)
             * (5) - Multiply the integer from (3) with the conversion ratio from (4) to get a value between 0 and (len(@charset) - 1)
             * (6) - Add 1 to the offset from (5) to get a value between 1 and len(@charset), since strings start at 1 in SQL
             * (7) - Use the offset from (6) and grab a single character from @subset
             */

            /**
             * All that is left is to add in everything we have left to do.
             * We will eventually process the entire string, but we will
             * take things one step at a time. Round and round we go!
             */

            -- Append everything we have left to do
            substring(value, 2 + @i, len(value))

end

-- Select the results
select value
from @random

    이 저장 프로 시저 아니지만, 한으로 바꿀 것을 어렵지 않을 것입니다. 그것은 (그것이 더 길이 60의 1000 개 결과를 생성하기 위해 ~ 0.3 초 ​​걸렸다 거 야 지금까지 개인적으로 필요 이상)도 엄청나게 느린 아니라 내가 뭘 문자열 돌연변이 모두에서 내 최초의 관심사 중 하나였다.

    여기에 주요 테이크 아웃은 내가 내 자신의 난수 생성기를 만들려고하고 있지 않다, 내 캐릭터 세트가 제한되지 않는 것입니다. 나는 단순히 SQL은 (내가 랜드 ()가 알고 있지만 테이블 결과 큰 아니다) 가지고있는 랜덤 생성기를 사용하고 있습니다. 지나치게 단순 (즉, 단지 NEWID ())와 지나치게 복잡 (즉, 사용자 정의 난수 알고리즘)에서 여기에 희망이 방법 결혼한다 대답의 두 종류.

    그것은 짧은 또한의 (마이너스 의견), 쉽게 항상 내 책에 플러스되는, (적어도 나를 위해) 이해하기.

    그러나,이 방법은 시드 할 수없는, 그래서 진정으로 무작위 때마다이 될 것, 당신은 신뢰성의 수단으로 동일한 데이터 집합을 복제 할 수 없습니다. 영업 이익은 요구 사항으로 목록을하지 않았다, 그러나 나는 어떤 사람들은 그런 종류의 물건을 찾아 것을 알고있다.

    나는 여기에 파티에 늦었 알고 있지만, 잘하면 사람이 유용하게 찾을 수 있습니다.

  16. ==============================

    16.나는 현재 프로젝트 (이상한 형식 죄송합니다) 사용하고 있음이에 대해 다음 저장 프로 시저를 내놓았다 후, 먼저이 블로그 게시물을 건너 온 :

    나는 현재 프로젝트 (이상한 형식 죄송합니다) 사용하고 있음이에 대해 다음 저장 프로 시저를 내놓았다 후, 먼저이 블로그 게시물을 건너 온 :

    CREATE PROCEDURE [dbo].[SpGenerateRandomString]
@sLength tinyint = 10,
@randomString varchar(50) OUTPUT
AS
BEGIN
SET NOCOUNT ON
DECLARE @counter tinyint
DECLARE @nextChar char(1)
SET @counter = 1
SET @randomString = ”

WHILE @counter <= @sLength
BEGIN
SELECT @nextChar = CHAR(48 + CONVERT(INT, (122-48+1)*RAND()))

IF ASCII(@nextChar) not in (58,59,60,61,62,63,64,91,92,93,94,95,96)
BEGIN
SELECT @randomString = @randomString + @nextChar
SET @counter = @counter + 1
END
END
END
  17. ==============================

    17.나는 NEWID에 의해 해당 테이블 순서에서 선택 문자 ()하고 해당보기에서 상위 1 문자를 선택하는 뷰를 생성, 내가 사용하고 싶었 문자를 가진 테이블을 생성하여 SQL 2000에서 이런 짓을.

    나는 NEWID에 의해 해당 테이블 순서에서 선택 문자 ()하고 해당보기에서 상위 1 문자를 선택하는 뷰를 생성, 내가 사용하고 싶었 문자를 가진 테이블을 생성하여 SQL 2000에서 이런 짓을.

    CREATE VIEW dbo.vwCodeCharRandom
AS
SELECT TOP 100 PERCENT 
    CodeChar
FROM dbo.tblCharacter
ORDER BY 
    NEWID()

...

SELECT TOP 1 CodeChar FROM dbo.vwCodeCharRandom

    그럼 당신은 단순히보기에서 문자를 끌어 필요에 따라 연결할 수 있습니다.

    편집 : 스테판의 반응에 의해 영감을 ...

    select top 1 RandomChar from tblRandomCharacters order by newid()

    뷰에 대한 필요가 없습니다 (나는 것을 왜 그랬는지 사실 잘 모르겠어요 - 다시 코드는 몇 년에서이다). 당신은 아직도 당신이 테이블에 사용할 문자를 지정할 수 있습니다.

  18. ==============================

    18.새로운 ID를 기반으로 Heres는 뭔가.

    새로운 ID를 기반으로 Heres는 뭔가.

    with list as 
(
    select 1 as id,newid() as val
         union all
    select id + 1,NEWID()
    from    list   
    where   id + 1 < 10
) 
select ID,val from list
option (maxrecursion 0)
  19. ==============================

    19.내가 공유하거나 사회에 돌려 줄 줄 알았는데 ... 그것은 ASCII 기반이고,이 솔루션은 완벽하지 않지만 그것은 아주 잘 작동합니다. 즐겨, 고란 ​​B.

    내가 공유하거나 사회에 돌려 줄 줄 알았는데 ... 그것은 ASCII 기반이고,이 솔루션은 완벽하지 않지만 그것은 아주 잘 작동합니다. 즐겨, 고란 ​​B.

    /* 
-- predictable masking of ascii chars within a given decimal range
-- purpose: 
--    i needed an alternative to hashing alg. or uniqueidentifier functions
--    because i wanted to be able to revert to original char set if possible ("if", the operative word)
-- notes: wrap below in a scalar function if desired (i.e. recommended)
-- by goran biljetina (2014-02-25)
*/

declare 
@length int
,@position int
,@maskedString varchar(500)
,@inpString varchar(500)
,@offsetAsciiUp1 smallint
,@offsetAsciiDown1 smallint
,@ipOffset smallint
,@asciiHiBound smallint
,@asciiLoBound smallint


set @ipOffset=null
set @offsetAsciiUp1=1
set @offsetAsciiDown1=-1
set @asciiHiBound=126 --> up to and NOT including
set @asciiLoBound=31 --> up from and NOT including

SET @inpString = '{"config":"some string value", "boolAttr": true}'
SET @length = LEN(@inpString)

SET @position = 1
SET @maskedString = ''

--> MASK:
---------
WHILE (@position < @length+1) BEGIN
    SELECT @maskedString = @maskedString + 
    ISNULL(
        CASE 
        WHEN ASCII(SUBSTRING(@inpString,@position,1))>@asciiLoBound AND ASCII(SUBSTRING(@inpString,@position,1))<@asciiHiBound
         THEN
            CHAR(ASCII(SUBSTRING(@inpString,@position,1))+
            (case when @ipOffset is null then
            case when ASCII(SUBSTRING(@inpString,@position,1))%2=0 then @offsetAsciiUp1 else @offsetAsciiDown1 end
            else @ipOffset end))
        WHEN ASCII(SUBSTRING(@inpString,@position,1))<=@asciiLoBound
         THEN '('+CONVERT(varchar,ASCII(SUBSTRING(@Inpstring,@position,1))+1000)+')' --> wrap for decode
        WHEN ASCII(SUBSTRING(@inpString,@position,1))>=@asciiHiBound
         THEN '('+CONVERT(varchar,ASCII(SUBSTRING(@inpString,@position,1))+1000)+')' --> wrap for decode
        END
        ,'')
    SELECT @position = @position + 1
END

select @MaskedString


SET @inpString = @maskedString
SET @length = LEN(@inpString)

SET @position = 1
SET @maskedString = ''

--> UNMASK (Limited to within ascii lo-hi bound):
-------------------------------------------------
WHILE (@position < @length+1) BEGIN
    SELECT @maskedString = @maskedString + 
    ISNULL(
        CASE 
        WHEN ASCII(SUBSTRING(@inpString,@position,1))>@asciiLoBound AND ASCII(SUBSTRING(@inpString,@position,1))<@asciiHiBound
         THEN
            CHAR(ASCII(SUBSTRING(@inpString,@position,1))+
            (case when @ipOffset is null then
            case when ASCII(SUBSTRING(@inpString,@position,1))%2=1 then @offsetAsciiDown1 else @offsetAsciiUp1 end
            else @ipOffset*(-1) end))
        ELSE ''
        END
        ,'')
    SELECT @position = @position + 1
END

select @maskedString
  20. ==============================

    20.이것은 다른 답변의 같은 종자와 랜드를 사용하지만 모든 호출에 씨앗을 제공 할 필요가 없다. 첫 번째 통화를 제공하는 것은 충분하다.

    이것은 다른 답변의 같은 종자와 랜드를 사용하지만 모든 호출에 씨앗을 제공 할 필요가 없다. 첫 번째 통화를 제공하는 것은 충분하다.

    이것은 내 수정 된 코드입니다.

    IF EXISTS (SELECT * FROM sys.objects WHERE type = 'P' AND object_id = OBJECT_ID(N'usp_generateIdentifier'))
DROP PROCEDURE usp_generateIdentifier
GO

create procedure usp_generateIdentifier
    @minLen int = 1
    , @maxLen int = 256
    , @seed int output
    , @string varchar(8000) output
as
begin
    set nocount on;
    declare @length int;
    declare @alpha varchar(8000)
        , @digit varchar(8000)
        , @specials varchar(8000)
        , @first varchar(8000)

    select @alpha = 'qwertyuiopasdfghjklzxcvbnm'
        , @digit = '1234567890'
        , @specials = '_@#$&'
    select @first = @alpha + '_@';

    -- Establish our rand seed and store a new seed for next time
    set  @seed = (rand(@seed)*2147483647);

    select @length = @minLen + rand() * (@maxLen-@minLen);
    --print @length

    declare @dice int;
    select @dice = rand() * len(@first);
    select @string = substring(@first, @dice, 1);

    while 0 < @length 
    begin
        select @dice = rand() * 100;
        if (@dice < 10) -- 10% special chars
        begin
            select @dice = rand() * len(@specials)+1;
            select @string = @string + substring(@specials, @dice, 1);
        end
        else if (@dice < 10+10) -- 10% digits
        begin
            select @dice = rand() * len(@digit)+1;
            select @string = @string + substring(@digit, @dice, 1);
        end
        else -- rest 80% alpha
        begin
            select @dice = rand() * len(@alpha)+1;

            select @string = @string + substring(@alpha, @dice, 1);
        end

        select @length = @length - 1;   
    end
end
go
  21. ==============================

    21.SQL 서버에서 2012+ 우리는 몇 가지 (G)의 UID의 바이너리을 연결 한 후 결과에 base64로 변환 할 수 있습니다.

    SQL 서버에서 2012+ 우리는 몇 가지 (G)의 UID의 바이너리을 연결 한 후 결과에 base64로 변환 할 수 있습니다.

    SELECT 
    textLen.textLen
,   left((
        select  CAST(newid() as varbinary(max)) + CAST(newid() as varbinary(max)) 
        where   textLen.textLen is not null /*force evaluation for each outer query row*/ 
        FOR XML PATH(''), BINARY BASE64
    ),textLen.textLen)   as  randomText
FROM ( values (2),(4),(48) ) as textLen(textLen)    --define lengths here
;

    당신은 당신이 하위 선택을에서 (VARBINARY (최대)로 NEWID ()) 더 + CAST 추가해야합니다 (또는 당신이 결과에서 볼 수 = 문자) 긴 문자열이 필요합니다.

  22. ==============================

    22.나는 위의 답변을 많이 좋아하지만 자연에 조금 더 무작위 무언가를 찾고 있었다 그래서. 또한 명시 적으로 제외 문자를 호출 할 수있는 방법을 원했다. 다음은 암호화 난수를 얻을 수있는 CRYPT_GEN_RANDOM를 호출하는 뷰를 사용하여 내 솔루션입니다. 내 예제에서는 단지 8 바이트이었다 임의의 숫자를 선택했다. 음, 당신이 크기를 늘리고 원하는 경우도 함수의 씨앗 매개 변수를 활용할 수 있습니다하십시오. 여기에 문서에 대한 링크는 다음과 같습니다 https://docs.microsoft.com/en-us/sql/t-sql/functions/crypt-gen-random-transact-sql

    나는 위의 답변을 많이 좋아하지만 자연에 조금 더 무작위 무언가를 찾고 있었다 그래서. 또한 명시 적으로 제외 문자를 호출 할 수있는 방법을 원했다. 다음은 암호화 난수를 얻을 수있는 CRYPT_GEN_RANDOM를 호출하는 뷰를 사용하여 내 솔루션입니다. 내 예제에서는 단지 8 바이트이었다 임의의 숫자를 선택했다. 음, 당신이 크기를 늘리고 원하는 경우도 함수의 씨앗 매개 변수를 활용할 수 있습니다하십시오. 여기에 문서에 대한 링크는 다음과 같습니다 https://docs.microsoft.com/en-us/sql/t-sql/functions/crypt-gen-random-transact-sql

    CREATE VIEW [dbo].[VW_CRYPT_GEN_RANDOM_8]
AS
SELECT CRYPT_GEN_RANDOM(8) as [value];

    CRYPT_GEN_RANDOM이 함수에서 직접 호출 할 수 없기 때문에 뷰를 작성하는 이유입니다.

    거기에서, 나는 길이와 제외 문자의 쉼표로 구분 된 문자열을 포함 할 수있는 문자열 매개 변수를 허용하는 스칼라 함수를 만들었습니다.

    CREATE FUNCTION [dbo].[fn_GenerateRandomString]
( 
    @length INT,
    @excludedCharacters VARCHAR(200) --Comma delimited string of excluded characters
)
RETURNS VARCHAR(Max)
BEGIN
    DECLARE @returnValue VARCHAR(Max) = ''
        , @asciiValue INT
        , @currentCharacter CHAR;

    --Optional concept, you can add default excluded characters
    SET @excludedCharacters = CONCAT(@excludedCharacters,',^,*,(,),-,_,=,+,[,{,],},\,|,;,:,'',",<,.,>,/,`,~');

    --Table of excluded characters
    DECLARE @excludedCharactersTable table([asciiValue] INT);

    --Insert comma
    INSERT INTO @excludedCharactersTable SELECT 44;

    --Stores the ascii value of the excluded characters in the table
    INSERT INTO @excludedCharactersTable
    SELECT ASCII(TRIM(value))
    FROM STRING_SPLIT(@excludedCharacters, ',')
    WHERE LEN(TRIM(value)) = 1;

    --Keep looping until the return string is filled
    WHILE(LEN(@returnValue) < @length)
    BEGIN
        --Get a truly random integer values from 33-126
        SET @asciiValue = (SELECT TOP 1 (ABS(CONVERT(INT, [value])) % 94) + 33 FROM [dbo].[VW_CRYPT_GEN_RANDOM_8]);

        --If the random integer value is not in the excluded characters table then append to the return string
        IF(NOT EXISTS(SELECT * 
                        FROM @excludedCharactersTable 
                        WHERE [asciiValue] = @asciiValue))
        BEGIN
            SET @returnValue = @returnValue + CHAR(@asciiValue);
        END
    END

    RETURN(@returnValue);
END

    다음은 함수를 호출하는 방법의 예입니다.

    SELECT [dbo].[fn_GenerateRandomString](8,'!,@,#,$,%,&,?');

    ~ 건배

  23. ==============================

    23.매우 그것을 simply.use 즐길 수 있어요.

    매우 그것을 simply.use 즐길 수 있어요.

    CREATE VIEW [dbo].[vwGetNewId]
AS
SELECT        NEWID() AS Id

Creat FUNCTION [dbo].[fnGenerateRandomString](@length INT = 8)
RETURNS NVARCHAR(MAX)
AS
BEGIN

DECLARE @result CHAR(2000);

DECLARE @String VARCHAR(2000);

SET @String = 'abcdefghijklmnopqrstuvwxyz' + --lower letters
'ABCDEFGHIJKLMNOPQRSTUVWXYZ' + --upper letters
'1234567890'; --number characters

SELECT @result =
(
    SELECT TOP (@length)
           SUBSTRING(@String, 1 + number, 1) AS [text()]
    FROM master..spt_values
    WHERE number < DATALENGTH(@String)
          AND type = 'P'
    ORDER BY
(
    SELECT TOP 1 Id FROM dbo.vwGetNewId
)   --instead of using newid()
    FOR XML PATH('')
);

RETURN @result;

END;
  24. ==============================

    24.이는 Base64로 범위에서, 길이 문자열을 (각성제, 하강, 숫자, + 및 /)를 96 개 문자를 생성합니다. 3 추가 "NEWID하면 ()"아니오 Base64로 패딩 (=)와 (32)의 길이를 증가시킬 것이다.

    이는 Base64로 범위에서, 길이 문자열을 (각성제, 하강, 숫자, + 및 /)를 96 개 문자를 생성합니다. 3 추가 "NEWID하면 ()"아니오 Base64로 패딩 (=)와 (32)의 길이를 증가시킬 것이다.

        SELECT 
        CAST(
            CONVERT(NVARCHAR(MAX),
                CONVERT(VARBINARY(8), NEWID())
                +CONVERT(VARBINARY(8), NEWID())
                +CONVERT(VARBINARY(8), NEWID())
                +CONVERT(VARBINARY(8), NEWID())
                +CONVERT(VARBINARY(8), NEWID())
                +CONVERT(VARBINARY(8), NEWID())
                +CONVERT(VARBINARY(8), NEWID())
                +CONVERT(VARBINARY(8), NEWID())
                +CONVERT(VARBINARY(8), NEWID())
            ,2) 
        AS XML).value('xs:base64Binary(xs:hexBinary(.))', 'VARCHAR(MAX)') AS StringValue

    당신이 세트에이를 적용하는 경우, 그렇지 않으면 당신은 같은 값을 매번 얻을 것이다는 NEWID ()가 다시 계산됩니다 그래서 그 세트에서 뭔가를 도입해야합니다 :

      SELECT 
    U.UserName
    , LEFT(PseudoRandom.StringValue, LEN(U.Pwd)) AS FauxPwd
  FROM Users U
    CROSS APPLY (
        SELECT 
            CAST(
                CONVERT(NVARCHAR(MAX),
                    CONVERT(VARBINARY(8), NEWID())
                    +CONVERT(VARBINARY(8), NEWID())
                    +CONVERT(VARBINARY(8), NEWID())
                    +CONVERT(VARBINARY(8), NEWID())
                    +CONVERT(VARBINARY(8), NEWID())
                    +CONVERT(VARBINARY(8), NEWID())
                    +CONVERT(VARBINARY(8), NEWID())
                    +CONVERT(VARBINARY(8), NEWID())
                    +CONVERT(VARBINARY(8), NEWID())
                    +CONVERT(VARBINARY(8), NEWID())
                    +CONVERT(VARBINARY(8), U.UserID)  -- Causes a recomute of all NEWID() calls
                ,2) 
            AS XML).value('xs:base64Binary(xs:hexBinary(.))', 'VARCHAR(MAX)') AS StringValue
    ) PseudoRandom
  25. ==============================

    25.SQL 서버 2016 이상의 경우, 여기에 지정된 바이트 길이의 암호화 된 임의의 문자열을 생성하는 정말 간단하고 상대적으로 효율적 식입니다 :

    SQL 서버 2016 이상의 경우, 여기에 지정된 바이트 길이의 암호화 된 임의의 문자열을 생성하는 정말 간단하고 상대적으로 효율적 식입니다 :

    --Generates 36 bytes (48 characters) of base64 encoded random data
select r from OpenJson((select Crypt_Gen_Random(36) r for json path)) 
  with (r varchar(max))

    바이트 길이의 인코딩 크기와 동일하지 않습니다; 변환이 문서에서 다음을 사용 :

    Bytes = 3 * (LengthInCharacters / 4) - Padding
  26. ==============================

    26.내가 좋아하는 몇 가지 옵션의 조합으로 착륙이 문서에 다양한 도움이 응답을 기준으로합니다.

    내가 좋아하는 몇 가지 옵션의 조합으로 착륙이 문서에 다양한 도움이 응답을 기준으로합니다.

    DECLARE @UserId BIGINT = 12345 -- a uniqueId in my system
SELECT LOWER(REPLACE(NEWID(),'-','')) + CONVERT(VARCHAR, @UserId)

    27. from https://stackoverflow.com/questions/1324063/generating-random-strings-with-t-sql by cc-by-sa and MIT license

'SQL' 카테고리의 다른 글

[SQL] 어떻게 현재 날짜의 소인이있는 행을 선택하려면?  (0) 2020.05.07
[SQL] 어떤 시점에서 데이터베이스를 사용하여 가치가있다?  (0) 2020.05.07
[SQL] SQL 서버 SELECT 마지막 N 행  (0) 2020.05.07
[SQL] 데이터베이스 커서를 사용의 이점은 무엇입니까?  (0) 2020.05.07
[SQL] 어떻게 PostgreSQL을에 정렬과 행의 고정 번호를 삭제합니까?  (0) 2020.05.07
,

티스토리툴바