Cree una jerarquía de niveles múltiples donde cada nodo tenga un número aleatorio de hijos

16

Necesito crear algunos datos de prueba que involucren una jerarquía. Podría facilitarlo y hacer un par de CROSS JOINsegundos, pero eso me daría una estructura que es completamente uniforme / sin ninguna variación. Eso no solo parece aburrido, sino que la falta de variación en los datos de la prueba a veces oculta problemas que de otro modo se encontrarían. Por lo tanto, quiero generar una jerarquía no uniforme que siga estas reglas:

  • 3 niveles de profundidad
    • El nivel 1 es aleatoriamente 5-20 nodos
    • El nivel 2 es de 1 a 10 nodos, aleatorio por cada nodo del nivel 1
    • El nivel 3 es de 1 a 5 nodos, aleatorio por cada nodo del nivel 2
  • Todas las ramas serán de 3 niveles de profundidad. La uniformidad en profundidad está bien en este momento.
  • Puede haber superposición en los nombres de los nodos secundarios en cualquier nivel dado (es decir, los nombres de los nodos secundarios no necesitan ser únicos en todos los nodos en el mismo nivel).
  • El término "aleatorio" se define aquí como pseudoaleatorio, no únicamente aleatorio. Esto debe mencionarse ya que el término "aleatorio" se usa a menudo para significar "ordenamiento aleatorio de un conjunto dado que no produce duplicados". Acepto que random = random y si el número de niños por cada nodo del Nivel 1 es solo 4, 7 y 8, incluso en 20 nodos en el Nivel 1 que tiene una propagación potencial de 1 a 10 niños por cada uno de esos nodos, entonces eso está bien, porque eso es lo que es aleatorio.
  • Aunque esto se puede hacer con bastante facilidad con WHILEbucles anidados , la preferencia es encontrar un enfoque basado en conjuntos. En términos generales, generar datos de prueba no tiene los requisitos de eficiencia que tendría el código de producción, pero buscar un enfoque basado en conjuntos probablemente será más educativo y ayudará en el futuro a encontrar enfoques basados ​​en conjuntos para los problemas. Por lo tanto, los WHILEbucles no se descartan, pero solo se pueden usar si no es posible un enfoque basado en conjuntos.
  • Basado en conjuntos = idealmente una única consulta, independientemente de CTE, APLICAR, etc. Por lo tanto, usar una tabla de números existente o en línea está bien. El uso de un enfoque WHILE / CURSOR / procedimiento no funcionará. Supongo que organizar partes de los datos en tablas temporales o variables de tabla está bien, siempre que las operaciones estén basadas en conjuntos, sin bucles. Sin embargo, dicho esto, un enfoque de consulta única probablemente se verá favorecido sobre múltiples consultas, a menos que se pueda demostrar que el enfoque de consulta múltiple es realmente mejor. Tenga en cuenta también que lo que constituye "mejor" suele ser subjetivo ;-). Tenga en cuenta también que el uso de "típicamente" en la oración anterior también es subjetivo.
  • Cualquier versión y edición de SQL Server (2005 y posterior, supongo) funcionará.
  • Solo T-SQL puro: ¡ninguna de esas tonterías de SQLCLR! Al menos en términos de generación de datos. La creación de los directorios y archivos se realizará utilizando SQLCLR. Pero aquí solo me estoy enfocando en generar los valores de qué crear.
  • Los TVF de múltiples declaraciones T-SQL se consideran procesales, no basados ​​en conjuntos, aunque en el exterior enmascaran el enfoque procesal en un conjunto. Hay momentos en que eso es absolutamente apropiado. Este no es uno de esos momentos. En esa misma línea, las funciones escalares de T-SQL tampoco están permitidas, no solo porque también son de procedimiento, sino que el Optimizador de consultas a veces almacena en caché su valor y lo repite de modo que el resultado no sea el esperado.
  • Los TVF en línea de T-SQL (también conocidos como iTVF) son okey-dokey ya que están basados ​​en conjuntos y son efectivamente lo mismo que usar [ CROSS | OUTER ] APPLY, lo que se indicó anteriormente como correcto.
  • Las ejecuciones repetidas de la (s) consulta (s) deberían producir resultados en su mayoría diferentes de la ejecución anterior.
  • Actualización de aclaración 1: el conjunto de resultados finales debe expresarse como que tiene una fila para cada nodo distinto de Level3, con la ruta completa que comienza en Level1. Esto significa que los valores de Nivel1 y Nivel2 se repetirán necesariamente en una o más filas, excepto en los casos en que haya un solo nodo de Nivel2 que contenga solo un nodo de Nivel3.
  • Actualización de aclaración 2: existe una preferencia muy fuerte para que cada nodo tenga un nombre o etiqueta, y no solo un número. Esto permitirá que los datos de prueba resultantes sean más significativos y realistas.

No estoy seguro de si esta información adicional es importante, pero en caso de que ayude a tener algún contexto, los datos de la prueba se relacionan con mi respuesta a esta pregunta:

Importar archivos XML a SQL Server 2012

Si bien no es relevante en este punto, el objetivo final de generar esta jerarquía es crear una estructura de directorio para probar los métodos recursivos del sistema de archivos. Los niveles 1 y 2 serán directorios, y el nivel 3 terminará siendo el nombre del archivo. He buscado (tanto aquí como a través de Google) y solo he encontrado una referencia para generar una jerarquía aleatoria:

Linux: crea una jerarquía aleatoria de directorios / archivos

Esa pregunta (en StackOverflow) en realidad es bastante cercana en términos del resultado deseado, ya que también busca crear una estructura de directorio para las pruebas. Pero esa pregunta (y las respuestas) se centran en las secuencias de comandos de shell de Linux / Unix y no tanto en el mundo basado en conjuntos en el que vivimos.

Ahora, sé cómo generar datos aleatorios, y ya lo estoy haciendo para crear el contenido de los archivos para que también puedan mostrar variaciones. La parte difícil aquí es que el número de elementos dentro de cada conjunto es aleatorio, no un campo en particular. Y , el número de elementos dentro de cada nodo debe ser aleatorio de otros nodos en esos mismos niveles.

Jerarquía de ejemplo

     Level 1
              Level 3
|---- A
|     |-- 1
|     |   |--- I
|     |
|     |-- 2
|         |--- III
|         |--- VI
|         |--- VII
|         |--- IX
|
|---- B
|     |-- 87
|         |--- AAA
|         |--- DDD
|
|---- C
      |-- ASDF
      |   |--- 11
      |   |--- 22
      |   |--- 33
      |
      |-- QWERTY
      |   |--- beft
      |
      |-- ROYGBP
          |--- Poi
          |--- Moi
          |--- Soy
          |--- Joy
          |--- Roy

Conjunto de resultados de ejemplo que describe la jerarquía anterior

Level 1    Level 2    Level 3
A          1          I
A          2          III
A          2          VI
A          2          VII
A          2          IX
B          87         AAA
B          87         DDD
C          ASDF       11
C          ASDF       22
C          ASDF       33
C          QWERTY     beft
C          ROYGBP     Poi
C          ROYGBP     Moi
C          ROYGBP     Soy
C          ROYGBP     Joy
C          ROYGBP     Roy
sql-server  t-sql  hierarchy  random 
— Solomon Rutzky
fuente

Respuestas:

9

( Nota de OP: la solución preferida es el bloque de código cuarto / final)

XML me parece ser la elección obvia de la estructura de datos para usar aquí.

with N as
(
  select T.N
  from (values(1),(2),(3),(4),(5),(6),(7),(8),(9),(10),(11),
              (12),(13),(14),(15),(16),(17),(18),(19),(20)) as T(N)
)

select top(5 + abs(checksum(newid())) % 15)
  N1.N as '@Value',
  (
  select top(1 + abs(checksum(newid())) % 10)
    N2.N as '@Value',
    (
    select top(1 + abs(checksum(newid())) % 5)
      N3.N as '@Value'
    from N as N3
    where N2.N > 0
    for xml path('Level3'), type
    )
  from N as N2
  where N1.N > 0
  for xml path('Level2'), type
  )
from N as N1
for xml path('Level1'), root('Root');

El truco para hacer que SQL Server use valores diferentes top()para cada nodo es hacer que las subconsultas estén correlacionadas. N1.N > 0y N2.N > 0.

Aplanar el XML:

declare @X xml;

with N as
(
  select T.N
  from (values(1),(2),(3),(4),(5),(6),(7),(8),(9),(10),(11),
              (12),(13),(14),(15),(16),(17),(18),(19),(20)) as T(N)
)
select @X  = (
             select top(5 + abs(checksum(newid())) % 15)
               N1.N as '@Value',
               (
               select top(1 + abs(checksum(newid())) % 10)
                 N2.N as '@Value',
                 (
                 select top(1 + abs(checksum(newid())) % 5)
                   N3.N as '@Value'
                 from N as N3
                 where N2.N > 0
                 for xml path('Level3'), type
                 )
               from N as N2
               where N1.N > 0
               for xml path('Level2'), type
               )
             from N as N1
             for xml path('Level1')
             );


select L1.X.value('@Value', 'varchar(10)')+'\'+
       L2.X.value('@Value', 'varchar(10)')+'\'+
       L3.X.value('@Value', 'varchar(10)')
from @X.nodes('/Level1') as L1(X)
  cross apply L1.X.nodes('Level2') as L2(X)
  cross apply L2.X.nodes('Level3') as L3(X);

Y una versión totalmente vacía de XML.

with N as
(
  select T.N
  from (values(1),(2),(3),(4),(5),(6),(7),(8),(9),(10),(11),
              (12),(13),(14),(15),(16),(17),(18),(19),(20)) as T(N)
)
select cast(N1.N as varchar(10))+'\'+
       cast(N2.N as varchar(10))+'\'+
       cast(N3.N as varchar(10))
from (
     select top(5 + abs(checksum(newid())) % 15)
       N.N
     from N
     ) as N1
  cross apply
     (
     select top(1 + abs(checksum(newid())) % 10)
       N.N
     from N
     where N1.N > 0
     ) as N2
  cross apply
     (
     select top(1 + abs(checksum(newid())) % 5)
       N.N
     from N
     where N2.N > 0
     ) as N3;

Correlación N1.N > 0y N2.N > 0sigue siendo importante.

Una versión que usa una tabla con 20 nombres para usar en lugar de solo enteros.

declare @Elements table
(
  Name nvarchar(50) not null
);

insert into @Elements(Name)
select top(20) C.name 
from sys.columns as C
group by C.name;

select N1.Name + N'\' + N2.Name + N'\' + N3.Name
from (
     select top(5 + abs(checksum(newid())) % 15)
       E.Name
     from @Elements as E
     ) as N1
  cross apply
     (
     select top(1 + abs(checksum(newid())) % 10)
       E.Name
     from @Elements as E
     where N1.Name > ''
     ) as N2
  cross apply
     (
     select top(1 + abs(checksum(newid())) % 5)
       E.Name
     from @Elements as E
     where N2.Name > ''
     ) as N3;
— Mikael Eriksson
fuente
1
Me gusta más la nueva versión. Es casi lo mismo que se me ocurrió en mi primer intento, pero por alguna razón no pude hacer TOP(n)que funcionara correctamente en los 2 CROSS APPLYs. No estoy seguro de lo que hice de manera diferente / incorrecta ya que me deshice de ese código una vez que algo más funcionó. Lo publicaré pronto, ahora que ha proporcionado esta actualización. Y he limpiado la mayoría de mis comentarios anteriores.
— Solomon Rutzky
Acabo de publicar mi versión. Las principales diferencias son: 1) como no pude hacer que TOP (n) funcionara, conseguí obtener nelementos a través de una condición WHERE, y 2) tengo el namecomponente que está más controlado que aleatorizar directorios y / o nombres de archivos .
— Solomon Rutzky
Lamento estar lejos tanto tiempo, pero he estado muy ocupado. Aún así, he estado pensando en esto y no puedo decidir entre mi respuesta y su versión no XML. Me gusta la simplicidad y flexibilidad de los suyos, pero necesito la capacidad de devolver nombres para usar para crear una estructura de carpetas, que la mía tiene. Luego me di cuenta de que Vlad había actualizado la suya para tener una tabla de búsqueda y unirme a ella para obtener el resultado ideal. Entonces, si no es inapropiado preguntar, ¿podría actualizar el suyo para incluir esa misma búsqueda? Luego, las 3 respuestas darían un resultado equivalente (ideal para comparar las 3), y yo aceptaría la suya. ¿Eso esta bien?
— Solomon Rutzky
1
@srutzky He actualizado la respuesta. Fue hace un tiempo, así que espero haberlo hecho bien y lo que estabas buscando. Por supuesto, puede agregar una columna de nivel @Elemetspara obtener un conjunto diferente de nombres para cada nivel para elegir.
— Mikael Eriksson
1
@srutzky no te preocupes. Me alegra que la respuesta te haya sido útil.
— Mikael Eriksson
6

Eso fue interesante.

Mi objetivo era generar un número dado de niveles con un número aleatorio de filas secundarias por cada nivel en una estructura jerárquica correctamente vinculada. Una vez que esta estructura está lista, es fácil agregarle información adicional, como nombres de archivos y carpetas.

Entonces, quería generar una tabla clásica para almacenar un árbol:

ID int NOT NULL
ParentID int NULL
Lvl int NOT NULL

Como estamos lidiando con la recursividad, el CTE recursivo parece una opción natural.

Necesitaré una tabla de números . Los números en la tabla debe comenzar desde 1. Debe haber por lo menos 20 números en la tabla: MAX(LvlMax).

CREATE TABLE [dbo].[Numbers](
    [Number] [int] NOT NULL,
CONSTRAINT [PK_Numbers] PRIMARY KEY CLUSTERED 
(
    [Number] ASC
));

INSERT INTO Numbers(Number)
SELECT TOP(1000)
    ROW_NUMBER() OVER(ORDER BY S.object_id)  AS Number
FROM
    sys.all_objects AS S
ORDER BY Number;

Los parámetros para la generación de datos deben almacenarse en una tabla:

DECLARE @Intervals TABLE (Lvl int, LvlMin int, LvlMax int);
INSERT INTO @Intervals (Lvl, LvlMin, LvlMax) VALUES
(1, 5, 20),
(2, 1, 10),
(3, 1, 5);

Tenga en cuenta que la consulta es bastante flexible y todos los parámetros están separados en un solo lugar. Puede agregar más niveles si es necesario, solo agregue una fila adicional de parámetros.

Para realizar dicha generación dinámica posible que tuve que recordar el número al azar de filas para el siguiente nivel, así que tengo una columna adicional ChildRowCount.

Generar únicos IDs también es algo complicado. Codifiqué el límite de 100 filas secundarias por 1 fila principal para garantizar que IDsno se repita. De esto POWER(100, CTE.Lvl)se trata. Como resultado, hay grandes brechas en IDs. Ese número podría ser un MAX(LvlMax), pero puse constante 100 en la consulta por simplicidad. El número de niveles no está codificado, pero está determinado por @Intervals.

Esta formula

CAST(CRYPT_GEN_RANDOM(4) as int) / 4294967295.0 + 0.5

genera un número aleatorio de coma flotante en el rango [0..1), que luego se escala al intervalo requerido.

La lógica de consulta es simple. Es recursivo. El primer paso genera un conjunto de filas del primer nivel. El número de filas está determinado por un número aleatorio en TOP. Además, para cada fila hay un número aleatorio separado de filas secundarias almacenadas ChildRowCount.

La parte recursiva se utiliza CROSS APPLYpara generar un número determinado de filas secundarias por cada fila principal. Tuve que usar en WHERE Numbers.Number <= CTE.ChildRowCountlugar de TOP(CTE.ChildRowCount), porque TOPno está permitido en la parte recursiva de CTE. No sabía sobre esta limitación de SQL Server antes.

WHERE CTE.ChildRowCount IS NOT NULL detiene la recursividad

Violín de SQL

WITH
CTE
AS
(
    SELECT 
        TOP(CAST(
            (CAST(CRYPT_GEN_RANDOM(4) as int) / 4294967295.0 + 0.5) * 
            (
                1 + (SELECT I.LvlMax FROM @Intervals AS I WHERE I.Lvl = 1)
                  - (SELECT I.LvlMin FROM @Intervals AS I WHERE I.Lvl = 1)
            )
            + (SELECT I.LvlMin FROM @Intervals AS I WHERE I.Lvl = 1)
            AS int))
        Numbers.Number AS ID
        ,NULL AS ParentID
        ,1 AS Lvl
        ,CAST(
            (CAST(CRYPT_GEN_RANDOM(4) as int) / 4294967295.0 + 0.5) * 
            (
                1 + (SELECT I.LvlMax FROM @Intervals AS I WHERE I.Lvl = 2)
                  - (SELECT I.LvlMin FROM @Intervals AS I WHERE I.Lvl = 2)
            )
            + (SELECT I.LvlMin FROM @Intervals AS I WHERE I.Lvl = 2)
            AS int) AS ChildRowCount
    FROM Numbers
    ORDER BY Numbers.Number

    UNION ALL

    SELECT
        CA.Number + CTE.ID * POWER(100, CTE.Lvl) AS ID
        ,CTE.ID AS ParentID
        ,CTE.Lvl + 1 AS Lvl
        ,CA.ChildRowCount
    FROM
        CTE
        CROSS APPLY
        (
            SELECT
                Numbers.Number
                ,CAST(
                    (CAST(CRYPT_GEN_RANDOM(4) as int) / 4294967295.0 + 0.5) * 
                    (
                    1 + (SELECT I.LvlMax FROM @Intervals AS I WHERE I.Lvl = CTE.Lvl + 2)
                      - (SELECT I.LvlMin FROM @Intervals AS I WHERE I.Lvl = CTE.Lvl + 2)
                    )
                    + (SELECT I.LvlMin FROM @Intervals AS I WHERE I.Lvl = CTE.Lvl + 2)
                    AS int) AS ChildRowCount
            FROM Numbers
            WHERE Numbers.Number <= CTE.ChildRowCount
        ) AS CA
    WHERE
        CTE.ChildRowCount IS NOT NULL
)
SELECT *
FROM CTE
ORDER BY Lvl, ParentID, ID;

Resultado (puede haber hasta 20 + 20 * 10 + 200 * 5 = 1220 filas si tiene suerte)

+---------+----------+-----+-------------------+
|   ID    | ParentID | Lvl | ChildRowCount     |
+---------+----------+-----+-------------------+
|       1 | NULL     |   1 | 3                 |
|       2 | NULL     |   1 | 1                 |
|       3 | NULL     |   1 | 6                 |
|       4 | NULL     |   1 | 5                 |
|       5 | NULL     |   1 | 3                 |
|       6 | NULL     |   1 | 7                 |
|       7 | NULL     |   1 | 1                 |
|       8 | NULL     |   1 | 6                 |
|     101 | 1        |   2 | 3                 |
|     102 | 1        |   2 | 5                 |
|     103 | 1        |   2 | 1                 |
|     201 | 2        |   2 | 5                 |
|     301 | 3        |   2 | 4                 |
|     302 | 3        |   2 | 5                 |
|     303 | 3        |   2 | 1                 |
|     304 | 3        |   2 | 2                 |
|     305 | 3        |   2 | 4                 |
|     306 | 3        |   2 | 3                 |
|     401 | 4        |   2 | 3                 |
|     402 | 4        |   2 | 1                 |
|     403 | 4        |   2 | 2                 |
|     404 | 4        |   2 | 2                 |
|     405 | 4        |   2 | 4                 |
|     501 | 5        |   2 | 1                 |
|     502 | 5        |   2 | 3                 |
|     503 | 5        |   2 | 5                 |
|     601 | 6        |   2 | 2                 |
|     602 | 6        |   2 | 5                 |
|     603 | 6        |   2 | 3                 |
|     604 | 6        |   2 | 3                 |
|     605 | 6        |   2 | 4                 |
|     606 | 6        |   2 | 5                 |
|     607 | 6        |   2 | 4                 |
|     701 | 7        |   2 | 2                 |
|     801 | 8        |   2 | 2                 |
|     802 | 8        |   2 | 3                 |
|     803 | 8        |   2 | 3                 |
|     804 | 8        |   2 | 3                 |
|     805 | 8        |   2 | 5                 |
|     806 | 8        |   2 | 2                 |
| 1010001 | 101      |   3 | NULL              |
| 1010002 | 101      |   3 | NULL              |
| 1010003 | 101      |   3 | NULL              |
| 1020001 | 102      |   3 | NULL              |
| 1020002 | 102      |   3 | NULL              |
| 1020003 | 102      |   3 | NULL              |
| 1020004 | 102      |   3 | NULL              |
| 1020005 | 102      |   3 | NULL              |
| 1030001 | 103      |   3 | NULL              |
| 2010001 | 201      |   3 | NULL              |
| 2010002 | 201      |   3 | NULL              |
| 2010003 | 201      |   3 | NULL              |
| 2010004 | 201      |   3 | NULL              |
| 2010005 | 201      |   3 | NULL              |
| 3010001 | 301      |   3 | NULL              |
| 3010002 | 301      |   3 | NULL              |
| 3010003 | 301      |   3 | NULL              |
| 3010004 | 301      |   3 | NULL              |
| 3020001 | 302      |   3 | NULL              |
| 3020002 | 302      |   3 | NULL              |
| 3020003 | 302      |   3 | NULL              |
| 3020004 | 302      |   3 | NULL              |
| 3020005 | 302      |   3 | NULL              |
| 3030001 | 303      |   3 | NULL              |
| 3040001 | 304      |   3 | NULL              |
| 3040002 | 304      |   3 | NULL              |
| 3050001 | 305      |   3 | NULL              |
| 3050002 | 305      |   3 | NULL              |
| 3050003 | 305      |   3 | NULL              |
| 3050004 | 305      |   3 | NULL              |
| 3060001 | 306      |   3 | NULL              |
| 3060002 | 306      |   3 | NULL              |
| 3060003 | 306      |   3 | NULL              |
| 4010001 | 401      |   3 | NULL              |
| 4010002 | 401      |   3 | NULL              |
| 4010003 | 401      |   3 | NULL              |
| 4020001 | 402      |   3 | NULL              |
| 4030001 | 403      |   3 | NULL              |
| 4030002 | 403      |   3 | NULL              |
| 4040001 | 404      |   3 | NULL              |
| 4040002 | 404      |   3 | NULL              |
| 4050001 | 405      |   3 | NULL              |
| 4050002 | 405      |   3 | NULL              |
| 4050003 | 405      |   3 | NULL              |
| 4050004 | 405      |   3 | NULL              |
| 5010001 | 501      |   3 | NULL              |
| 5020001 | 502      |   3 | NULL              |
| 5020002 | 502      |   3 | NULL              |
| 5020003 | 502      |   3 | NULL              |
| 5030001 | 503      |   3 | NULL              |
| 5030002 | 503      |   3 | NULL              |
| 5030003 | 503      |   3 | NULL              |
| 5030004 | 503      |   3 | NULL              |
| 5030005 | 503      |   3 | NULL              |
| 6010001 | 601      |   3 | NULL              |
| 6010002 | 601      |   3 | NULL              |
| 6020001 | 602      |   3 | NULL              |
| 6020002 | 602      |   3 | NULL              |
| 6020003 | 602      |   3 | NULL              |
| 6020004 | 602      |   3 | NULL              |
| 6020005 | 602      |   3 | NULL              |
| 6030001 | 603      |   3 | NULL              |
| 6030002 | 603      |   3 | NULL              |
| 6030003 | 603      |   3 | NULL              |
| 6040001 | 604      |   3 | NULL              |
| 6040002 | 604      |   3 | NULL              |
| 6040003 | 604      |   3 | NULL              |
| 6050001 | 605      |   3 | NULL              |
| 6050002 | 605      |   3 | NULL              |
| 6050003 | 605      |   3 | NULL              |
| 6050004 | 605      |   3 | NULL              |
| 6060001 | 606      |   3 | NULL              |
| 6060002 | 606      |   3 | NULL              |
| 6060003 | 606      |   3 | NULL              |
| 6060004 | 606      |   3 | NULL              |
| 6060005 | 606      |   3 | NULL              |
| 6070001 | 607      |   3 | NULL              |
| 6070002 | 607      |   3 | NULL              |
| 6070003 | 607      |   3 | NULL              |
| 6070004 | 607      |   3 | NULL              |
| 7010001 | 701      |   3 | NULL              |
| 7010002 | 701      |   3 | NULL              |
| 8010001 | 801      |   3 | NULL              |
| 8010002 | 801      |   3 | NULL              |
| 8020001 | 802      |   3 | NULL              |
| 8020002 | 802      |   3 | NULL              |
| 8020003 | 802      |   3 | NULL              |
| 8030001 | 803      |   3 | NULL              |
| 8030002 | 803      |   3 | NULL              |
| 8030003 | 803      |   3 | NULL              |
| 8040001 | 804      |   3 | NULL              |
| 8040002 | 804      |   3 | NULL              |
| 8040003 | 804      |   3 | NULL              |
| 8050001 | 805      |   3 | NULL              |
| 8050002 | 805      |   3 | NULL              |
| 8050003 | 805      |   3 | NULL              |
| 8050004 | 805      |   3 | NULL              |
| 8050005 | 805      |   3 | NULL              |
| 8060001 | 806      |   3 | NULL              |
| 8060002 | 806      |   3 | NULL              |
+---------+----------+-----+-------------------+

Generando ruta completa en lugar de jerarquía vinculada

Si estamos interesados ​​solo en los Nniveles de ruta completos profundos, podemos omitir IDy ParentIDdesde el CTE. Si tenemos una lista de posibles nombres en la tabla complementaria Names, es fácil elegirlos de esta tabla en CTE. La Namestabla debe tener suficientes filas para cada nivel: 20 para el nivel 1, 10 para el nivel 2, 5 para el nivel 3; 20 + 10 + 5 = 35 en total. No es necesario tener diferentes conjuntos de filas para cada nivel, pero es fácil configurarlo correctamente, así que lo hice.

DECLARE @Names TABLE (Lvl int, Name nvarchar(4000), SeqNumber int);

-- First level: AAA, BBB, CCC, etc.
INSERT INTO @Names (Lvl, Name, SeqNumber)
SELECT 1, REPLICATE(CHAR(Number+64), 3) AS Name, Number AS SeqNumber
FROM Numbers
WHERE Number <= 20;

-- Second level: 001, 002, 003, etc.
INSERT INTO @Names (Lvl, Name, SeqNumber)
SELECT 2, REPLACE(STR(Number, 3), ' ', '0') AS Name, Number AS SeqNumber
FROM Numbers
WHERE Number <= 10;

-- Third level: I, II, III, IV, V
INSERT INTO @Names (Lvl, Name, SeqNumber) VALUES
(3, 'I',   1),
(3, 'II',  2),
(3, 'III', 3),
(3, 'IV',  4),
(3, 'V',   5);

SQL Fiddle Aquí está la consulta final. Lo dividí FullPathen FilePathy FileName.

WITH
CTE
AS
(
    SELECT 
        TOP(CAST(
            (CAST(CRYPT_GEN_RANDOM(4) as int) / 4294967295.0 + 0.5) * 
            (
                1 + (SELECT I.LvlMax FROM @Intervals AS I WHERE I.Lvl = 1)
                  - (SELECT I.LvlMin FROM @Intervals AS I WHERE I.Lvl = 1)
            )
            + (SELECT I.LvlMin FROM @Intervals AS I WHERE I.Lvl = 1)
            AS int))

        1 AS Lvl
        ,CAST(
            (CAST(CRYPT_GEN_RANDOM(4) as int) / 4294967295.0 + 0.5) * 
            (
                1 + (SELECT I.LvlMax FROM @Intervals AS I WHERE I.Lvl = 2)
                  - (SELECT I.LvlMin FROM @Intervals AS I WHERE I.Lvl = 2)
            )
            + (SELECT I.LvlMin FROM @Intervals AS I WHERE I.Lvl = 2)
            AS int) AS ChildRowCount
        ,N.Name AS FullPath
        ,N.Name AS [FilePath]
        ,CAST(N'' AS nvarchar(4000)) AS [FileName]
    FROM
        Numbers
        INNER JOIN @Names AS N ON 
            N.SeqNumber = Numbers.Number AND N.Lvl = 1
    ORDER BY Numbers.Number

    UNION ALL

    SELECT
        CTE.Lvl + 1 AS Lvl
        ,CA.ChildRowCount
        ,CTE.FullPath + '\' + CA.Name AS FullPath

        ,CASE WHEN CA.ChildRowCount IS NOT NULL 
            THEN CTE.FullPath + '\' + CA.Name
            ELSE CTE.FullPath END AS [FilePath]

        ,CASE WHEN CA.ChildRowCount IS NULL 
            THEN CA.Name
            ELSE N'' END AS [FileName]
    FROM
        CTE
        CROSS APPLY
        (
            SELECT
                Numbers.Number
                ,CAST(
                    (CAST(CRYPT_GEN_RANDOM(4) as int) / 4294967295.0 + 0.5) * 
                    (
                    1 + (SELECT I.LvlMax FROM @Intervals AS I WHERE I.Lvl = CTE.Lvl + 2)
                      - (SELECT I.LvlMin FROM @Intervals AS I WHERE I.Lvl = CTE.Lvl + 2)
                    )
                    + (SELECT I.LvlMin FROM @Intervals AS I WHERE I.Lvl = CTE.Lvl + 2)
                    AS int) AS ChildRowCount
                ,N.Name
            FROM
                Numbers
                INNER JOIN @Names AS N ON 
                    N.SeqNumber = Numbers.Number AND N.Lvl = CTE.Lvl + 1
            WHERE Numbers.Number <= CTE.ChildRowCount
        ) AS CA
    WHERE
        CTE.ChildRowCount IS NOT NULL
)
SELECT
    CTE.FullPath
    ,CTE.[FilePath]
    ,CTE.[FileName]
FROM CTE
WHERE CTE.ChildRowCount IS NULL
ORDER BY FullPath;

Resultado

+-------------+----------+----------+
|  FullPath   | FilePath | FileName |
+-------------+----------+----------+
| AAA\001\I   | AAA\001  | I        |
| AAA\001\II  | AAA\001  | II       |
| AAA\002\I   | AAA\002  | I        |
| AAA\002\II  | AAA\002  | II       |
| AAA\002\III | AAA\002  | III      |
| AAA\002\IV  | AAA\002  | IV       |
| AAA\002\V   | AAA\002  | V        |
| AAA\003\I   | AAA\003  | I        |
| AAA\003\II  | AAA\003  | II       |
| AAA\003\III | AAA\003  | III      |
| AAA\004\I   | AAA\004  | I        |
| AAA\004\II  | AAA\004  | II       |
| AAA\004\III | AAA\004  | III      |
| AAA\004\IV  | AAA\004  | IV       |
| BBB\001\I   | BBB\001  | I        |
| BBB\001\II  | BBB\001  | II       |
| CCC\001\I   | CCC\001  | I        |
| CCC\001\II  | CCC\001  | II       |
| CCC\001\III | CCC\001  | III      |
| CCC\001\IV  | CCC\001  | IV       |
| CCC\001\V   | CCC\001  | V        |
| CCC\002\I   | CCC\002  | I        |
| CCC\003\I   | CCC\003  | I        |
| CCC\003\II  | CCC\003  | II       |
| CCC\004\I   | CCC\004  | I        |
| CCC\004\II  | CCC\004  | II       |
| CCC\005\I   | CCC\005  | I        |
| CCC\005\II  | CCC\005  | II       |
| CCC\005\III | CCC\005  | III      |
| CCC\006\I   | CCC\006  | I        |
| CCC\006\II  | CCC\006  | II       |
| CCC\006\III | CCC\006  | III      |
| CCC\006\IV  | CCC\006  | IV       |
| CCC\007\I   | CCC\007  | I        |
| CCC\007\II  | CCC\007  | II       |
| CCC\007\III | CCC\007  | III      |
| CCC\007\IV  | CCC\007  | IV       |
| CCC\008\I   | CCC\008  | I        |
| CCC\008\II  | CCC\008  | II       |
| CCC\008\III | CCC\008  | III      |
| CCC\009\I   | CCC\009  | I        |
| CCC\009\II  | CCC\009  | II       |
| CCC\009\III | CCC\009  | III      |
| CCC\009\IV  | CCC\009  | IV       |
| CCC\010\I   | CCC\010  | I        |
| CCC\010\II  | CCC\010  | II       |
| CCC\010\III | CCC\010  | III      |
| DDD\001\I   | DDD\001  | I        |
| DDD\001\II  | DDD\001  | II       |
| DDD\001\III | DDD\001  | III      |
| DDD\001\IV  | DDD\001  | IV       |
| DDD\002\I   | DDD\002  | I        |
| DDD\003\I   | DDD\003  | I        |
| DDD\003\II  | DDD\003  | II       |
| DDD\003\III | DDD\003  | III      |
| DDD\003\IV  | DDD\003  | IV       |
| DDD\004\I   | DDD\004  | I        |
| DDD\004\II  | DDD\004  | II       |
| DDD\004\III | DDD\004  | III      |
| DDD\005\I   | DDD\005  | I        |
| DDD\006\I   | DDD\006  | I        |
| DDD\006\II  | DDD\006  | II       |
| DDD\006\III | DDD\006  | III      |
| DDD\007\I   | DDD\007  | I        |
| DDD\007\II  | DDD\007  | II       |
| DDD\008\I   | DDD\008  | I        |
| DDD\008\II  | DDD\008  | II       |
| DDD\008\III | DDD\008  | III      |
| DDD\009\I   | DDD\009  | I        |
| DDD\009\II  | DDD\009  | II       |
| DDD\010\I   | DDD\010  | I        |
| DDD\010\II  | DDD\010  | II       |
| DDD\010\III | DDD\010  | III      |
| DDD\010\IV  | DDD\010  | IV       |
| DDD\010\V   | DDD\010  | V        |
| EEE\001\I   | EEE\001  | I        |
| EEE\001\II  | EEE\001  | II       |
| FFF\001\I   | FFF\001  | I        |
| FFF\002\I   | FFF\002  | I        |
| FFF\002\II  | FFF\002  | II       |
| FFF\003\I   | FFF\003  | I        |
| FFF\003\II  | FFF\003  | II       |
| FFF\003\III | FFF\003  | III      |
| FFF\003\IV  | FFF\003  | IV       |
| FFF\003\V   | FFF\003  | V        |
| FFF\004\I   | FFF\004  | I        |
| FFF\004\II  | FFF\004  | II       |
| FFF\004\III | FFF\004  | III      |
| FFF\004\IV  | FFF\004  | IV       |
| FFF\005\I   | FFF\005  | I        |
| FFF\006\I   | FFF\006  | I        |
| FFF\007\I   | FFF\007  | I        |
| FFF\007\II  | FFF\007  | II       |
| FFF\007\III | FFF\007  | III      |
| GGG\001\I   | GGG\001  | I        |
| GGG\001\II  | GGG\001  | II       |
| GGG\001\III | GGG\001  | III      |
| GGG\002\I   | GGG\002  | I        |
| GGG\003\I   | GGG\003  | I        |
| GGG\003\II  | GGG\003  | II       |
| GGG\003\III | GGG\003  | III      |
| GGG\004\I   | GGG\004  | I        |
| GGG\004\II  | GGG\004  | II       |
| HHH\001\I   | HHH\001  | I        |
| HHH\001\II  | HHH\001  | II       |
| HHH\001\III | HHH\001  | III      |
| HHH\002\I   | HHH\002  | I        |
| HHH\002\II  | HHH\002  | II       |
| HHH\002\III | HHH\002  | III      |
| HHH\002\IV  | HHH\002  | IV       |
| HHH\002\V   | HHH\002  | V        |
| HHH\003\I   | HHH\003  | I        |
| HHH\003\II  | HHH\003  | II       |
| HHH\003\III | HHH\003  | III      |
| HHH\003\IV  | HHH\003  | IV       |
| HHH\003\V   | HHH\003  | V        |
| HHH\004\I   | HHH\004  | I        |
| HHH\004\II  | HHH\004  | II       |
| HHH\004\III | HHH\004  | III      |
| HHH\004\IV  | HHH\004  | IV       |
| HHH\004\V   | HHH\004  | V        |
| HHH\005\I   | HHH\005  | I        |
| HHH\005\II  | HHH\005  | II       |
| HHH\005\III | HHH\005  | III      |
| HHH\005\IV  | HHH\005  | IV       |
| HHH\005\V   | HHH\005  | V        |
| HHH\006\I   | HHH\006  | I        |
| HHH\007\I   | HHH\007  | I        |
| HHH\007\II  | HHH\007  | II       |
| HHH\007\III | HHH\007  | III      |
| HHH\008\I   | HHH\008  | I        |
| HHH\008\II  | HHH\008  | II       |
| HHH\008\III | HHH\008  | III      |
| HHH\008\IV  | HHH\008  | IV       |
| HHH\008\V   | HHH\008  | V        |
+-------------+----------+----------+
— Vladimir Baranov
fuente
Enfoque interesante :). Me gusta. En aras de la exhaustividad, ¿puede agregar la consulta para completar la tabla de Números (desde el Fiddle de SQL), o simplemente incluir esa línea como parte del CTE? Entonces es más fácil para alguien copiar y pegar. Para esta respuesta, ¿se puede expresar el resultado final como cada fila que es una ruta completa desde el Nivel1 hasta el Nivel3 para todos los valores de Nivel3? Creo que eso tomaría solo 2 INNER JOINs en la final SELECT. Finalmente, ¿se pueden asignar nombres / etiquetas a cada nodo para que no sean solo números? Actualizaré la pregunta para aclarar ambos puntos.
— Solomon Rutzky
¿De dónde vienen estos nombres / etiquetas? ¿Debería tener una tabla de 'Nombres', que tiene 20 filas y elegir un nombre? Por lo tanto, el mismo conjunto de nombres aparecería en cada nivel. ¿O debería cada nivel tener su propio conjunto separado de nombres?
— Vladimir Baranov
Creo que los nombres pueden provenir de una tabla (temporal, real o variable) o en línea como parte del CTE. Originalmente los puse en el CTE pero luego los moví a una tabla temporal local para que la parte principal de la consulta fuera más legible aquí. Creo que con la estructura que tiene, sería bastante fácil tener separados por nivel. Pero si solo fuera un conjunto de 20 que también sería suficiente, solo proporcionaría una variación ligeramente menor en los datos de prueba. El único requisito verdadero es que no se repita ningún nombre dentro de un nodo, ya que sería un error al intentar crear los directorios o archivos :).
— Solomon Rutzky
1
@srutzky, agregué una segunda variante.
— Vladimir Baranov
1
@srutzky, me dividí FullPathen FilePathy FileName.
— Vladimir Baranov
4

Así que aquí está lo que se me ocurrió. Con el objetivo de crear una estructura de directorios, estaba buscando "nombres" utilizables para los directorios y archivos. Debido a que no pude TOP(n)trabajar en el CROSS APPLYs (creo que intenté correlacionar las consultas usando un valor del padre como nen el TOP(n)pero no fue al azar), decidí crear un tipo de "números" tabla que permitiría que una condición INNER JOINo WHEREproduzca un conjunto de nelementos simplemente aleatorizando un número y especificándolo como WHERE table.Level = random_number. El truco es que solo hay 1 fila para el Nivel 1, 2 filas para el Nivel 2, 3 filas para el Nivel 3, y así sucesivamente. Por lo tanto, usar WHERE LevelID = 3me dará 3 filas, y cada fila tiene un valor que puedo usar como nombre de directorio.

PREPARAR

Esta parte se especificó originalmente en línea, como parte del CTE. Pero en aras de la legibilidad (para que no necesite desplazarse a través de muchas INSERTdeclaraciones para llegar a las pocas líneas de la consulta real), lo dividí en una tabla temporal local.

IF (OBJECT_ID(N'tempdb..#Elements') IS NULL)
BEGIN
  PRINT 'Creating #Elements table...';
  CREATE TABLE #Elements (
     ElementLevel TINYINT NOT NULL,
     LevelName NVARCHAR(50) NOT NULL
                         );

  PRINT 'Populating #Elements table...';
  INSERT INTO #Elements (ElementLevel, LevelName)
    SELECT tmp.[Level], tmp.[Name]
    FROM (
                  SELECT 1,  N'Ella'
       UNION ALL  SELECT 2,  N'Itchy'
       UNION ALL  SELECT 2,  N'Scratchy'
       UNION ALL  SELECT 3,  N'Moe'
       UNION ALL  SELECT 3,  N'Larry'
       UNION ALL  SELECT 3,  N'Curly'
       UNION ALL  SELECT 4,  N'Ian'
       UNION ALL  SELECT 4,  N'Stephen'
       UNION ALL  SELECT 4,  N'Peter'
       UNION ALL  SELECT 4,  N'Bernard'
       UNION ALL  SELECT 5,  N'Michigan'
       UNION ALL  SELECT 5,  N'Erie'
       UNION ALL  SELECT 5,  N'Huron'
       UNION ALL  SELECT 5,  N'Ontario'
       UNION ALL  SELECT 5,  N'Superior'
       UNION ALL  SELECT 6,  N'White'
       UNION ALL  SELECT 6,  N'Orange'
       UNION ALL  SELECT 6,  N'Blonde'
       UNION ALL  SELECT 6,  N'Pink'
       UNION ALL  SELECT 6,  N'Blue'
       UNION ALL  SELECT 6,  N'Brown'
       UNION ALL  SELECT 7,  N'Asia'
       UNION ALL  SELECT 7,  N'Africa'
       UNION ALL  SELECT 7,  N'North America'
       UNION ALL  SELECT 7,  N'South America'
       UNION ALL  SELECT 7,  N'Antarctica'
       UNION ALL  SELECT 7,  N'Europe'
       UNION ALL  SELECT 7,  N'Australia'
       UNION ALL  SELECT 8,  N'AA'
       UNION ALL  SELECT 8,  N'BB'
       UNION ALL  SELECT 8,  N'CC'
       UNION ALL  SELECT 8,  N'DD'
       UNION ALL  SELECT 8,  N'EE'
       UNION ALL  SELECT 8,  N'FF'
       UNION ALL  SELECT 8,  N'GG'
       UNION ALL  SELECT 8,  N'HH'
       UNION ALL  SELECT 9,  N'I'
       UNION ALL  SELECT 9,  N'II'
       UNION ALL  SELECT 9,  N'III'
       UNION ALL  SELECT 9,  N'IV'
       UNION ALL  SELECT 9,  N'V'
       UNION ALL  SELECT 9,  N'VI'
       UNION ALL  SELECT 9,  N'VII'
       UNION ALL  SELECT 9,  N'VIII'
       UNION ALL  SELECT 9,  N'IX'
       UNION ALL  SELECT 10, N'Million'
       UNION ALL  SELECT 10, N'Billion'
       UNION ALL  SELECT 10, N'Trillion'
       UNION ALL  SELECT 10, N'Quadrillion'
       UNION ALL  SELECT 10, N'Quintillion'
       UNION ALL  SELECT 10, N'Sestillion'
       UNION ALL  SELECT 10, N'Sextillion'
       UNION ALL  SELECT 10, N'Octillion'
       UNION ALL  SELECT 10, N'Nonillion'
       UNION ALL  SELECT 10, N'Decillion'
     ) tmp([Level], [Name]);
END;

CONSULTA PRINCIPAL

Para el Nivel 1, simplemente tomé [name]valores, sys.objectsya que siempre hay muchas filas allí. Pero, si necesitaba más control sobre los nombres, podría expandir la #Elementstabla para contener niveles adicionales.

;WITH topdir(Level1, Randy) AS
(
    SELECT TOP ( (CONVERT(INT, CRYPT_GEN_RANDOM(1)) % 20) + 5 ) so.[name],
                ( (CONVERT(INT, CRYPT_GEN_RANDOM(1)) % 10) + 1 )
    FROM sys.objects so
    ORDER BY CRYPT_GEN_RANDOM(8) ASC
)
SELECT  td.Level1, tmp1.Level2, tmp2.Level3
FROM    topdir td
CROSS APPLY (SELECT help.LevelName, (CONVERT(INT, CRYPT_GEN_RANDOM(1)) % 5) + 1
            FROM #Elements help
            WHERE help.ElementLevel = td.Randy
            ) tmp1 (Level2, Bandy)
CROSS APPLY (SELECT help.LevelName
            FROM #Elements help
            WHERE help.ElementLevel = tmp1.Bandy
            ) tmp2 (Level3);

CONSULTA ADAPTADA PARA PRODUCIR CADA RUTA, NOMBRE Y CONTENIDO DE ARCHIVO

Para generar las rutas completas para los archivos y el contenido del archivo, hice el SELECT principal del CTE simplemente otro CTE y agregué un nuevo SELECT principal que proporcionó las salidas adecuadas que simplemente necesitan ir a los archivos.

DECLARE @Template NVARCHAR(4000);
SET @Template = N'<?xml version="1.0" encoding="ISO-8859-1"?>
<ns0:P4131 xmlns:ns0="http://switching/xi">
<R000000>
    <R00000010>R000000</R00000010>
    <R00000020>I</R00000020>
    <R00000030>{{Tag30}}</R00000030>
    <R00000040>{{Tag40}}</R00000040>
    <R00000050>{{Tag50}}</R00000050>
    <R00000060>2</R00000060>
</R000000>
</ns0:P4131>
';


;WITH topdir(Level1, Thing1) AS
(
    SELECT TOP ( (CONVERT(INT, CRYPT_GEN_RANDOM(1)) % 20) + 5 ) so.[name],
                ( (CONVERT(INT, CRYPT_GEN_RANDOM(1)) % 10) + 1 )
    FROM sys.objects so
    ORDER BY CRYPT_GEN_RANDOM(8) ASC
), main AS
(
   SELECT  td.Level1, tmp1.Level2, tmp2.Level3,
           td.Level1 + N'\' + tmp1.Level2 AS [FullPath],
           RIGHT('000' + CONVERT(VARCHAR(10),
                          (CONVERT(INT, CRYPT_GEN_RANDOM(2)) % 9999) + 1), 4) AS [R30],
           RIGHT('000' + CONVERT(VARCHAR(10),
                          (CONVERT(INT, CRYPT_GEN_RANDOM(2)) % 500) + 100), 4) AS [R50],
           ROW_NUMBER() OVER(ORDER BY (SELECT NULL)) AS [RowNum]
   FROM    topdir td
   CROSS APPLY (SELECT help.LevelName, (CONVERT(INT, CRYPT_GEN_RANDOM(1)) % 5) + 1
                FROM #Elements help
                WHERE help.ElementLevel = td.Thing1
               ) tmp1 (Level2, Thing2)
   CROSS APPLY (SELECT help.LevelName
                FROM #Elements help
                WHERE help.ElementLevel = tmp1.Thing2
               ) tmp2 (Level3)
)
SELECT  mn.FullPath,
        mn.Level3 + N'.xml' AS [FileName],
        REPLACE(
            REPLACE(
                REPLACE(
                    @Template,
                    N'{{Tag30}}',
                    mn.R30),
                N'{{Tag40}}',
                mn.RowNum),
            N'{{Tag50}}',
            mn.R50) AS [Contents]
FROM    main mn;

CRÉDITO ADICIONAL

Si bien no forma parte de los requisitos establecidos en la pregunta, el objetivo (que se mencionó) era crear archivos para probar las funciones recursivas del Sistema de archivos. Entonces, ¿cómo tomamos este conjunto de resultados de nombres de ruta, nombres de archivo y contenido de archivo y hacemos algo con él? Solo necesitamos dos funciones SQLCLR: una para crear las carpetas y otra para crear los archivos.

Para que estos datos funcionen, modifiqué el principal SELECTdel CTE que se muestra directamente arriba de la siguiente manera:

SELECT  SQL#.File_CreateDirectory(
            N'C:\Stuff\TestXmlFiles\' + mn.FullPath) AS [CreateTheDirectory],
        SQL#.File_WriteFile(
            N'C:\Stuff\TestXmlFiles\' + mn.FullPath + N'\' + mn.Level3 + N'.xml',
            REPLACE(
                REPLACE(
                    REPLACE(
                        @Template,
                        N'{{Tag30}}',
                        mn.R30),
                    N'{{Tag40}}',
                    mn.RowNum),
                N'{{Tag50}}',
                mn.R50), -- @FileData
            0, -- @AppendData
            '' -- @FileEncoding
                            ) AS [WriteTheFile]
FROM    main mn;
— Solomon Rutzky
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.