password - Generando cadenas aleatorias con T-SQL
rand t sql (22)
Si quisiera generar una cadena alfanumérica pseudoaleatoria utilizando T-SQL, ¿cómo lo haría? ¿Cómo excluiría a los personajes como signos de dólar, guiones y barras oblicuas?
A veces necesitamos muchas cosas al azar: amor, amabilidad, vacaciones, etc. He recolectado algunos generadores aleatorios a lo largo de los años, y estos son de Pinal Dave y una respuesta de que encontré una vez. Refs a continuación.
--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://.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
Al generar datos aleatorios, especialmente para la prueba, es muy útil hacer que los datos sean aleatorios, pero reproducibles. El secreto es usar semillas explícitas para la función aleatoria, de modo que cuando la prueba se ejecuta nuevamente con la misma semilla, vuelva a producir exactamente las mismas cadenas. Aquí hay un ejemplo simplificado de una función que genera nombres de objetos de forma reproducible:
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
Al ejecutar las pruebas, la persona que llama genera una semilla aleatoria que asocia con la ejecución de prueba (la guarda en la tabla de resultados), y luego pasa a lo largo de la semilla, similar a esto:
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;
Actualización 2016-02-17: Ver los comentarios a continuación, el procedimiento original tenía un problema en la forma en que avanzaba la semilla aleatoria. Actualicé el código y también solucioné el problema mencionado por separado.
Aquí hay algo basado en New Id.
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)
Aquí hay un generador alfanumérico aleatorio
print left(replace(newid(),''-'',''''),@length) //--@length is the length of random Num.
Aquí hay uno que se me ocurrió hoy (porque no me gustó lo suficiente las respuestas existentes).
Éste genera una tabla temporal de cadenas aleatorias, se basa en newid() , pero también admite un juego de caracteres personalizado (por lo que más de 0-9 y AF), longitud personalizada (hasta 255, el límite está codificado, pero se puede cambiar) y una cantidad personalizada de registros aleatorios.
Aquí está el código fuente (con suerte los comentarios ayudan):
/**
* 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
No es un procedimiento almacenado, pero no sería tan difícil convertirlo en uno. Tampoco es tremendamente lento (tardé ~ 0.3 segundos en generar 1,000 resultados de longitud 60, que es más de lo que necesitaré personalmente), que fue una de mis preocupaciones iniciales de toda la mutación de cadena que estoy haciendo.
El punto principal aquí es que no estoy tratando de crear mi propio generador de números aleatorios, y mi conjunto de caracteres no está limitado. Simplemente estoy usando el generador aleatorio que SQL tiene (sé que hay rand() , pero eso no es bueno para los resultados de la tabla). Esperemos que este enfoque case los dos tipos de respuestas, desde las más simples (es decir, simplemente newid() ) y demasiado complejas (es decir, el algoritmo personalizado de números aleatorios).
También es corto (menos los comentarios) y fácil de entender (al menos para mí), que siempre es una ventaja en mi libro.
Sin embargo, este método no se puede dividir, por lo que será verdaderamente aleatorio cada vez y no podrá replicar el mismo conjunto de datos con ningún tipo de fiabilidad. El OP no lo mencionó como un requisito, pero sé que algunas personas buscan ese tipo de cosas.
Sé que llego tarde a la fiesta aquí, pero espero que alguien lo encuentre útil.
Así que me gustaron muchas de las respuestas anteriores, pero estaba buscando algo que fuera un poco más aleatorio por naturaleza. También quería una forma de llamar explícitamente a los personajes excluidos. Debajo está mi solución usando una vista que llama al CRYPT_GEN_RANDOM para obtener un número aleatorio criptográfico. En mi ejemplo, solo elegí un número aleatorio de 8 bytes. Tenga en cuenta que puede aumentar este tamaño y también utilizar el parámetro inicial de la función si lo desea. Aquí está el enlace a la documentación: 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];
El motivo para crear la vista es porque CRYPT_GEN_RANDOM no puede CRYPT_GEN_RANDOM directamente desde una función.
A partir de ahí, creé una función escalar que acepta una longitud y un parámetro de cadena que pueden contener una cadena delimitada por comas de caracteres excluidos.
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
A continuación se muestra un ejemplo de cómo llamar a la función.
SELECT [dbo].[fn_GenerateRandomString](8,''!,@,#,$,%,&,?'');
~ Saludos
En SQL Server 2012+ podríamos concatenar los binarios de algunos UID (G) y luego realizar una conversión base64 en el resultado.
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
;
Si necesita cadenas más largas (o ve = caracteres en el resultado), necesita agregar más + CAST(newid() as varbinary(max)) en la selección secundaria.
Esto funcionó para mí: necesitaba generar solo tres caracteres alfanuméricos aleatorios para una identificación, pero podría funcionar para cualquier longitud de hasta 15 o más.
declare @DesiredLength as int = 3;
select substring(replace(newID(),''-'',''''),cast(RAND()*(31-@DesiredLength) as int),@DesiredLength);
Esto usa rand con una semilla como una de las otras respuestas, pero no es necesario proporcionar una semilla en cada llamada. Proporcionarlo en la primera llamada es suficiente.
Este es mi código modificado
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
Hay muchas respuestas buenas, pero hasta ahora ninguna permite un grupo de caracteres personalizables y funciona como valor predeterminado para una columna. Yo quería poder hacer algo como esto:
alter table MY_TABLE add MY_COLUMN char(20) not null
default dbo.GenerateToken(crypt_gen_random(20))
Así que se me ocurrió esto. Tenga cuidado con el número codificado 32 si lo modifica.
-- 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
Hice esto en SQL 2000 creando una tabla que tenía caracteres que quería usar, creando una vista que selecciona caracteres de esa tabla ordenando por newid (), y luego seleccionando los 1 caracteres superiores de esa vista.
CREATE VIEW dbo.vwCodeCharRandom
AS
SELECT TOP 100 PERCENT
CodeChar
FROM dbo.tblCharacter
ORDER BY
NEWID()
...
SELECT TOP 1 CodeChar FROM dbo.vwCodeCharRandom
Luego, simplemente puede extraer caracteres de la vista y concatenarlos según sea necesario.
EDITAR: Inspirado por la respuesta de Stephan ...
select top 1 RandomChar from tblRandomCharacters order by newid()
No hay necesidad de una vista (de hecho, no estoy seguro de por qué lo hice, el código data de hace varios años). Aún puede especificar los caracteres que desea usar en la tabla.
Me doy cuenta de que esta es una vieja pregunta con muchas buenas respuestas. Sin embargo, cuando encontré esto, también encontré un artículo más reciente sobre TechNet, de Saeid Hasani.
T-SQL: Cómo generar contraseñas aleatorias
Si bien la solución se centra en las contraseñas, se aplica al caso general. Saeid trabaja a través de varias consideraciones para llegar a una solución. Es muy instructivo
Una secuencia de comandos que contiene todos los bloques de código del artículo está disponible por separado a través de la Galería de TechNet , pero definitivamente comenzaría en el artículo.
No soy experto en T-SQL, pero la manera más sencilla que ya he usado es la siguiente:
select char((rand()*25 + 65))+char((rand()*25 + 65))
Esto genera dos caracteres (AZ, en ascii 65-90).
Pensé en compartir, o devolver a la comunidad ... Está basado en ASCII, y la solución no es perfecta, pero funciona bastante bien. Disfruta, Goran 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
Por una letra al azar, puede usar:
select substring(''ABCDEFGHIJKLMNOPQRSTUVWXYZ'',
(abs(checksum(newid())) % 26)+1, 1)
Una diferencia importante entre usar newid() versus rand() es que si devuelve varias filas, newid() se calcula por separado para cada fila, mientras que rand() se calcula una vez para toda la consulta.
Primero me encontré con esta publicación en el blog , y luego se me ocurrió el siguiente procedimiento almacenado para esto que estoy usando en un proyecto actual (lo siento por el formato extraño):
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
Si está ejecutando SQL Server 2008 o superior, podría usar la nueva función criptográfica crypt_gen_random () y luego usar la codificación base64 para convertirla en una cadena. Esto funcionará para hasta 8000 caracteres.
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
Similar al primer ejemplo, pero con más flexibilidad:
-- 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
Olvidé mencionar una de las otras características que hace esto más flexible. Al repetir bloques de caracteres en @CharPool, puede aumentar la ponderación de ciertos caracteres para que sean más elegibles.
Usando un guid
SELECT @randomString = CONVERT(varchar(255), NEWID())
muy corto ...
Use el siguiente código para devolver una cadena corta:
SELECT SUBSTRING(CONVERT(varchar(40), NEWID()),0,9)
Utilizo este procedimiento que desarrollé simplemente stipluate los charaters que desea poder mostrar en las variables de entrada, puede definir la longitud también. Espero que este formato sea bueno, soy nuevo en el desbordamiento de la pila.
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
select left(NEWID(),5)
Esto devolverá los 5 caracteres más a la izquierda de la cadena guid
Example run
------------
11C89
9DB02